@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/analytics/structured-data-merchant-return-policy-auditor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - StructuredDataMerchantReturnPolicyAuditor
+ * Validates Schema.org MerchantReturnPolicy structured data for Google Shopping
+ * free product listings, return window badges, and merchant policy compliance.
+ */
+export interface MerchantReturnPolicyInput {
+    applicableCountry?: string;
+    returnPolicyCategory?: "https://schema.org/MerchantReturnFiniteReturnWindow" | "https://schema.org/MerchantReturnNotPermitted" | "https://schema.org/MerchantReturnUnlimitedWindow" | string;
+    merchantReturnDays?: number;
+    returnMethod?: "https://schema.org/ReturnByMail" | "https://schema.org/ReturnInStore" | "https://schema.org/ReturnAtKiosk" | string;
+    returnFees?: "https://schema.org/FreeReturn" | "https://schema.org/ReturnFeesCustomerResponsibility" | "https://schema.org/ReturnShippingFees" | string;
+    returnShippingCost?: number;
+    currency?: string;
+}
+export type MerchantReturnIssueType = "missing_applicable_country" | "missing_return_policy_category" | "missing_return_days_for_finite_window" | "negative_or_zero_return_days" | "missing_return_method" | "missing_return_fees" | "invalid_country_code";
+export interface ReturnPolicyFinding {
+    issue: MerchantReturnIssueType;
+    severity: "critical" | "warning" | "info";
+    description: string;
+    recommendation: string;
+}
+export interface ReturnPolicyAuditReport {
+    isEligibleForGoogleShopping: boolean;
+    score: number;
+    applicableCountry?: string;
+    returnDays?: number;
+    findings: ReturnPolicyFinding[];
+    generatedValidJsonLd: object;
+    recommendations: string[];
+}
+export declare class StructuredDataMerchantReturnPolicyAuditor {
+    private static readonly VALID_CATEGORIES;
+    /**
+     * Audits MerchantReturnPolicy properties for Google Shopping rich result eligibility.
+     */
+    audit(input: MerchantReturnPolicyInput): ReturnPolicyAuditReport;
+}

package/dist/analytics/structured-data-rich-results-eligibility-auditor.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Structured Data Rich Results Eligibility Auditor (Batch 19 - Gap 2)
+ *
+ * Google Search Rich Results validator inspired by Google Search Console
+ * Rich Results Test, Schema.org Validator & Merkle Schema Generator.
+ *
+ * Validates Product, Article, FAQPage, BreadcrumbList, and Event schemas
+ * against strict Google Search requirements. Distinguishes mandatory disqualifying errors
+ * from non-critical recommended warnings to protect SERP enhanced snippets.
+ */
+export type RichResultType = "Product" | "Article" | "NewsArticle" | "BlogPosting" | "FAQPage" | "BreadcrumbList" | "Event" | "JobPosting" | "Unknown";
+export type EligibilityVerdict = "eligible" | "eligible_with_warnings" | "ineligible";
+export interface SchemaValidationIssue {
+    fieldPath: string;
+    severity: "error" | "warning";
+    message: string;
+}
+export interface DetectedSchemaEntityAudit {
+    schemaType: RichResultType;
+    verdict: EligibilityVerdict;
+    mandatoryFieldsPassed: string[];
+    issues: SchemaValidationIssue[];
+}
+export interface RichResultsAuditReport {
+    totalSchemasFound: number;
+    overallEligibilityVerdict: EligibilityVerdict;
+    eligibleFeatureCards: string[];
+    entities: DetectedSchemaEntityAudit[];
+    criticalErrorsCount: number;
+    warningsCount: number;
+    remediationActionPlan: string[];
+}
+export declare class StructuredDataRichResultsEligibilityAuditor {
+    /**
+     * Parses JSON-LD content and evaluates Google Search rich results eligibility.
+     */
+    static auditJsonLd(rawJsonLd: string | Record<string, unknown> | unknown[]): RichResultsAuditReport;
+    private static extractEntities;
+    private static auditSingleEntity;
+    private static checkRequired;
+    private static checkRecommended;
+}

package/dist/analytics/structured-data-validation-aggregate-score-synthesizer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - StructuredDataValidationAggregateScoreSynthesizer
+ * Synthesizes cross-entity Schema.org JSON-LD audits into a single aggregate health score (0-100),
+ * weighting entities by their Google Rich Results commercial CTR impact, counting fatal validation errors,
+ * non-fatal warnings, and producing prioritized remediation steps.
+ */
+export interface SchemaEntityAuditItem {
+    entityType: string;
+    url: string;
+    isEligibleForRichResult: boolean;
+    criticalErrorsCount: number;
+    warningsCount: number;
+    missingRequiredFields: string[];
+    missingRecommendedFields: string[];
+}
+export interface SchemaTypeScoreSummary {
+    entityType: string;
+    totalInstances: number;
+    eligibleInstances: number;
+    eligibilityRate: number;
+    totalErrors: number;
+    totalWarnings: number;
+}
+export interface PrioritizedRemediationTask {
+    priority: "P0_CRITICAL" | "P1_HIGH" | "P2_MEDIUM";
+    entityType: string;
+    affectedUrlCount: number;
+    missingField: string;
+    impactDescription: string;
+}
+export interface StructuredDataAggregateReport {
+    totalEntitiesAudited: number;
+    overallHealthScore: number;
+    totalRichResultEligible: number;
+    globalEligibilityRate: number;
+    entityBreakdown: SchemaTypeScoreSummary[];
+    prioritizedTasks: PrioritizedRemediationTask[];
+    summary: string;
+}
+export declare class StructuredDataValidationAggregateScoreSynthesizer {
+    synthesize(entities: SchemaEntityAuditItem[]): StructuredDataAggregateReport;
+}

package/dist/analytics/subresource-integrity-cdn-tampering-auditor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - SubresourceIntegrityCdnTamperingAuditor
+ * Audits third-party scripts and stylesheets for Subresource Integrity (SRI) attributes,
+ * preventing CDN supply-chain tampering and malicious code injection.
+ */
+export interface ExternalResourceInput {
+    url: string;
+    tagType: "script" | "stylesheet";
+    pageUrl: string;
+    integrity?: string;
+    crossorigin?: string;
+}
+export type SriIssueType = "missing_sri_on_third_party_cdn" | "missing_crossorigin_attribute" | "weak_hash_algorithm" | "malformed_integrity_format" | "high_risk_unpinned_cdn_url";
+export interface SriResourceFinding {
+    resource: ExternalResourceInput;
+    isThirdParty: boolean;
+    issues: SriIssueType[];
+    severity: "critical" | "warning" | "info";
+    description: string;
+    recommendedTagSnippet: string;
+}
+export interface SriAuditSummary {
+    totalPagesScanned: number;
+    totalResourcesAudited: number;
+    thirdPartyResourcesCount: number;
+    resourcesWithValidSri: number;
+    sriComplianceRatePercent: number;
+    criticalTamperingRisksCount: number;
+    findings: SriResourceFinding[];
+}
+export declare class SubresourceIntegrityCdnTamperingAuditor {
+    private static readonly KNOWN_PUBLIC_CDNS;
+    /**
+     * Audits external resources for SRI compliance and supply-chain tampering vulnerability.
+     */
+    audit(resources: ExternalResourceInput[]): SriAuditSummary;
+    private checkIfThirdParty;
+    private buildDescription;
+    private buildRecommendedSnippet;
+}

package/dist/analytics/survey-branching-engine.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Dynamic Survey Branching Flow & Decision Tree Engine
+ * Clean-room implementation for deterministic survey question routing,
+ * conditional response paths, and DAG validation.
+ * Parity: PostHog Surveys Branching Flow & Typeform Logic Jumps.
+ */
+export type SurveyBranchingType = "next_question" | "end" | "specific_question" | "response_based";
+export interface SurveyBranchRule {
+    responseValue: string | number;
+    targetQuestionId: string | "end";
+}
+export interface SurveyQuestionNode {
+    id: string;
+    title: string;
+    type: "open_text" | "multiple_choice" | "rating" | "nps";
+    defaultBranchingType: SurveyBranchingType;
+    defaultTargetId?: string | "end";
+    responseRules?: SurveyBranchRule[];
+}
+export interface SurveyFlowEdge {
+    fromQuestionId: string;
+    toQuestionId: string | "end";
+    conditionLabel?: string;
+    isFallback: boolean;
+}
+export interface SurveyNavigationEvaluation {
+    currentQuestionId: string;
+    responseValue?: string | number;
+    nextQuestionId: string | "end";
+    matchedRuleReason: string;
+}
+export declare class SurveyBranchingEngine {
+    /**
+     * Evaluates the next question or survey end based on the user's answer.
+     */
+    static evaluateNextStep(question: SurveyQuestionNode, allQuestions: SurveyQuestionNode[], userResponse?: string | number): SurveyNavigationEvaluation;
+    /**
+     * Compiles questions into an explicit DAG / Edge list for visualization & validation.
+     */
+    static buildGraphEdges(questions: SurveyQuestionNode[]): {
+        edges: SurveyFlowEdge[];
+        hasCycles: boolean;
+        unreachableQuestionIds: string[];
+    };
+}

package/dist/analytics/survey-sentiment-driver-analyzer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 📊 Survey Sentiment & NPS / CSAT Driver Analyzer
+ * Clean-room implementation inspired by PostHog Surveys & Delighted customer intelligence.
+ *
+ * Computes official NPS (-100 to +100), CSAT (1-5), and Customer Effort Score (CES),
+ * performs lexical sentiment extraction on open-text feedback, and discovers top satisfaction & churn drivers.
+ *
+ * @license AGPL-3.0-or-later
+ */
+export interface SurveyFeedbackResponse {
+    responseId: string;
+    userId?: string;
+    score: number;
+    metricType: "nps" | "csat" | "ces";
+    comment?: string;
+    timestamp: number;
+    properties?: Record<string, unknown>;
+}
+export interface SentimentKeywordDriver {
+    keyword: string;
+    frequency: number;
+    sentiment: "positive" | "negative" | "neutral";
+    averageScoreAssociated: number;
+    sampleQuotes: string[];
+}
+export interface NpsBreakdown {
+    npsScore: number;
+    totalResponses: number;
+    promotersCount: number;
+    promotersShare: number;
+    passivesCount: number;
+    passivesShare: number;
+    detractorsCount: number;
+    detractorsShare: number;
+    healthGrade: "world_class" | "excellent" | "good" | "needs_improvement" | "critical";
+}
+export interface CsatBreakdown {
+    csatAverage: number;
+    satisfiedPercentage: number;
+    totalResponses: number;
+    distribution: Record<number, number>;
+}
+export interface SurveyAnalysisReport {
+    totalAnalyzed: number;
+    nps?: NpsBreakdown;
+    csat?: CsatBreakdown;
+    averageCommentSentimentPolarity: number;
+    commentsCount: number;
+    topPositiveDrivers: SentimentKeywordDriver[];
+    topDetractorPainPoints: SentimentKeywordDriver[];
+    actionableInsights: string[];
+}
+export declare class SurveySentimentDriverAnalyzer {
+    private static readonly POSITIVE_LEXICON;
+    private static readonly NEGATIVE_LEXICON;
+    /**
+     * Analyzes an array of survey responses and generates a comprehensive sentiment & driver report.
+     */
+    static analyze(responses: SurveyFeedbackResponse[]): SurveyAnalysisReport;
+    private static calculateCommentPolarity;
+    private static emptyReport;
+}

package/dist/analytics/tag-trigger-evaluator.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tag Manager Trigger & Variable Evaluator Runtime
+ *
+ * Implémentation clean-room conforme aux standards Matomo Tag Manager & Google Tag Manager.
+ * Évalue les déclencheurs (pageview, clic, scroll, form submit, custom event, timer)
+ * contre des variables et règles conditionnelles avec vérification du consentement RGPD.
+ */
+export type TriggerType = 'pageview' | 'dom_ready' | 'click' | 'scroll' | 'form_submit' | 'custom_event' | 'timer';
+export type TagFilterOperator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'matches_regex' | 'greater_than' | 'less_than' | 'matches_css_selector';
+export interface TagTriggerFilter {
+    variable: string;
+    operator: TagFilterOperator;
+    value: string | number | boolean;
+}
+export type TagExecutionRule = 'once_per_page' | 'once_per_event' | 'unlimited';
+export interface TagTriggerDefinition {
+    id: string;
+    name: string;
+    type: TriggerType;
+    filters?: TagTriggerFilter[];
+    executionRule?: TagExecutionRule;
+}
+export type TagConsentCategory = 'essential' | 'analytics' | 'marketing' | 'personalization';
+export interface TagDefinition {
+    id: string;
+    name: string;
+    triggerIds: string[];
+    consentCategory: TagConsentCategory;
+    priority?: number;
+    parameters?: Record<string, unknown>;
+    isEnabled?: boolean;
+}
+export interface EvaluationClickTarget {
+    tagName?: string;
+    className?: string;
+    id?: string;
+    href?: string;
+    text?: string;
+}
+export interface TagEvaluationContext {
+    eventType: TriggerType;
+    pageUrl: string;
+    pageTitle?: string;
+    referrer?: string;
+    clickTarget?: EvaluationClickTarget;
+    scrollDepthPercent?: number;
+    customEventName?: string;
+    dataLayer?: Record<string, unknown>;
+    userConsent: Partial<Record<TagConsentCategory, boolean>>;
+    firedTagHistory?: Record<string, number>;
+}
+export interface FiredTagResult {
+    tagId: string;
+    tagName: string;
+    priority: number;
+    consentCategory: TagConsentCategory;
+    matchedTriggerId: string;
+    parameters?: Record<string, unknown>;
+}
+export interface BlockedTagResult {
+    tagId: string;
+    tagName: string;
+    reason: 'consent_denied' | 'disabled' | 'execution_rule_limit' | 'no_trigger_matched';
+    details?: string;
+}
+export interface TagEvaluationResult {
+    eventType: TriggerType;
+    matchedTriggerIds: string[];
+    firedTags: FiredTagResult[];
+    blockedTags: BlockedTagResult[];
+    timestamp: number;
+}
+export declare class TagTriggerEvaluator {
+    /**
+     * Évalue les tags et déclencheurs configurés par rapport au contexte d'événement courant.
+     */
+    static evaluate(tags: TagDefinition[], triggers: TagTriggerDefinition[], context: TagEvaluationContext): TagEvaluationResult;
+    /**
+     * Vérifie si un déclencheur particulier matche le contexte
+     */
+    static evaluateTrigger(trigger: TagTriggerDefinition, context: TagEvaluationContext): boolean;
+    /**
+     * Résout la valeur d'une variable système ou dataLayer
+     */
+    static resolveVariable(varName: string, context: TagEvaluationContext): unknown;
+    /**
+     * Évalue un opérateur conditionnel sur une valeur résolue
+     */
+    static evaluateCondition(actual: unknown, operator: TagFilterOperator, expected: string | number | boolean): boolean;
+    private static getNestedProperty;
+}

package/dist/analytics/tasks-timetable-manager.d.ts

@@ -0,0 +1,62 @@
+/**
+ * LynxSEO Engine - Scheduled Tasks Timetable & Cron Lock Monitor
+ *
+ * Monitors background scheduled tasks, next run times, distributed locks,
+ * duration trends, and overdue warnings.
+ * (Parity: Matomo TasksTimetable).
+ */
+export interface ScheduledTaskDefinition {
+    id: string;
+    name: string;
+    description: string;
+    intervalMinutes: number;
+    priority: "high" | "normal" | "low";
+    lastRunStart?: string;
+    lastRunEnd?: string;
+    lastDurationMs?: number;
+    lastStatus?: "success" | "failure" | "running" | "skipped";
+    lastError?: string;
+}
+export interface TaskLockState {
+    taskId: string;
+    isLocked: boolean;
+    lockedBy?: string;
+    lockedAt?: string;
+    expiresAt?: string;
+}
+export interface CronTaskExecutionStatus {
+    task: ScheduledTaskDefinition;
+    nextRunEstimated: string;
+    isOverdue: boolean;
+    overdueMinutes: number;
+    lockState: TaskLockState;
+}
+export interface CronTasksTimetableReport {
+    totalTasks: number;
+    healthyTasks: number;
+    overdueTasks: number;
+    currentlyRunning: number;
+    tasks: CronTaskExecutionStatus[];
+}
+export declare class TasksTimetableManager {
+    private tasks;
+    private locks;
+    constructor(initialTasks?: ScheduledTaskDefinition[]);
+    registerTask(task: ScheduledTaskDefinition): void;
+    setLockState(lock: TaskLockState): void;
+    releaseLock(taskId: string): void;
+    /**
+     * Records the completion or failure of a scheduled task run.
+     */
+    recordRunResult(taskId: string, result: {
+        status: "success" | "failure" | "skipped";
+        durationMs: number;
+        startTime: string;
+        endTime: string;
+        error?: string;
+    }): void;
+    /**
+     * Generates a comprehensive timetable report with overdue diagnostics.
+     */
+    generateReport(now?: Date): CronTasksTimetableReport;
+}

package/dist/analytics/text-selection-tracker.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Text Selection & Copy Tracker
+ * Clean-room implementation inspired by OpenReplay and modern session replay tools.
+ * Tracks user selection, highlight, and copy events, redacting PII, and aggregating
+ * high-interest snippets, frequently copied documentation or errors, and friction points.
+ */
+export interface RawSelectionEvent {
+    id?: string;
+    timestamp: string | number;
+    url: string;
+    selector?: string;
+    rawText: string;
+    eventType: 'select' | 'copy' | 'contextmenu_copy';
+    durationMs?: number;
+}
+export interface SanitizedSelectionEvent {
+    id: string;
+    timestamp: string;
+    url: string;
+    selector: string;
+    sanitizedText: string;
+    eventType: 'select' | 'copy' | 'contextmenu_copy';
+    characterCount: number;
+    wordCount: number;
+    piiRedacted: boolean;
+    durationMs: number;
+}
+export interface SelectionSnippetSummary {
+    snippet: string;
+    selector: string;
+    url: string;
+    selectionCount: number;
+    copyCount: number;
+    averageDurationMs: number;
+    lastObserved: string;
+}
+export interface TextSelectionReport {
+    totalSelections: number;
+    totalCopies: number;
+    copyConversionRate: number;
+    averageSelectionLengthChars: number;
+    averageSelectionLengthWords: number;
+    topSnippets: SelectionSnippetSummary[];
+    topSelectors: {
+        selector: string;
+        count: number;
+    }[];
+}
+export declare class TextSelectionTracker {
+    private piiPatterns;
+    /**
+     * Sanitizes a text selection by scrubbing any PII and trimming whitespace.
+     */
+    sanitizeText(text: string): {
+        sanitized: string;
+        hadPii: boolean;
+    };
+    /**
+     * Ingests and standardizes raw selection/copy events.
+     */
+    processEvent(raw: RawSelectionEvent): SanitizedSelectionEvent;
+    /**
+     * Aggregates a batch of processed selection events into a comprehensive report.
+     */
+    generateReport(events: SanitizedSelectionEvent[]): TextSelectionReport;
+}

package/dist/analytics/third-party-script-cpu-execution-profiler.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ThirdPartyScriptCpuExecutionProfiler
+ * Profiles third-party JavaScript resource impact, categorizing by purpose
+ * (ads, analytics, customer chat, social, tag management), CPU execution time,
+ * main-thread blocking time, and web worker offload eligibility.
+ */
+export interface ThirdPartyScriptInput {
+    url: string;
+    byteSize: number;
+    cpuExecutionMs: number;
+    mainThreadBlockingMs: number;
+    isAsync?: boolean;
+    isDefer?: boolean;
+    isRenderBlocking?: boolean;
+}
+export type ThirdPartyCategory = "advertising" | "analytics_telemetry" | "customer_chat_support" | "social_widget" | "tag_manager_cmp" | "unknown_utility";
+export interface ThirdPartyCategorySummary {
+    category: ThirdPartyCategory;
+    scriptCount: number;
+    totalByteSize: number;
+    totalCpuMs: number;
+    totalBlockingMs: number;
+    percentageOfThirdPartyCpu: number;
+}
+export interface ThirdPartyScriptFinding {
+    url: string;
+    category: ThirdPartyCategory;
+    severity: "critical" | "warning" | "info";
+    description: string;
+    remediation: "facade_on_interaction" | "web_worker_partytown" | "defer_after_load" | "remove_redundant_tag";
+}
+export interface ThirdPartyProfileReport {
+    totalThirdPartyScripts: number;
+    totalBytes: number;
+    totalCpuTimeMs: number;
+    totalBlockingTimeMs: number;
+    healthScore: number;
+    categorySummaries: ThirdPartyCategorySummary[];
+    findings: ThirdPartyScriptFinding[];
+    facadeRecommendations: string[];
+}
+export declare class ThirdPartyScriptCpuExecutionProfiler {
+    private static readonly CATEGORY_PATTERNS;
+    /**
+     * Profiles third-party script assets and calculates main thread CPU impact.
+     */
+    profile(scripts: ThirdPartyScriptInput[]): ThirdPartyProfileReport;
+    private categorize;
+}

package/dist/analytics/third-party-tracker-cname-cloaking-auditor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ThirdPartyTrackerCnameCloakingAuditor
+ * Detects CNAME cloaking where third-party advertising and analytics trackers masquerade
+ * as first-party subdomains, auditing Safari ITP cookie caps and GDPR privacy leakage.
+ */
+export interface DnsCnameSubdomainInput {
+    subdomain: string;
+    rootApexDomain: string;
+    cnameTarget?: string;
+}
+export type CnameCloakingRiskLevel = "critical_tracker_cloaking" | "external_saas_cname" | "benign_first_party";
+export interface CloakedSubdomainFinding {
+    subdomain: string;
+    cnameTarget: string;
+    isCloakedTracker: boolean;
+    detectedTrackerVendor?: string;
+    riskLevel: CnameCloakingRiskLevel;
+    privacyImplications: string;
+}
+export interface CnameCloakingAuditReport {
+    rootApexDomain: string;
+    totalSubdomainsAudited: number;
+    cloakedTrackersCount: number;
+    privacyIntegrityScore: number;
+    findings: CloakedSubdomainFinding[];
+    complianceWarnings: string[];
+}
+export declare class ThirdPartyTrackerCnameCloakingAuditor {
+    private static readonly KNOWN_TRACKER_CNAME_PATTERNS;
+    /**
+     * Audits subdomains for CNAME cloaking tracker patterns.
+     */
+    audit(rootApexDomain: string, subdomains: DnsCnameSubdomainInput[]): CnameCloakingAuditReport;
+}

package/dist/analytics/time-series-forecaster.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Time-Series Predictive Forecasting Engine — LynxSEO
+ *
+ * Parité fonctionnelle :
+ * - Google Analytics 4 : Automated Insights & Predictive Metrics (Predicted traffic, conversions & bounds)
+ * - Semrush / Matomo Enterprise : Traffic Forecasting & Seasonal Decompositions
+ *
+ * Algorithmes :
+ * 1. Triple Lissage Exponentiel (Holt-Winters Additif) avec composantes Niveau (α), Tendance (β), et Saisonnalité (γ).
+ * 2. Détection de saisonnalité automatique (hebdomadaire m=7, mensuelle m=30) via autocorrélations (ACF).
+ * 3. Enveloppes de prédiction statistique avec intervalles de confiance à 80% (z=1.282) et 95% (z=1.960).
+ * 4. Décomposition STL (Trend, Seasonal, Residual) et forces de tendance/saisonnalité.
+ * 5. Diagnostic de trajectoire et détection des points d'inflexion futurs.
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+export interface TimeSeriesPoint {
+    date: string;
+    value: number;
+}
+export interface ForecastPoint {
+    date: string;
+    predicted: number;
+    lower80: number;
+    upper80: number;
+    lower95: number;
+    upper95: number;
+}
+export interface SeasonalityMetrics {
+    detectedPeriod: number;
+    seasonalityStrength: number;
+    trendStrength: number;
+    isSeasonal: boolean;
+}
+export interface TimeSeriesForecastResult {
+    metricName: string;
+    historicalCount: number;
+    forecastHorizonDays: number;
+    modelParams: {
+        alpha: number;
+        beta: number;
+        gamma: number;
+        period: number;
+    };
+    metrics: {
+        rmse: number;
+        mae: number;
+        mape: number;
+    };
+    seasonality: SeasonalityMetrics;
+    trajectory: "accelerating_growth" | "steady_growth" | "plateau" | "decelerating" | "declining";
+    projectedGrowthPercent: number;
+    forecast: ForecastPoint[];
+    insights: string[];
+}
+export interface ForecastOptions {
+    horizonDays?: number;
+    period?: number;
+    alpha?: number;
+    beta?: number;
+    gamma?: number;
+    confidenceLevels?: number[];
+}
+export declare class TimeSeriesForecaster {
+    /**
+     * Entraîne le modèle Holt-Winters et génère les prédictions futures avec intervalles de confiance.
+     */
+    static forecast(points: TimeSeriesPoint[], metricName?: string, options?: ForecastOptions): TimeSeriesForecastResult;
+    /**
+     * Ajuste le modèle Holt-Winters additif sur les données historiques
+     */
+    private static fitHoltWinters;
+    /**
+     * Détecte automatiquement la période saisonnière principale (7 pour web traffic, 30 pour cycle mensuel)
+     */
+    private static detectPeriod;
+    private static autocorrelation;
+    private static computeSeasonalityMetrics;
+    private static variance;
+    private static generateInsights;
+}