@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/analytics/image-format-density-responsive-optimizer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - ImageFormatDensityResponsiveOptimizer
+ * Audits HTML image elements for next-gen formats (AVIF/WebP), responsive srcset,
+ * layout shift (CLS) dimension attributes, LCP fetchpriority, and byte savings.
+ */
+export interface ImageElementInput {
+    src: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    loading?: "lazy" | "eager" | "auto";
+    fetchpriority?: "high" | "low" | "auto";
+    srcset?: string;
+    sizes?: string;
+    fileSizeBytes?: number;
+    isLcpCandidate?: boolean;
+}
+export type ImageIssueType = "legacy_format" | "missing_dimensions_cls_risk" | "lazy_loading_on_lcp" | "missing_fetchpriority_on_lcp" | "missing_responsive_srcset" | "oversized_file_bytes" | "missing_alt_text";
+export interface ImageAuditFinding {
+    src: string;
+    issue: ImageIssueType;
+    severity: "critical" | "warning" | "info";
+    description: string;
+    recommendation: string;
+}
+export interface ImageOptimizationReport {
+    totalImagesAudited: number;
+    modernFormatCount: number;
+    missingDimensionsCount: number;
+    missingAltCount: number;
+    potentialByteSavingsBytes: number;
+    clsRiskLevel: "none" | "moderate" | "severe";
+    score: number;
+    findings: ImageAuditFinding[];
+    suggestedPictureSnippet?: string;
+}
+export declare class ImageFormatDensityResponsiveOptimizer {
+    private static readonly MODERN_EXTENSIONS;
+    /**
+     * Audits an array of image element inputs or HTML string.
+     */
+    audit(input: string | ImageElementInput[]): ImageOptimizationReport;
+    private extractImagesFromHtml;
+    private getFileExtension;
+}

package/dist/analytics/in-page-overlay-mapper.d.ts

@@ -0,0 +1,47 @@
+/**
+ * LynxSEO Engine - In-Page Link Overlay & Visual Click Heatmap Mapper
+ *
+ * Maps recorded click events back to distinct DOM link targets (anchors, CTAs, buttons)
+ * on a given URL path to power in-page floating click badges and link conversion share.
+ *
+ * (Parity: Matomo In-Page Overlay Plugin).
+ */
+export interface RawOverlayClickEvent {
+    targetSelector: string;
+    targetHref?: string;
+    targetText?: string;
+    xPercent: number;
+    yPercent: number;
+    sessionId: string;
+    isClickableTarget?: boolean;
+}
+export interface LinkOverlayBadge {
+    targetSelector: string;
+    targetHref: string;
+    targetText: string;
+    totalClicks: number;
+    uniqueClickers: number;
+    clickSharePercent: number;
+    avgCoordinates: {
+        xPercent: number;
+        yPercent: number;
+    };
+    isDeadClickTarget: boolean;
+}
+export interface InPageOverlayReport {
+    pageUrl: string;
+    totalPageViews: number;
+    totalClicks: number;
+    uniqueClickers: number;
+    overallClickThroughRate: number;
+    deadClicksCount: number;
+    deadClicksRatePercent: number;
+    overlayBadges: LinkOverlayBadge[];
+    topClickedLink?: LinkOverlayBadge;
+}
+export declare class InPageOverlayMapper {
+    /**
+     * Aggregates raw clicks on a URL into categorized in-page link badges.
+     */
+    mapOverlay(pageUrl: string, totalPageViews: number, clicks: RawOverlayClickEvent[]): InPageOverlayReport;
+}

package/dist/analytics/index.d.ts

@@ -0,0 +1,35 @@
+export * from './types';
+export * from './events';
+export { DeviceDetectorCache, type CacheStats, type DeviceDetectorParsedInfo, } from './device-detector-cache';
+export * from './sessions';
+export * from './funnels';
+export * from './retention';
+export * from './rum';
+export * from './lfa';
+export * from './ai-sov';
+export * from './monitor';
+export * from './attribution';
+export * from './cross-domain-linker';
+export * from './markov-attribution-engine';
+export * from './shapley-attribution-engine';
+export * from './crux';
+export * from './unified';
+export * from './exports';
+export * from './alerts-engine';
+export * from './offline-event-reconciler';
+export * from './churn-risk-calculator';
+export * from './client-error-tracker';
+export * from './data-retention-lifecycle-manager';
+export * from './public-dashboard-manager';
+export * from './user-lifecycle-analyzer';
+export * from './metric-driver-analyzer';
+export * from './proof-of-work-gatekeeper';
+export * from './data-staleness-sentinel';
+export * from './referrer-spam-detector';
+export * from './user-feedback-engine';
+export * from './network-waterfall-analyzer';
+export * from './tasks-timetable-manager';
+export declare const analytics: {
+    version: string;
+    modules: string[];
+};

package/dist/analytics/indexnow-instant-indexation-submitter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - IndexNowInstantIndexationSubmitter
+ * Manages bulk and real-time URL submissions to the IndexNow protocol
+ * (Bing, Yandex, Seznam, Naver), handling key generation, host verification,
+ * URL partitioning (10k chunk limits), and deduplication cooldowns.
+ */
+export interface IndexNowConfig {
+    host: string;
+    key: string;
+    keyLocation?: string;
+    endpoint?: "https://api.indexnow.org/indexnow" | "https://www.bing.com/indexnow" | "https://yandex.com/indexnow" | string;
+    cooldownSeconds?: number;
+}
+export interface IndexNowPayloadBatch {
+    host: string;
+    key: string;
+    keyLocation?: string;
+    urlList: string[];
+}
+export interface IndexNowSubmissionResult {
+    host: string;
+    totalUrlsSubmitted: number;
+    totalValidUrls: number;
+    totalDuplicateFiltered: number;
+    totalForeignHostFiltered: number;
+    batches: IndexNowPayloadBatch[];
+    curlCommand: string;
+    verificationFile: {
+        fileName: string;
+        content: string;
+        expectedUrl: string;
+    };
+}
+export declare class IndexNowInstantIndexationSubmitter {
+    private static readonly MAX_URLS_PER_BATCH;
+    private readonly submittedUrlTimestamps;
+    /**
+     * Generates a compliant 32-character hex key for IndexNow verification.
+     */
+    static generateApiKey(): string;
+    /**
+     * Prepares and partitions URLs into IndexNow transmission batches.
+     */
+    prepareSubmission(urls: string[], config: IndexNowConfig, nowTimestampMs?: number): IndexNowSubmissionResult;
+}

package/dist/analytics/indexnow-instant-submission-protocol-auditor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - IndexNowInstantSubmissionProtocolAuditor
+ * Audits IndexNow instant search engine indexing protocol configurations (supported by Bing, Yandex, Seznam),
+ * validating API key syntax, key location URL hosting, urlList batch quotas (max 10,000),
+ * and same-host domain boundary compliance.
+ */
+export interface IndexNowSubmissionPayload {
+    host: string;
+    key: string;
+    keyLocation?: string;
+    urlList: string[];
+}
+export interface IndexNowAuditIssue {
+    severity: "critical" | "warning" | "info";
+    field: string;
+    message: string;
+}
+export interface IndexNowAuditReport {
+    isValid: boolean;
+    issues: IndexNowAuditIssue[];
+    metrics: {
+        host: string;
+        urlCount: number;
+        keyLength: number;
+        expectedKeyLocation: string;
+        actualKeyLocation?: string;
+    };
+    recommendation: string;
+}
+export declare class IndexNowInstantSubmissionProtocolAuditor {
+    audit(payload: IndexNowSubmissionPayload): IndexNowAuditReport;
+}

package/dist/analytics/infinite-scroll-virtualized-list-seo-auditor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - InfiniteScrollVirtualizedListSeoAuditor
+ * Audits infinite scroll feeds and virtualized DOM lists (react-window, TanStack Virtual)
+ * for search bot discoverability, paginated crawl paths, and deep URL state parity.
+ */
+export interface InfiniteScrollAuditInput {
+    url: string;
+    hasInfiniteScroll: boolean;
+    hasVirtualization: boolean;
+    hasPaginatedHtmlFallback: boolean;
+    supportsPushStateUrlPagination: boolean;
+    totalItemsExpected: number;
+    itemsRenderedInInitialSsrHtml: number;
+    hasNoscriptOrSitemapCrawlPath: boolean;
+}
+export type InfiniteScrollIssueType = "missing_paginated_crawl_path" | "zero_initial_ssr_items" | "virtualization_unindexed_items" | "missing_push_state_url_updates" | "insufficient_initial_items";
+export interface InfiniteScrollFinding {
+    issue: InfiniteScrollIssueType;
+    severity: "critical" | "warning" | "info";
+    description: string;
+    recommendation: string;
+}
+export interface InfiniteScrollAuditReport {
+    url: string;
+    isBotFriendly: boolean;
+    score: number;
+    initialIndexationRatio: number;
+    findings: InfiniteScrollFinding[];
+    recommendedArchitecture: {
+        recommendedStrategy: "hybrid_paginated_infinite_scroll" | "standard_pagination" | "server_rendered_virtualization";
+        htmlFallbackSnippet: string;
+        pushStateSnippet: string;
+    };
+}
+export declare class InfiniteScrollVirtualizedListSeoAuditor {
+    /**
+     * Evaluates infinite scroll and virtualized feed configuration against Google Search Central guidelines.
+     */
+    audit(input: InfiniteScrollAuditInput): InfiniteScrollAuditReport;
+}

package/dist/analytics/internal-link-anchor-nofollow-equity-leak-auditor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - InternalLinkAnchorNofollowEquityLeakAuditor
+ * Detects internal links tagged with rel="nofollow", rel="sponsored", or rel="ugc",
+ * diagnosing PageRank equity evaporation where internal link equity is permanently lost.
+ */
+export interface InternalLinkAuditEntryInput {
+    sourceUrl: string;
+    targetUrl: string;
+    anchorText?: string;
+    relAttributes: string[];
+    isInternal: boolean;
+}
+export type EquityLeakSeverity = "critical_pagerank_evaporation" | "sponsored_on_internal" | "ugc_on_internal";
+export interface LeakingInternalLinkFinding {
+    sourceUrl: string;
+    targetUrl: string;
+    anchorText: string;
+    flaggedRelTypes: string[];
+    severity: EquityLeakSeverity;
+    wastedEquityExplanation: string;
+    recommendedHtmlSnippet: string;
+}
+export interface InternalEquityLeakReport {
+    totalInternalLinksAudited: number;
+    leakingLinksCount: number;
+    equityIntegrityScore: number;
+    findings: LeakingInternalLinkFinding[];
+    strategicRemediationAdvice: string[];
+}
+export declare class InternalLinkAnchorNofollowEquityLeakAuditor {
+    private static readonly LEAK_RELS;
+    /**
+     * Audits internal links for nofollow/sponsored attributes and PageRank evaporation.
+     */
+    audit(links: InternalLinkAuditEntryInput[]): InternalEquityLeakReport;
+}

package/dist/analytics/internal-link-pagerank-auditor.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Internal Link PageRank & Authority Flow Auditor (Batch 13 - Gap 4)
+ *
+ * Internal PageRank (InRank) power-iteration graph engine
+ * inspired by Screaming Frog Internal PageRank, Botify InRank & OnCrawl.
+ *
+ * Accurately models link equity distribution, damping factors (d = 0.85),
+ * dangling page mass re-distribution, detects equity leaks (links to 404/redirects),
+ * and flags starved high-priority business URLs.
+ */
+export interface CrawlLinkEdge {
+    sourceUrl: string;
+    targetUrl: string;
+    isNofollow?: boolean;
+    isRedirect?: boolean;
+    targetStatusCode?: number;
+}
+export interface CrawlPageNodeInput {
+    url: string;
+    title?: string;
+    isConversionTarget?: boolean;
+    priorityScore?: number;
+}
+export interface PageRankNodeResult {
+    url: string;
+    title?: string;
+    rawPageRank: number;
+    normalizedScore: number;
+    decile: number;
+    inboundInternalLinksCount: number;
+    outboundInternalLinksCount: number;
+    isDanglingPage: boolean;
+    equityLeakScore: number;
+    isStarvedHighValuePage: boolean;
+}
+export interface PageRankAuthorityAuditReport {
+    totalPagesAudited: number;
+    totalInternalLinksAudited: number;
+    iterationsToConvergence: number;
+    converged: boolean;
+    dampingFactor: number;
+    topAuthorityPages: PageRankNodeResult[];
+    starvedPages: PageRankNodeResult[];
+    equityLeakPages: PageRankNodeResult[];
+    distributionSummary: {
+        meanScore: number;
+        medianScore: number;
+        danglingPagesCount: number;
+    };
+    recommendations: string[];
+}
+export declare class InternalLinkPageRankAuditor {
+    /**
+     * Computes mathematical internal PageRank via power-iteration algorithm.
+     */
+    static calculatePageRank(pages: CrawlPageNodeInput[], links: CrawlLinkEdge[], options?: {
+        dampingFactor?: number;
+        maxIterations?: number;
+        tolerance?: number;
+    }): PageRankAuthorityAuditReport;
+}

package/dist/analytics/internal-search-query-intelligence.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Internal Search Query Intelligence (Batch 13 - Gap 3)
+ *
+ * Site search analytics and merchandising intelligence engine
+ * inspired by Algolia Analytics, GA4 Site Search, Coveo & Bloomreach.
+ *
+ * Uncovers zero-result content voids, search exit bounce hotspots,
+ * high-converting commercial search terms, and generates SEO landing page opportunities.
+ */
+export interface InternalSearchQueryEvent {
+    query: string;
+    resultsCount: number;
+    clickedResultRank?: number;
+    converted: boolean;
+    exitedWithoutClick: boolean;
+    revenue?: number;
+    timestampMs?: number;
+}
+export interface ZeroResultVoid {
+    query: string;
+    searchFrequency: number;
+    suggestedAction: "create_content" | "expand_catalog" | "add_synonym";
+    recommendedTargetTerm?: string;
+}
+export interface SearchExitHotspot {
+    query: string;
+    searchFrequency: number;
+    exitRatePct: number;
+    averageResultsCount: number;
+    frictionDiagnosis: string;
+}
+export interface HighConvertingSearchTerm {
+    query: string;
+    searchFrequency: number;
+    conversionRatePct: number;
+    totalRevenue: number;
+    seoOpportunityScore: number;
+}
+export interface AggregatedSearchQueryStat {
+    query: string;
+    totalSearches: number;
+    zeroResultsCount: number;
+    zeroResultsRatePct: number;
+    clickThroughCount: number;
+    clickThroughRatePct: number;
+    avgClickedRank?: number;
+    exitCount: number;
+    exitRatePct: number;
+    conversionCount: number;
+    conversionRatePct: number;
+    totalRevenue: number;
+}
+export interface InternalSearchIntelligenceReport {
+    totalSearchesAudited: number;
+    uniqueQueriesCount: number;
+    overallZeroResultRatePct: number;
+    overallSearchCtrPct: number;
+    overallSearchConversionRatePct: number;
+    zeroResultVoids: ZeroResultVoid[];
+    exitHotspots: SearchExitHotspot[];
+    highConvertingCommercialTerms: HighConvertingSearchTerm[];
+    topQueries: AggregatedSearchQueryStat[];
+    strategicMerchandisingAdvice: string[];
+}
+export declare class InternalSearchQueryIntelligence {
+    /**
+     * Simple Levenshtein distance for fuzzy synonym / typo matching.
+     */
+    private static levenshteinDistance;
+    /**
+     * Evaluates fuzzy matching including edit distance and vowel-dropped abbreviation subsequences.
+     */
+    private static isFuzzyMatch;
+    /**
+     * Analyzes raw site search query events to produce actionable search intelligence.
+     */
+    static analyzeSearchQueries(events: InternalSearchQueryEvent[], knownCatalogTerms?: string[], options?: {
+        minQueryFrequency?: number;
+        maxResultsToReturn?: number;
+    }): InternalSearchIntelligenceReport;
+}

package/dist/analytics/internal-search-zero-result-spelling-correction-suggester.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - InternalSearchZeroResultSpellingCorrectionSuggester
+ * Analyzes zero-result site search queries, calculating Levenshtein distance against product
+ * and content vocabulary to generate "Did you mean?" suggestions and recover lost search conversions.
+ */
+export interface ZeroResultSearchQueryInput {
+    rawQuery: string;
+    monthlySearchCount: number;
+    bounceRateAfterSearch: number;
+}
+export interface SearchQueryCorrectionSuggestion {
+    originalQuery: string;
+    suggestedCorrection: string;
+    editDistance: number;
+    confidenceScore: number;
+    lostSearchesRecoverable: number;
+    searchIntentAction: string;
+}
+export interface ZeroResultSearchRescueReport {
+    totalZeroResultQueriesAudited: number;
+    totalLostSearchVolume: number;
+    successfullyMatchedSuggestionsCount: number;
+    unmatchedQueriesCount: number;
+    recoverableVolume: number;
+    potentialRescueRate: number;
+    suggestions: SearchQueryCorrectionSuggestion[];
+    unmatchedQueries: string[];
+}
+export declare class InternalSearchZeroResultSpellingCorrectionSuggester {
+    /**
+     * Suggests corrections for zero-result internal search queries.
+     */
+    analyze(zeroResultQueries: ZeroResultSearchQueryInput[], validCatalogVocabulary: string[]): ZeroResultSearchRescueReport;
+    private levenshtein;
+}

package/dist/analytics/interrupted-time-series-engine.d.ts

@@ -0,0 +1,64 @@
+/**
+ * InterruptedTimeSeriesEngine — Analyse d'Impact Causal par Séries Temporelles Interrompues (ITS)
+ *
+ * Parité : Google CausalImpact, Meta Robyn & Amplitude Causal Insights.
+ *
+ * Évalue scientifiquement l'effet d'une intervention à une date T (migration SEO,
+ * mise à jour d'algorithme Google, refonte UX, lancement de campagne média) :
+ * 1. Modélisation économétrique ITS :
+ *    Y_t = β_0 + β_1 * T_t + β_2 * D_t + β_3 * P_t + ε_t
+ *    - β_0 : Niveau de référence initial (ordonnée à l'origine).
+ *    - β_1 : Tendance préexistante (pente naturelle avant intervention).
+ *    - β_2 : Changement de niveau immédiat (saut instantané post-intervention).
+ *    - β_3 : Changement de pente / accélération (effet cumulatif à long terme).
+ * 2. Trajectoire contrefactuelle : Ce qui se serait produit sans l'intervention.
+ * 3. Effet causal net cumulé : Gain / perte en volume et en pourcentage de lift relatif.
+ * 4. Dérivation statistique : Erreur standard, t-stat, p-value bilatérale et intervalle de confiance à 95%.
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface TimeSeriesDataPoint {
+    date: string;
+    value: number;
+}
+export interface CausalInterventionInput {
+    series: TimeSeriesDataPoint[];
+    interventionDate: string;
+    metricName?: string;
+}
+export interface CausalTimeSeriesPoint {
+    date: string;
+    observed: number;
+    counterfactual: number;
+    causalLift: number;
+    isPostIntervention: boolean;
+}
+export interface InterruptedTimeSeriesReport {
+    metricName: string;
+    interventionDate: string;
+    preInterventionPointsCount: number;
+    postInterventionPointsCount: number;
+    baselineIntercept: number;
+    baselineSlope: number;
+    immediateLevelChange: number;
+    slopeTrajectoryChange: number;
+    cumulativeObserved: number;
+    cumulativeCounterfactual: number;
+    cumulativeNetLift: number;
+    relativeLiftPercentage: number;
+    confidenceInterval95: {
+        lowerLift: number;
+        upperLift: number;
+    };
+    pValue: number;
+    verdict: "statistically_significant_positive" | "statistically_significant_negative" | "no_significant_effect" | "insufficient_data";
+    summaryText: string;
+    timeline: CausalTimeSeriesPoint[];
+    generatedAt: string;
+}
+export declare class InterruptedTimeSeriesEngine {
+    evaluate(input: CausalInterventionInput): InterruptedTimeSeriesReport;
+    private linearRegression;
+    private approximatePValue;
+    private emptyReport;
+}

package/dist/analytics/intranet-measurable-engine.d.ts

@@ -0,0 +1,33 @@
+/**
+ * IntranetMeasurable Analytics Engine
+ *
+ * Implements corporate intranet vs public traffic segmentation,
+ * RFC 1918 IPv4 private subnet matching (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16),
+ * IPv6 Unique Local Address (ULA fc00::/7) and loopback validation,
+ * single-label intranet hostname resolution (corp, intranet, wiki, .local, .internal).
+ * Parity with Matomo IntranetMeasurable plugin.
+ *
+ * Clean-room implementation under AGPL-3.0-or-later.
+ */
+export interface IntranetFilterRules {
+    allowedSubnets?: string[];
+    allowedHostnames?: string[];
+    excludePublicTraffic?: boolean;
+}
+export interface IntranetEvaluationResult {
+    isIntranet: boolean;
+    matchedReason: 'rfc1918' | 'loopback' | 'link_local' | 'ipv6_ula' | 'intranet_hostname' | 'custom_subnet' | null;
+    clientIp: string;
+    hostname: string;
+    isAllowed: boolean;
+}
+export declare class IntranetMeasurableEngine {
+    private static parseIpv4;
+    static isIpv4InCidr(ip: string, cidr: string): boolean;
+    static isIntranetIp(ip: string): {
+        isIntranet: boolean;
+        reason: 'rfc1918' | 'loopback' | 'link_local' | 'ipv6_ula' | null;
+    };
+    static isIntranetHostname(hostname: string): boolean;
+    static evaluate(clientIp: string, hostname: string, rules?: IntranetFilterRules): IntranetEvaluationResult;
+}

package/dist/analytics/js-hydration-drift-auditor.d.ts

@@ -0,0 +1,63 @@
+/**
+ * JsHydrationDriftAuditor — Audit de Divergence d'Hydratation JavaScript SEO
+ *
+ * Parité : Screaming Frog (JavaScript Rendering Comparison) & OnCrawl (Raw vs Rendered DOM).
+ *
+ * Compare l'empreinte HTML brute du serveur (SSR / HTML initial) avec le DOM client rendu
+ * après exécution JavaScript (CSR / DOM post-hydratation).
+ *
+ * Détecte les anomalies critiques de rendu :
+ * 1. Altération de la balise Canonical par JavaScript (risque d'indexation majeur).
+ * 2. Mutation des balises Title et Meta Description lors de l'hydratation.
+ * 3. Injection ou modification des directives Robots (<meta name="robots">, e.g. noindex ajouté par JS).
+ * 4. Liens exclusifs JavaScript : Liens internes/externes absents du HTML brut et présents uniquement
+ *    dans le DOM rendu (invisible pour les crawlers n'exécutant pas le JS ou avec timeout).
+ * 5. Données structurées (JSON-LD) dépendantes du JavaScript.
+ * 6. Écart de volume textuel et de contenu (contenu différé ou masqué).
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface RawVsRenderedInput {
+    url: string;
+    rawHtml: string;
+    renderedHtml: string;
+}
+export type DriftSeverity = "low" | "medium" | "high" | "critical";
+export interface DriftIssue {
+    type: "canonical_drift" | "title_drift" | "meta_description_drift" | "robots_drift" | "js_dependent_links" | "js_dependent_structured_data" | "content_length_drift";
+    severity: DriftSeverity;
+    message: string;
+    rawVal?: string | number | null;
+    renderedVal?: string | number | null;
+    recommendation: string;
+}
+export interface JsHydrationDriftResult {
+    url: string;
+    hydrationDriftScore: number;
+    riskLevel: DriftSeverity;
+    rawStats: {
+        title: string | null;
+        metaDescription: string | null;
+        canonical: string | null;
+        robots: string | null;
+        linksCount: number;
+        jsonLdCount: number;
+        wordCount: number;
+    };
+    renderedStats: {
+        title: string | null;
+        metaDescription: string | null;
+        canonical: string | null;
+        robots: string | null;
+        linksCount: number;
+        jsonLdCount: number;
+        wordCount: number;
+    };
+    jsDependentLinks: string[];
+    issues: DriftIssue[];
+    auditedAt: string;
+}
+export declare class JsHydrationDriftAuditor {
+    audit(input: RawVsRenderedInput): JsHydrationDriftResult;
+    private extractFeatures;
+}