@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/analytics/web-vital-inp-attribution-profiler.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Web Vital INP Attribution Profiler (Batch 12 - Gap 1)
+ *
+ * Granular Interaction to Next Paint (INP) and Long Animation Frame (LoAF)
+ * profiler adhering to Web Vitals v4 specifications.
+ *
+ * Breaks down slow interactions into 3 exact sub-phases:
+ * 1. Input Delay (time until listener begins execution)
+ * 2. Processing Time (duration spent executing event handlers)
+ * 3. Presentation Delay (rendering, paint, and frame dispatch time)
+ *
+ * Diagnoses Long Animation Frames (LoAF), identifies DOM interaction bottlenecks,
+ * and outputs deterministic developer remediation advice (yield to main, debounce, CSS containment).
+ */
+export type InpInteractionType = "pointerdown" | "pointerup" | "click" | "keydown" | "keyup";
+export interface LongAnimationFrameEntry {
+    durationMs: number;
+    renderStartMs?: number;
+    styleAndLayoutDurationMs?: number;
+    blockingDurationMs?: number;
+    sourceScript?: string;
+    sourceFunction?: string;
+}
+export interface InpInteractionRecord {
+    id: string;
+    interactionType: InpInteractionType;
+    targetSelector: string;
+    totalDurationMs: number;
+    inputDelayMs: number;
+    processingDurationMs: number;
+    presentationDelayMs: number;
+    longAnimationFrames?: LongAnimationFrameEntry[];
+    timestampMs: number;
+    pageUrl: string;
+}
+export type InpRating = "good" | "needs_improvement" | "poor";
+export interface InpTargetBottleneck {
+    targetSelector: string;
+    interactionType: InpInteractionType;
+    sampleCount: number;
+    p75TotalMs: number;
+    p75InputDelayMs: number;
+    p75ProcessingMs: number;
+    p75PresentationDelayMs: number;
+    primaryCulprit: "input_delay" | "processing_time" | "presentation_delay";
+    dominantScript?: string;
+    remediationAdvice: string[];
+}
+export interface InpAttributionReport {
+    totalInteractionsAudited: number;
+    p75InpDurationMs: number;
+    p90InpDurationMs: number;
+    p99InpDurationMs: number;
+    overallRating: InpRating;
+    subpartDistribution: {
+        inputDelayContributionPct: number;
+        processingTimeContributionPct: number;
+        presentationDelayContributionPct: number;
+    };
+    worstBottlenecks: InpTargetBottleneck[];
+    highRiskLoafCount: number;
+    recommendations: string[];
+}
+export declare class WebVitalInpAttributionProfiler {
+    /**
+     * Computes percentile (p-th) using linear interpolation on sorted array.
+     */
+    private static calculatePercentile;
+    /**
+     * Profiles a collection of raw INP interaction entries and groups them
+     * into component-level attribution bottlenecks and actionable recommendations.
+     */
+    static profileInteractions(interactions: InpInteractionRecord[], options?: {
+        maxBottlenecks?: number;
+        goodThresholdMs?: number;
+        poorThresholdMs?: number;
+    }): InpAttributionReport;
+}

package/dist/analytics/web-vital-interaction-to-next-paint-event-target-decomposer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - WebVitalInteractionToNextPaintEventTargetDecomposer
+ * Decomposes Interaction to Next Paint (INP) measurements into input delay, processing time,
+ * and presentation delay phases to pinpoint root-cause UI thread stalls and layout thrashing.
+ */
+export interface InpRawInteractionEvent {
+    interactionId: string;
+    eventType: "click" | "pointerdown" | "pointerup" | "keydown" | "keyup";
+    targetElementSelector: string;
+    totalDurationMs: number;
+    inputDelayMs: number;
+    processingDurationMs: number;
+    presentationDelayMs: number;
+    targetPageUrl: string;
+    timestampMs?: number;
+}
+export type InpDominantPhase = "input_delay" | "processing_duration" | "presentation_delay";
+export interface DecomposedInteractionReport {
+    interactionId: string;
+    targetElementSelector: string;
+    eventType: string;
+    totalDurationMs: number;
+    dominantPhase: InpDominantPhase;
+    phasePercentages: {
+        inputDelayPercent: number;
+        processingPercent: number;
+        presentationPercent: number;
+    };
+    inpSeverity: "good" | "needs_improvement" | "poor";
+    diagnosticCause: string;
+    remediationSnippet: string;
+}
+export interface InpDecompositionSummary {
+    totalInteractionsAnalyzed: number;
+    poorInteractionsCount: number;
+    p75InpDurationMs: number;
+    dominantBottleneck: InpDominantPhase;
+    decomposedEvents: DecomposedInteractionReport[];
+}
+export declare class WebVitalInteractionToNextPaintEventTargetDecomposer {
+    private static readonly INP_GOOD_THRESHOLD;
+    private static readonly INP_POOR_THRESHOLD;
+    /**
+     * Decomposes INP interaction entries into their three lifecycle phases.
+     */
+    decompose(events: InpRawInteractionEvent[]): InpDecompositionSummary;
+    private diagnose;
+}

package/dist/analytics/web-vital-lcp-attribution-profiler.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Web Vital LCP Attribution Profiler (Batch 14 - Gap 1)
+ *
+ * Granular Largest Contentful Paint (LCP) performance profiler conforming to Chrome Web Vitals v4.
+ *
+ * Breaks down LCP into 4 exact subpart phases:
+ * 1. Time to First Byte (TTFB / server response time)
+ * 2. Resource Load Delay (delta between TTFB and start of resource fetch)
+ * 3. Resource Load Duration (time taken to download the LCP asset)
+ * 4. Element Render Delay (time between asset download finish and paint to screen)
+ *
+ * Identifies LCP element types, preloading directives, priority hints (`fetchpriority="high"`),
+ * and generates deterministic web performance engineering recommendations.
+ */
+export type LcpElementType = "image" | "background_image" | "text" | "video" | "svg" | "unknown";
+export interface LcpMeasurementRecord {
+    id: string;
+    url: string;
+    totalLcpDurationMs: number;
+    ttfbMs: number;
+    resourceLoadDelayMs: number;
+    resourceLoadDurationMs: number;
+    elementRenderDelayMs: number;
+    elementSelector: string;
+    elementType: LcpElementType;
+    resourceSizeBytes?: number;
+    resourceUrl?: string;
+    isPreloaded?: boolean;
+    hasFetchPriorityHigh?: boolean;
+    timestampMs?: number;
+}
+export type LcpRating = "good" | "needs_improvement" | "poor";
+export interface LcpElementBottleneck {
+    elementSelector: string;
+    elementType: LcpElementType;
+    sampleCount: number;
+    p75TotalLcpMs: number;
+    p75TtfbMs: number;
+    p75LoadDelayMs: number;
+    p75LoadDurationMs: number;
+    p75RenderDelayMs: number;
+    primaryCulprit: "ttfb" | "load_delay" | "load_duration" | "render_delay";
+    missingPreload: boolean;
+    missingFetchPriority: boolean;
+    remediationAdvice: string[];
+}
+export interface LcpAttributionReport {
+    totalRecordsAudited: number;
+    p75LcpMs: number;
+    p90LcpMs: number;
+    overallRating: LcpRating;
+    subpartDistributionPct: {
+        ttfbPct: number;
+        resourceLoadDelayPct: number;
+        resourceLoadDurationPct: number;
+        elementRenderDelayPct: number;
+    };
+    dominantElementType: LcpElementType;
+    worstElementBottlenecks: LcpElementBottleneck[];
+    recommendations: string[];
+}
+export declare class WebVitalLcpAttributionProfiler {
+    /**
+     * Computes p-th percentile from an array of numbers.
+     */
+    private static calculatePercentile;
+    /**
+     * Profiles a collection of LCP measurement records and groups them
+     * into component-level attribution bottlenecks and actionable recommendations.
+     */
+    static profileLcp(records: LcpMeasurementRecord[], options?: {
+        goodThresholdMs?: number;
+        poorThresholdMs?: number;
+        maxBottlenecks?: number;
+    }): LcpAttributionReport;
+}

package/dist/analytics/web-vitals-attribution-engine.d.ts

@@ -0,0 +1,103 @@
+/**
+ * WebVitalsAttributionEngine — Attribution Granulaire & Diagnostics des Core Web Vitals v4
+ *
+ * Parité : Google CrUX, SpeedCurve & PostHog Web Vitals.
+ *
+ * Analyse les sous-composantes et attribue précisément les dégradations de performance :
+ * 1. LCP (Largest Contentful Paint) :
+ *    - Identification du sélecteur CSS de l'élément (ex: header > div.hero > img).
+ *    - Décomposition en 4 phases : TTFB, Resource Load Delay, Resource Load Duration, Element Render Delay.
+ * 2. INP (Interaction to Next Paint) :
+ *    - Identification de l'élément interactif (ex: button#checkout).
+ *    - Type d'interaction (click, pointerdown, keydown).
+ *    - Décomposition en 3 phases : Input Delay, Processing Duration (tâches longues JS), Presentation Delay.
+ * 3. CLS (Cumulative Layout Shift) :
+ *    - Identification des sélecteurs responsables des plus grands décalages visuels.
+ * 4. Diagnostics Prescriptifs : Recommandations de code ciblées (fetchpriority, content-visibility, Web Workers).
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface LcpMeasurement {
+    url: string;
+    valueMs: number;
+    targetElementSelector?: string;
+    elementResourceUrl?: string;
+    ttfbMs?: number;
+    resourceLoadDelayMs?: number;
+    resourceLoadTimeMs?: number;
+    elementRenderDelayMs?: number;
+}
+export interface InpMeasurement {
+    url: string;
+    valueMs: number;
+    targetElementSelector?: string;
+    interactionType?: "click" | "pointerdown" | "keydown";
+    inputDelayMs?: number;
+    processingDurationMs?: number;
+    presentationDelayMs?: number;
+}
+export interface ClsMeasurement {
+    url: string;
+    value: number;
+    largestShiftElementSelector?: string;
+}
+export type VitalsRating = "good" | "needs_improvement" | "poor";
+export interface OffenderElementSummary {
+    selector: string;
+    metric: "LCP" | "INP" | "CLS";
+    occurrences: number;
+    p75Value: number;
+    rating: VitalsRating;
+    primarySubPartCulprit?: string;
+    recommendedAction: string;
+}
+export interface WebVitalsAttributionReport {
+    lcp: {
+        p75Ms: number;
+        rating: VitalsRating;
+        averageSubParts: {
+            ttfbMs: number;
+            loadDelayMs: number;
+            loadTimeMs: number;
+            renderDelayMs: number;
+        };
+        primaryBottleneck: string;
+        topOffenders: OffenderElementSummary[];
+    };
+    inp: {
+        p75Ms: number;
+        rating: VitalsRating;
+        averageSubParts: {
+            inputDelayMs: number;
+            processingDurationMs: number;
+            presentationDelayMs: number;
+        };
+        primaryBottleneck: string;
+        topOffenders: OffenderElementSummary[];
+    };
+    cls: {
+        p75: number;
+        rating: VitalsRating;
+        topOffenders: OffenderElementSummary[];
+    };
+    prescriptiveRecommendations: string[];
+    generatedAt: string;
+}
+export declare class WebVitalsAttributionEngine {
+    private static readonly LCP_GOOD_MAX;
+    private static readonly LCP_NEEDS_IMPROVEMENT_MAX;
+    private static readonly INP_GOOD_MAX;
+    private static readonly INP_NEEDS_IMPROVEMENT_MAX;
+    private static readonly CLS_GOOD_MAX;
+    private static readonly CLS_NEEDS_IMPROVEMENT_MAX;
+    analyze(lcpList: LcpMeasurement[], inpList: InpMeasurement[], clsList?: ClsMeasurement[]): WebVitalsAttributionReport;
+    private rateMetric;
+    private getPercentile;
+    private calculateLcpSubParts;
+    private identifyLcpBottleneck;
+    private calculateInpSubParts;
+    private identifyInpBottleneck;
+    private extractLcpOffenders;
+    private extractInpOffenders;
+    private extractClsOffenders;
+}

package/dist/analytics/web-vitals-fcp-speed-index-auditor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Web Vitals FCP & Speed Index Auditor (Batch 16 - Gap 3)
+ *
+ * First Contentful Paint (FCP) and Speed Index (SI) performance profiler
+ * conforming to Google Lighthouse v12 and Chrome Web Vitals standards.
+ *
+ * Identifies head render-blocking stylesheets, parser-blocking synchronous scripts,
+ * and FOIT webfont loading delays. Computes potential millisecond savings and
+ * emits surgical code remediation snippets.
+ */
+export type FcpRating = "good" | "needs_improvement" | "poor";
+export type SpeedIndexRating = "good" | "needs_improvement" | "poor";
+export interface RenderBlockingResource {
+    url: string;
+    resourceType: "stylesheet" | "script" | "font";
+    transferSizeBytes: number;
+    blockingDurationMs: number;
+    hasAsyncOrDefer?: boolean;
+    fontDisplaySetting?: "swap" | "optional" | "block" | "fallback" | "auto" | "none";
+}
+export interface FcpMeasurementInput {
+    fcpMs: number;
+    speedIndexMs: number;
+    resources: RenderBlockingResource[];
+}
+export interface RenderBlockingOptimizationReport {
+    resource: RenderBlockingResource;
+    estimatedFcpSavingsMs: number;
+    actionableFix: string;
+}
+export interface WebVitalsFcpSpeedIndexReport {
+    fcpMs: number;
+    fcpRating: FcpRating;
+    speedIndexMs: number;
+    speedIndexRating: SpeedIndexRating;
+    totalBlockingResourcesCount: number;
+    totalRenderBlockingDurationMs: number;
+    potentialFcpSavingsMs: number;
+    optimizations: RenderBlockingOptimizationReport[];
+    recommendations: string[];
+}
+export declare class WebVitalsFcpSpeedIndexAuditor {
+    /**
+     * Audits FCP and Speed Index along with render-blocking network assets.
+     */
+    static auditFcpAndSpeedIndex(input: FcpMeasurementInput): WebVitalsFcpSpeedIndexReport;
+}

package/dist/analytics/web-vitals-tbt-loaf-auditor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - Web Vitals TBT & LoAF Auditor (Batch 15 - Gap 3)
+ *
+ * Total Blocking Time (TBT) and Long Animation Frames (LoAF) performance profiler
+ * conforming to Chrome Web Vitals v4 and Lighthouse performance specifications.
+ *
+ * Breaks down main thread blocking tasks (> 50ms), computes total TBT,
+ * attributes blocking duration to specific script URLs and invoker callbacks,
+ * and generates web performance recommendations (e.g. scheduler.yield, Web Workers).
+ */
+export type LoafInvokerType = "event-listener" | "user-callback" | "promise-resolve" | "settimeout" | "microtask" | "script-parse" | "unknown";
+export interface LongTaskRecord {
+    id: string;
+    durationMs: number;
+    startTimeMs: number;
+    scriptUrl?: string;
+    sourceFunctionName?: string;
+    invokerType?: LoafInvokerType;
+    isThirdParty?: boolean;
+}
+export type TbtRating = "good" | "needs_improvement" | "poor";
+export interface ScriptBlockingAttribution {
+    scriptUrl: string;
+    isThirdParty: boolean;
+    totalTaskCount: number;
+    totalBlockingDurationMs: number;
+    blockingContributionPct: number;
+    maxSingleBlockingTaskMs: number;
+    dominantInvokerType: LoafInvokerType;
+    optimizationAdvice: string[];
+}
+export interface WebVitalsTbtReport {
+    totalLongTasksAudited: number;
+    totalDurationMs: number;
+    totalTbtMs: number;
+    tbtRating: TbtRating;
+    firstPartyTbtMs: number;
+    thirdPartyTbtMs: number;
+    thirdPartyTbtSharePct: number;
+    worstBlockingScripts: ScriptBlockingAttribution[];
+    performanceRecommendations: string[];
+}
+export declare class WebVitalsTbtLoafAuditor {
+    /**
+     * Audits long task / LoAF records to calculate TBT and script attributions.
+     */
+    static auditTbtAndLoaf(longTasks: LongTaskRecord[], options?: {
+        goodThresholdMs?: number;
+        poorThresholdMs?: number;
+        maxCulpritScripts?: number;
+    }): WebVitalsTbtReport;
+    private static guessIsThirdParty;
+}

package/dist/analytics/web-worker-offscreen-canvas-performance-auditor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - WebWorkerOffscreenCanvasPerformanceAuditor
+ * Audits heavy canvas rendering, chart calculations, and long-running scripts executed on the main UI thread,
+ * recommending Web Worker and OffscreenCanvas offloading to protect Interaction to Next Paint (INP).
+ */
+export interface MainThreadTaskInput {
+    taskName: string;
+    sourceFile: string;
+    durationMs: number;
+    category: "canvas_2d" | "webgl" | "data_processing" | "crypto_parsing" | "dom_mutation";
+    usesOffscreenCanvas: boolean;
+    executedInWebWorker: boolean;
+}
+export interface OffloadingOpportunity {
+    task: MainThreadTaskInput;
+    potentialInpImpactReductionMs: number;
+    priority: "critical" | "high" | "medium";
+    recommendation: string;
+}
+export interface MainThreadWorkerAuditReport {
+    totalTasksAudited: number;
+    mainThreadBlockingTasksCount: number;
+    totalMainThreadDurationMs: number;
+    offloadableTasksCount: number;
+    estimatedTbtSavingsMs: number;
+    mainThreadFriendlinessScore: number;
+    opportunities: OffloadingOpportunity[];
+    architecturalGuidance: string[];
+}
+export declare class WebWorkerOffscreenCanvasPerformanceAuditor {
+    private static readonly LONG_TASK_THRESHOLD_MS;
+    /**
+     * Evaluates task performance profiles and highlights Web Worker / OffscreenCanvas opportunities.
+     */
+    audit(tasks: MainThreadTaskInput[]): MainThreadWorkerAuditReport;
+}

package/dist/analytics/webapp-manifest-pwa-installability-auditor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - WebAppManifestPwaInstallabilityAuditor
+ * Audits Web App Manifests (manifest.json) against Google Chrome PWA installability criteria,
+ * maskable icons (192x192 / 512x512), display modes, and service worker registration.
+ */
+export interface ManifestIconInput {
+    src: string;
+    sizes: string;
+    type?: string;
+    purpose?: string;
+}
+export interface WebAppManifestInput {
+    name?: string;
+    short_name?: string;
+    start_url?: string;
+    scope?: string;
+    display?: "standalone" | "fullscreen" | "minimal-ui" | "browser" | string;
+    theme_color?: string;
+    background_color?: string;
+    icons?: ManifestIconInput[];
+    serviceWorkerRegistered?: boolean;
+}
+export type PwaInstallabilityStatus = "installable" | "missing_critical_requirements" | "suboptimal";
+export interface PwaInstallabilityAuditReport {
+    isInstallable: boolean;
+    status: PwaInstallabilityStatus;
+    installabilityScore: number;
+    missingRequirements: string[];
+    warnings: string[];
+    has192Icon: boolean;
+    has512Icon: boolean;
+    hasMaskableIcon: boolean;
+    recommendedManifestSnippet: string;
+}
+export declare class WebAppManifestPwaInstallabilityAuditor {
+    /**
+     * Audits manifest.json against Chrome PWA installability requirements.
+     */
+    audit(manifest: WebAppManifestInput): PwaInstallabilityAuditReport;
+}

package/dist/analytics/webhooks-engine.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Webhooks & Event Subscriptions Engine
+ *
+ * Clean-room implementation inspired by PostHog Webhooks & Matomo Live Webhooks.
+ * Dispatches real-time events to subscribed external endpoints with HMAC-SHA256 signatures,
+ * automated exponential backoff retries, and delivery audit logs.
+ */
+export interface WebhookOutboundSubscription {
+    id: string;
+    name: string;
+    siteId: string;
+    targetUrl: string;
+    secret: string;
+    eventFilters: string[];
+    enabled: boolean;
+    maxRetries: number;
+    timeoutMs: number;
+}
+export interface WebhookDeliveryAttempt {
+    id: string;
+    subscriptionId: string;
+    event: string;
+    payload: Record<string, any>;
+    attemptNumber: number;
+    status: "success" | "failed" | "pending";
+    statusCode?: number;
+    signature: string;
+    deliveredAt?: number;
+    error?: string;
+}
+export declare class WebhooksEngine {
+    private subscriptions;
+    private deliveryHistory;
+    registerSubscription(sub: WebhookOutboundSubscription): void;
+    getSubscription(id: string): WebhookOutboundSubscription | undefined;
+    generateHmacSignature(payloadString: string, secret: string): string;
+    prepareDeliveries(siteId: string, eventName: string, payload: Record<string, any>): WebhookDeliveryAttempt[];
+    recordDeliveryResult(attemptId: string, statusCode: number, error?: string): void;
+    getHistory(subscriptionId?: string): WebhookDeliveryAttempt[];
+    clear(): void;
+}

package/dist/analytics/xml-sitemap-index-paginator-splitter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - XML Sitemap Index Paginator & Splitter (Batch 17 - Gap 2)
+ *
+ * Enterprise XML Sitemap partitioner & index compiler conforming to
+ * Google & Bing sitemaps.org protocol (50,000 URL / 50MB limit per chunk).
+ *
+ * Inspired by Yoast XML Sitemap Engine & Screaming Frog Sitemap Generator.
+ * Partitions large catalogs into numbered sitemap chunks and generates
+ * the master <sitemapindex> with valid schema namespaces.
+ */
+export interface PaginatorSitemapUrlEntry {
+    loc: string;
+    lastmod?: string;
+    changefreq?: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+    priority?: number;
+}
+export interface GeneratedChildSitemap {
+    filename: string;
+    urlCount: number;
+    xmlContent: string;
+}
+export interface SitemapSplitterResult {
+    totalUrlsIngested: number;
+    totalValidUrls: number;
+    invalidUrlsCount: number;
+    sitemapIndexXml: string;
+    childSitemaps: GeneratedChildSitemap[];
+    warnings: string[];
+}
+export interface SitemapSplitterOptions {
+    baseSitemapUrl: string;
+    sitemapPrefix?: string;
+    maxUrlsPerSitemap?: number;
+}
+export declare class XmlSitemapIndexPaginatorSplitter {
+    /**
+     * Partitions an array of URLs into chunked XML sitemaps and creates a master sitemapindex.
+     */
+    static partitionAndCompile(entries: PaginatorSitemapUrlEntry[], options: SitemapSplitterOptions): SitemapSplitterResult;
+    private static renderUrlsetXml;
+    private static renderSitemapIndexXml;
+    private static escapeXml;
+}

package/dist/analytics/xml-sitemap-video-extension-auditor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @license AGPL-3.0-or-later
+ * LynxSEO - XmlSitemapVideoExtensionAuditor
+ * Audits XML sitemaps for Google Video extension compliance (<video:video>, <video:thumbnail_loc>,
+ * <video:title>, <video:description>, <video:content_loc>, <video:player_loc>, <video:duration>),
+ * verifying video indexing eligibility and rich video carousel snippet display.
+ */
+export interface SitemapVideoTagEntry {
+    pageUrl: string;
+    thumbnailLoc: string;
+    title: string;
+    description: string;
+    contentLoc?: string;
+    playerLoc?: string;
+    durationSeconds?: number;
+    publicationDate?: string;
+    familyFriendly?: boolean;
+}
+export interface VideoSitemapFinding {
+    pageUrl: string;
+    title: string;
+    hasValidThumbnail: boolean;
+    hasPlayableMediaLoc: boolean;
+    hasValidDuration: boolean;
+    isEligibleForVideoIndex: boolean;
+    issues: string[];
+}
+export interface VideoSitemapAuditReport {
+    totalVideosAudited: number;
+    eligibleVideosCount: number;
+    videoIndexingReadinessScore: number;
+    findings: VideoSitemapFinding[];
+    remediationAdvice: string[];
+    sampleValidVideoXml: string;
+}
+export declare class XmlSitemapVideoExtensionAuditor {
+    private static readonly PLAYABLE_VIDEO_REGEX;
+    /**
+     * Audits video extension tags in an XML sitemap.
+     */
+    audit(videos: SitemapVideoTagEntry[]): VideoSitemapAuditReport;
+}