@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/analytics/json-ld-local-business-geo-shape-validator.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - JsonLdLocalBusinessGeoShapeValidator
+ * Validates LocalBusiness, Store, and Restaurant JSON-LD schema against Google Search Central
+ * requirements to ensure eligibility for Google Maps 3-Pack and Local Knowledge Panel rich results.
+ */
+export interface PostalAddressInput {
+    "@type"?: string;
+    streetAddress?: string;
+    addressLocality?: string;
+    addressRegion?: string;
+    postalCode?: string;
+    addressCountry?: string;
+}
+export interface GeoCoordinatesInput {
+    "@type"?: string;
+    latitude?: number | string;
+    longitude?: number | string;
+}
+export interface OpeningHoursSpecificationInput {
+    dayOfWeek?: string | string[];
+    opens?: string;
+    closes?: string;
+}
+export interface LocalBusinessJsonLdInput {
+    "@context"?: string;
+    "@type"?: string;
+    name?: string;
+    image?: string | string[];
+    url?: string;
+    telephone?: string;
+    priceRange?: string;
+    address?: PostalAddressInput;
+    geo?: GeoCoordinatesInput;
+    openingHoursSpecification?: OpeningHoursSpecificationInput[];
+    [key: string]: unknown;
+}
+export interface LocalBusinessValidationResult {
+    businessName: string;
+    businessType: string;
+    isEligibleForLocalPack: boolean;
+    score: number;
+    missingRequiredFields: string[];
+    missingRecommendedFields: string[];
+    geoCoordinateIssues: string[];
+    remediationSnippet: string;
+}
+export declare class JsonLdLocalBusinessGeoShapeValidator {
+    private static readonly SUPPORTED_LOCAL_TYPES;
+    /**
+     * Validates LocalBusiness schema object for Google rich snippet & local pack eligibility.
+     */
+    validate(input: LocalBusinessJsonLdInput): LocalBusinessValidationResult;
+    private generateSampleSnippet;
+}

package/dist/analytics/keyword-cannibalization-resolver.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Keyword Cannibalization Resolver (Batch 18 - Gap 2)
+ *
+ * SERP cannibalization detector & multi-URL conflict resolver inspired by
+ * Ahrefs Cannibalization Explorer, Semrush Cannibalization Report & Sitebulb.
+ *
+ * Flags competing internal URLs splitting Googlebot ranking signals for identical queries.
+ * Computes severity scores, models traffic dilution, and prescribes surgical
+ * consolidation remedies (301 redirect, canonical tag, or de-optimization).
+ */
+export interface CompetingUrlEntry {
+    url: string;
+    currentRank: number;
+    historicalRanks?: number[];
+    monthlyOrganicClicks?: number;
+    isPreferredUrl?: boolean;
+}
+export interface CannibalizedKeywordRecord {
+    keyword: string;
+    monthlySearchVolume: number;
+    competingUrls: CompetingUrlEntry[];
+}
+export type CannibalizationSeverity = "critical" | "high" | "moderate" | "low";
+export type ResolutionRemedyType = "301_redirect_consolidation" | "canonical_tag_consolidation" | "de_optimize_secondary_content" | "internal_link_repointing";
+export interface CannibalizationConflictAnalysis {
+    keyword: string;
+    monthlySearchVolume: number;
+    competingUrlsCount: number;
+    severity: CannibalizationSeverity;
+    severityScore: number;
+    primaryUrl: string;
+    secondaryUrls: string[];
+    estimatedMonthlyTrafficLoss: number;
+    recommendedRemedy: ResolutionRemedyType;
+    actionablePrescription: string;
+}
+export interface CannibalizationAuditReport {
+    totalKeywordsChecked: number;
+    cannibalizedKeywordsCount: number;
+    totalMonthlyTrafficDiluted: number;
+    conflicts: CannibalizationConflictAnalysis[];
+    strategicActionPlan: string[];
+}
+export declare class KeywordCannibalizationResolver {
+    /**
+     * Audits keyword ranking records and detects cannibalization conflicts.
+     */
+    static auditCannibalization(records: CannibalizedKeywordRecord[]): CannibalizationAuditReport;
+}

package/dist/analytics/kmeans-persona-discovery-engine.d.ts

@@ -0,0 +1,57 @@
+/**
+ * KmeansPersonaDiscoveryEngine — Découverte non supervisée de personas comportementaux par K-Means
+ *
+ * Parité : Amplitude (Persona Discovery) & Mixpanel.
+ *
+ * Transforme les volumes d'activité événementielle des utilisateurs en profils vectoriels,
+ * normalise les caractéristiques par Z-score (centrage-réduction) et applique l'algorithme
+ * K-Means avec initialisation K-Means++ pour partitionner automatiquement les utilisateurs
+ * en K personas comportementaux distincts.
+ *
+ * Génère automatiquement :
+ * - Le nommage et profil du persona (ex: "Power Users Recherche", "Acheteurs Compulsifs").
+ * - Les caractéristiques comportementales distinctives (sur-représentation par rapport à la moyenne globale).
+ * - La taille relative (% de la base) et les centroïdes de chaque cluster.
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface UserEventProfile {
+    userId: string;
+    /** Dictionnaire des comptages d'événements : { "search": 15, "export_csv": 4, "page_view": 80 } */
+    eventCounts: Record<string, number>;
+}
+export interface DistinctiveBehavior {
+    eventName: string;
+    clusterAverage: number;
+    globalAverage: number;
+    zScore: number;
+    isOverIndexed: boolean;
+}
+export interface DiscoveredPersona {
+    clusterIndex: number;
+    personaName: string;
+    userCount: number;
+    percentageOfTotal: number;
+    sampleUserIds: string[];
+    distinctiveBehaviors: DistinctiveBehavior[];
+    summary: string;
+}
+export interface PersonaDiscoveryResult {
+    totalUsersAnalyzed: number;
+    kClusters: number;
+    featureNames: string[];
+    personas: DiscoveredPersona[];
+    globalFeatureAverages: Record<string, number>;
+    generatedAt: string;
+}
+export interface PersonaDiscoveryOptions {
+    k?: number;
+    maxIterations?: number;
+    randomSeed?: number;
+}
+export declare class KmeansPersonaDiscoveryEngine {
+    discoverPersonas(userProfiles: UserEventProfile[], options?: PersonaDiscoveryOptions): PersonaDiscoveryResult;
+    private euclideanDistance;
+    private formatEventLabel;
+    private emptyResult;
+}

package/dist/analytics/lcp-preload-responsive-image-candidate-picker.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - LcpPreloadResponsiveImageCandidatePicker
+ * Computes responsive image candidate selection from srcset and sizes descriptors,
+ * generates optimal <link rel="preload" as="image"> tags, and eliminates LCP resource load delay.
+ */
+export interface ResponsiveImageDescriptor {
+    url: string;
+    width?: number;
+    density?: number;
+}
+export interface LcpImageElementInput {
+    src: string;
+    srcset?: string;
+    sizes?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    loading?: "lazy" | "eager" | string;
+    fetchPriority?: "high" | "low" | "auto" | string;
+}
+export interface ViewportDeviceTest {
+    deviceName: "mobile" | "tablet" | "desktop";
+    viewportWidthPx: number;
+    devicePixelRatio: number;
+}
+export interface ResolvedCandidatePick {
+    device: ViewportDeviceTest;
+    effectiveSlotWidthPx: number;
+    requiredResolutionPx: number;
+    selectedCandidateUrl: string;
+}
+export interface LcpPreloadReport {
+    isOptimal: boolean;
+    score: number;
+    parsedCandidates: ResponsiveImageDescriptor[];
+    devicePicks: ResolvedCandidatePick[];
+    hasDoubleDownloadRisk: boolean;
+    hasLazyLoadingAntiPattern: boolean;
+    hasMissingFetchPriority: boolean;
+    preloadHeadTagSnippet: string;
+    correctedImgTagSnippet: string;
+    findings: string[];
+}
+export declare class LcpPreloadResponsiveImageCandidatePicker {
+    private static readonly DEFAULT_TEST_DEVICES;
+    /**
+     * Evaluates LCP responsive image markup and generates the exact preload head tag.
+     */
+    evaluate(image: LcpImageElementInput, devices?: ViewportDeviceTest[]): LcpPreloadReport;
+    private parseSrcset;
+    private computeSlotWidth;
+    private parseSlotValue;
+}

package/dist/analytics/ld-json-graph-nesting-resolver.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - LdJsonGraphNestingResolver
+ * Dereferences and unifies multiple disconnected JSON-LD schema blocks into a coherent
+ * Schema.org @graph hierarchy (Organization -> WebSite -> WebPage -> Primary Entity).
+ */
+export interface LdJsonSchemaNode {
+    "@type": string;
+    "@id"?: string;
+    [key: string]: unknown;
+}
+export interface LdJsonGraphEdge {
+    fromNodeId: string;
+    fromType: string;
+    toNodeId: string;
+    property: string;
+    isResolved: boolean;
+}
+export interface DanglingReference {
+    referencingNodeId: string;
+    referencingType: string;
+    property: string;
+    missingTargetId: string;
+}
+export interface SchemaGraphResolutionReport {
+    totalNodes: number;
+    totalEdges: number;
+    connectedEdges: number;
+    danglingReferences: DanglingReference[];
+    duplicateNodeIds: string[];
+    unifiedGraph: {
+        "@context": "https://schema.org";
+        "@graph": LdJsonSchemaNode[];
+    };
+    hierarchyCheck: {
+        hasOrganization: boolean;
+        hasWebSite: boolean;
+        hasWebPage: boolean;
+        hasPrimaryEntity: boolean;
+        isProperlyInterlinked: boolean;
+    };
+    recommendations: string[];
+}
+export declare class LdJsonGraphNestingResolver {
+    /**
+     * Parses JSON-LD script blocks from HTML or directly accepts an array of Schema nodes/graphs.
+     */
+    resolve(input: string | LdJsonSchemaNode[] | {
+        "@graph": LdJsonSchemaNode[];
+    }): SchemaGraphResolutionReport;
+    private extractNodes;
+    private inspectReferences;
+}

package/dist/analytics/lfa.d.ts

@@ -0,0 +1,24 @@
+export interface NormalizedLog {
+    ts: string;
+    path: string;
+    status: number;
+    bytes: number;
+    bot: boolean;
+    botName?: string;
+    ip?: string;
+    method?: string;
+}
+export declare function normalizeLogLine(line: string): NormalizedLog | null;
+export declare function lfaKpis(rows: NormalizedLog[]): {
+    total: number;
+    bots: number;
+    humans: number;
+    ok: number;
+    err: number;
+    bytes: number;
+    topPaths: {
+        path: string;
+        hits: number;
+    }[];
+    crawlBudgetWaste: number;
+};

package/dist/analytics/live-funnel-dropoff-alert-engine.d.ts

@@ -0,0 +1,64 @@
+/**
+ * LiveFunnelDropoffAlertEngine — Détection en Temps Réel des Chutes Anormales de Conversion de Funnel
+ *
+ * Parité : PostHog (Funnel Correlation & Alerts), Mixpanel (Anomaly Detection & Root-Cause).
+ *
+ * Surveille en continu les taux de passage entre les étapes d'un entonnoir de conversion
+ * (ex: Inscription -> Onboarding -> Choix Formule -> Paiement) et déclenche des alertes
+ * immédiates en cas d'effondrement statistique anormal :
+ *
+ * 1. Calcul du Z-Score de Déviation Statistique :
+ *    - Compare le taux de conversion de la fenêtre temps-réel (dernière heure) à la moyenne
+ *      historique mobile (baseline moyenne µ et écart-type σ).
+ * 2. Quantification du Manque à Gagner Financier :
+ *    - Estime le montant de chiffre d'affaires perdu par heure (Hourly Revenue Loss Estimation)
+ *      selon la valeur moyenne de transaction et le volume de visiteurs bloqués.
+ * 3. Diagnostic d'Isolation de Panne :
+ *    - Identifie si la chute est généralisée ou localisée sur un canal, navigateur ou OS particulier
+ *      (ex: régression spécifique à Safari iOS ou bogue Stripe Webhook).
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface FunnelStepBaseline {
+    stepId: string;
+    stepName: string;
+    historicalMeanConversionRate: number;
+    historicalStdDev: number;
+}
+export interface LiveStepMeasurement {
+    stepId: string;
+    visitorsEntered: number;
+    visitorsConverted: number;
+    deviceAnomalyHint?: string;
+}
+export interface FunnelAlertConfig {
+    funnelId: string;
+    funnelName: string;
+    averageTransactionValue: number;
+    criticalZScoreThreshold?: number;
+}
+export interface StepDropoffAlert {
+    stepId: string;
+    stepName: string;
+    baselineRate: number;
+    liveRate: number;
+    rateDeltaPercentagePoints: number;
+    zScore: number;
+    severity: "info" | "warning" | "critical";
+    lostConversionsCount: number;
+    estimatedHourlyRevenueLoss: number;
+    diagnostic: string;
+}
+export interface FunnelMonitoringReport {
+    funnelId: string;
+    funnelName: string;
+    hasCriticalAlert: boolean;
+    totalEstimatedHourlyLoss: number;
+    alerts: StepDropoffAlert[];
+    recommendedActions: string[];
+    generatedAt: string;
+}
+export declare class LiveFunnelDropoffAlertEngine {
+    monitor(config: FunnelAlertConfig, baselines: FunnelStepBaseline[], measurements: LiveStepMeasurement[]): FunnelMonitoringReport;
+    private emptyReport;
+}

package/dist/analytics/log-file-search-engine-ip-reverse-dns-verifier.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - LogFileSearchEngineIpReverseDnsVerifier
+ * Verifies authenticity of claimed search engine crawlers (Googlebot, Bingbot, Yandex, Applebot)
+ * via strict two-pass rDNS (PTR) and forward DNS confirmation, detecting fake bot spoofing.
+ */
+export type ClaimedSearchEngineBot = "googlebot" | "bingbot" | "yandex" | "baidu" | "applebot" | "duckduckgo" | "unknown_or_generic";
+export interface BotVerificationInput {
+    ip: string;
+    userAgent: string;
+    ptrHostnames?: string[];
+    forwardResolvedIps?: string[];
+}
+export interface BotVerificationResult {
+    ip: string;
+    userAgent: string;
+    claimedEngine: ClaimedSearchEngineBot;
+    isClaimingOfficialBot: boolean;
+    isVerifiedAuthentic: boolean;
+    status: "verified_authentic" | "spoofed_fake_bot" | "unverified_missing_dns" | "non_bot_traffic";
+    ptrHostnameMatched?: string;
+    reason: string;
+    mitigationWafRuleSnippet?: string;
+}
+export declare class LogFileSearchEngineIpReverseDnsVerifier {
+    private static readonly OFFICIAL_DOMAINS;
+    /**
+     * Identifies claimed search engine identity from User-Agent string.
+     */
+    identifyClaimedBot(userAgent: string): ClaimedSearchEngineBot;
+    /**
+     * Verifies an IP address against claimed search engine DNS identity.
+     */
+    verify(input: BotVerificationInput): BotVerificationResult;
+}

package/dist/analytics/logfile-bot-anomaly-detector.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Logfile Bot Anomaly Detector (Batch 14 - Gap 3)
+ *
+ * Search engine crawl log analyzer and anomaly detector inspired by
+ * Botify Log Analyzer, OnCrawl Log Analyzer & Screaming Frog Log File Analyser.
+ *
+ * Classifies search engine & AI crawler bot traffic (Googlebot, Bingbot, GPTBot, ClaudeBot, etc.),
+ * detects 5xx server error bursts, WAF 403 blocks, crawl budget drain on parameter URLs,
+ * and high bot response latency causing crawler throttling.
+ */
+export type LogBotFamily = "googlebot_smartphone" | "googlebot_desktop" | "bingbot" | "yandexbot" | "baiduspider" | "ai_crawler" | "unknown_bot" | "human_user";
+export interface ServerAccessLogRecord {
+    ip: string;
+    timestampMs: number;
+    method: "GET" | "POST" | "HEAD" | "PUT" | string;
+    url: string;
+    statusCode: number;
+    responseTimeMs: number;
+    userAgent: string;
+    bytesSent?: number;
+}
+export type BotAnomalySeverity = "critical" | "warning" | "info";
+export interface BotCrawlAnomaly {
+    anomalyType: "bot_5xx_server_error_spike" | "bot_403_waf_block" | "high_crawl_latency" | "crawl_budget_parameter_trap" | "crawl_rate_collapse";
+    botFamily: LogBotFamily;
+    severity: BotAnomalySeverity;
+    affectedUrlSample: string[];
+    impactDescription: string;
+    remediationAdvice: string;
+}
+export interface BotFamilyStats {
+    botFamily: LogBotFamily;
+    totalHits: number;
+    statusCodeCounts: Record<number, number>;
+    error5xxCount: number;
+    blocked403Count: number;
+    avgResponseTimeMs: number;
+    p95ResponseTimeMs: number;
+    parameterUrlHitCount: number;
+    parameterHitRatioPct: number;
+}
+export interface LogfileBotAuditReport {
+    totalLogLinesAudited: number;
+    totalBotHits: number;
+    humanHits: number;
+    botTrafficRatioPct: number;
+    overallCrawlHealthScore: number;
+    botFamilyBreakdown: BotFamilyStats[];
+    detectedAnomalies: BotCrawlAnomaly[];
+    recommendations: string[];
+}
+export declare class LogfileBotAnomalyDetector {
+    /**
+     * Classifies user-agent into recognized bot family.
+     */
+    static classifyUserAgent(ua: string): LogBotFamily;
+    /**
+     * Audits access log records and surfaces bot crawl anomalies and health metrics.
+     */
+    static auditLogRecords(logs: ServerAccessLogRecord[], baselineDailyGooglebotHits?: number): LogfileBotAuditReport;
+}

package/dist/analytics/long-animation-task-tracker.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Long Animation Task (LoAF) & Frame Drop Tracker
+ *
+ * Clean-room implementation inspired by OpenReplay longAnimationTask & Chrome Performance API.
+ * Detects UI stalls, main-thread blocking scripts, layout thrashing, and frame drops
+ * during user sessions and connects them with replay timestamps.
+ */
+export interface LongAnimationFrame {
+    id: string;
+    sessionId: string;
+    startTime: number;
+    duration: number;
+    blockingDuration: number;
+    renderDuration: number;
+    styleAndLayoutDuration: number;
+    scripts: Array<{
+        invoker: string;
+        sourceURL?: string;
+        sourceFunctionName?: string;
+        duration: number;
+        pauseDuration: number;
+    }>;
+    severity: "low" | "medium" | "high" | "critical";
+}
+export interface LoAFSessionSummary {
+    sessionId: string;
+    totalLoAFs: number;
+    totalBlockingTimeMs: number;
+    maxBlockingDurationMs: number;
+    criticalFramesCount: number;
+    topOffendingScripts: Array<{
+        invoker: string;
+        sourceURL?: string;
+        count: number;
+        cumulativeDurationMs: number;
+    }>;
+}
+export declare class LongAnimationTaskTracker {
+    private frames;
+    recordLoAF(frame: Omit<LongAnimationFrame, "id" | "blockingDuration" | "severity"> & {
+        id?: string;
+    }): LongAnimationFrame;
+    getSessionSummary(sessionId: string): LoAFSessionSummary;
+    clear(): void;
+}

package/dist/analytics/long-task-tracker.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Long Task Tracker
+ *
+ * Traque et analyse les tâches JavaScript bloquantes (> 50ms) sur le fil principal (W3C Long Tasks API).
+ * Isole les scripts ou conteneurs responsables (iframes publicitaires, widgets tiers)
+ * et calcule le Total Blocking Time (TBT) ainsi que l'impact estimé sur l'INP.
+ */
+export interface LongTaskEntry {
+    startTime: number;
+    duration: number;
+    name?: string;
+    containerType?: "window" | "iframe" | "embed" | "object" | string;
+    containerSrc?: string;
+    containerId?: string;
+    containerName?: string;
+}
+export interface CulpritSummary {
+    containerSrc: string;
+    taskCount: number;
+    totalDurationMs: number;
+    totalBlockingTimeMs: number;
+}
+export interface LongTaskReport {
+    totalTasks: number;
+    totalDurationMs: number;
+    totalBlockingTimeMs: number;
+    maxDurationMs: number;
+    averageDurationMs: number;
+    inpImpactEstimate: "negligible" | "moderate" | "severe";
+    topCulprits: CulpritSummary[];
+    timeline: Array<{
+        startTime: number;
+        durationMs: number;
+        blockingTimeMs: number;
+        culprit: string;
+    }>;
+}
+export declare class LongTaskTracker {
+    private readonly LONG_TASK_THRESHOLD_MS;
+    analyze(entries: LongTaskEntry[]): LongTaskReport;
+}

package/dist/analytics/market-basket-association-engine.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Market Basket Association Engine (Batch 15 - Gap 1)
+ *
+ * E-commerce association rule mining and cross-sell affinity engine
+ * inspired by GA4 Item Affinity, Shopify Cross-Sell & Retail Analytics.
+ *
+ * Employs Apriori support, confidence, and lift metrics:
+ * - Support(A -> B) = P(A ∩ B) : proportion of orders containing both A and B
+ * - Confidence(A -> B) = P(B | A) : likelihood of purchasing B given A is in basket
+ * - Lift(A -> B) = P(B | A) / P(B) : cross-sell strength (> 1 indicates positive affinity)
+ *
+ * Generates recommended product bundles and estimates basket size expansion upside.
+ */
+export interface BasketTransaction {
+    orderId: string;
+    itemIds: string[];
+    totalOrderValue?: number;
+    timestampMs?: number;
+}
+export interface ItemMetadata {
+    itemId: string;
+    itemName: string;
+    price?: number;
+    category?: string;
+}
+export interface AssociationRule {
+    antecedentId: string;
+    antecedentName?: string;
+    consequentId: string;
+    consequentName?: string;
+    transactionCountBoth: number;
+    supportPct: number;
+    confidencePct: number;
+    lift: number;
+    affinityGrade: "exceptional" | "strong" | "moderate" | "neutral" | "negative";
+    estimatedAovUplift?: number;
+}
+export interface MarketBasketAnalysisReport {
+    totalOrdersAnalyzed: number;
+    uniqueProductsCount: number;
+    averageItemsPerBasket: number;
+    topCrossSellRules: AssociationRule[];
+    recommendedBundles: {
+        bundleItemIds: string[];
+        bundleNames: string[];
+        coOccurrenceOrders: number;
+        estimatedBundlePrice: number;
+        rationale: string;
+    }[];
+    merchandisingInsights: string[];
+}
+export declare class MarketBasketAssociationEngine {
+    /**
+     * Analyzes basket transactions to compute association rules (Support, Confidence, Lift).
+     */
+    static mineAssociationRules(orders: BasketTransaction[], itemsCatalog?: Record<string, ItemMetadata>, options?: {
+        minSupportPct?: number;
+        minConfidencePct?: number;
+        minLift?: number;
+        maxRules?: number;
+    }): MarketBasketAnalysisReport;
+    private static formatRule;
+}

package/dist/analytics/markov-attribution-engine.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Markov Chain & Algorithmic Data-Driven Attribution Engine
+ * Parity with GA4 Data-Driven Attribution & Matomo Multi-Channel Attribution
+ *
+ * Implements absorbing Markov chains to calculate removal effects across multi-touch customer journeys.
+ * Evaluates the incremental contribution of each marketing channel by measuring conversion degradation
+ * when that channel is simulated as removed from the transition graph.
+ */
+export interface JourneyPath {
+    pathId: string;
+    channels: string[];
+    converted: boolean;
+    value?: number;
+}
+export interface ChannelMarkovAttribution {
+    channel: string;
+    removalEffect: number;
+    attributedConversions: number;
+    attributedRevenue: number;
+    attributionShare: number;
+    linearShare: number;
+    firstTouchShare: number;
+    lastTouchShare: number;
+    deltaVsLastTouch: number;
+}
+export interface TransitionStep {
+    from: string;
+    to: string;
+    count: number;
+    probability: number;
+}
+export interface MarkovAttributionReport {
+    totalJourneys: number;
+    convertedJourneys: number;
+    totalConversions: number;
+    totalRevenue: number;
+    baselineConversionRate: number;
+    channels: ChannelMarkovAttribution[];
+    transitions: TransitionStep[];
+    topPaths: {
+        path: string;
+        conversions: number;
+        conversionRate: number;
+        revenue: number;
+    }[];
+}
+export declare class MarkovAttributionEngine {
+    private static START_STATE;
+    private static CONV_STATE;
+    private static NULL_STATE;
+    /**
+     * Analyzes an array of multi-touch journeys using Absorbing Markov Chains.
+     */
+    static compute(journeys: JourneyPath[]): MarkovAttributionReport;
+    /**
+     * Calculates absorption probability from (start) to (conversion)
+     * using iterative probability propagation through the Markov graph.
+     * When a channel is removed, transitions entering that channel are
+     * absorbed into (null), measuring the true loss of conversions (removal effect).
+     */
+    private static calculateConversionProbability;
+}