@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/analytics/predictive-lead-scorer.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Predictive Lead Scorer & Product Qualified Lead (PQL) Engine — LynxSEO
+ *
+ * Parité fonctionnelle :
+ * - PostHog & Mixpanel : Product Analytics to CRM Pipeline & PQL Scoring
+ * - MadKudu & HubSpot : Predictive Behavioral Lead Scoring with Recency Decay
+ *
+ * Algorithmes :
+ * 1. Pondération comportementale des signaux d'intention d'achat (pricing, sécu/compliance, invitations équipe, API).
+ * 2. Décroissance temporelle exponentielle (Half-life decay de 14 jours) pour valoriser la fraîcheur des actions.
+ * 3. Filtrage firmographique (domaine d'entreprise pro vs webmail gratuit grand public).
+ * 4. Qualification automatique : PQL (Product Qualified), MQL (Marketing Qualified), Warm, Cold.
+ * 5. Recommandation prescriptive du "Next Best Action" pour l'équipe commerciale ou le marketing automation.
+ *
+ * Licence : AGPL-3.0-or-later
+ */
+export interface LeadBehavioralEvent {
+    eventName: string;
+    timestamp: string;
+    path?: string;
+    properties?: Record<string, unknown>;
+}
+export interface LeadProfileInput {
+    leadId: string;
+    email?: string;
+    companyName?: string;
+    domain?: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    totalSessions: number;
+    events: LeadBehavioralEvent[];
+    firmographic?: {
+        employeeCount?: number;
+        industry?: string;
+        country?: string;
+    };
+}
+export type LeadQualificationTier = "pql" | "mql" | "warm" | "cold";
+export interface IntentSignalBreakdown {
+    signalName: string;
+    occurrences: number;
+    rawPoints: number;
+    decayedPoints: number;
+    description: string;
+}
+export interface PredictiveLeadScoreResult {
+    leadId: string;
+    email?: string;
+    companyName?: string;
+    isBusinessEmail: boolean;
+    score: number;
+    qualificationTier: LeadQualificationTier;
+    qualificationLabel: string;
+    intentSignals: IntentSignalBreakdown[];
+    behaviorScore: number;
+    firmographicScore: number;
+    recencyScore: number;
+    nextBestAction: {
+        actionType: "immediate_sales_outreach" | "product_demo_offer" | "nurture_campaign" | "retargeting";
+        reason: string;
+        recommendedChannel: "email_sdr" | "in_app_tour" | "marketing_drip" | "none";
+    };
+}
+export declare class PredictiveLeadScorer {
+    private static readonly HALF_LIFE_DAYS;
+    /**
+     * Calcule le score prédictif d'intention et la qualification PQL d'un prospect.
+     */
+    static scoreLead(input: LeadProfileInput, now?: Date): PredictiveLeadScoreResult;
+    private static checkBusinessEmail;
+    private static categorizeEvent;
+    private static deriveNextAction;
+}

package/dist/analytics/privacy-manager-engine.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Privacy Manager & Anonymizer Engine
+ *
+ * Clean-room implementation inspired by Matomo PrivacyManager.
+ * Enforces GDPR/ePrivacy compliance via IP address masking (1-3 octets),
+ * User-Agent de-identification, automatic raw log purging schedules, and geo anonymization.
+ */
+export interface PrivacyPolicyConfig {
+    ipMaskLevel: 0 | 1 | 2 | 3;
+    maskUserAgent: boolean;
+    maskReferrerUrl: boolean;
+    rawLogRetentionDays: number;
+    anonymizeOrderId: boolean;
+    salt: string;
+}
+export interface AnonymizedPayload {
+    anonymizedIp: string;
+    anonymizedUserAgent: string;
+    anonymizedReferrer: string;
+    maskedOrderId?: string;
+    anonymizedAt: string;
+}
+export declare class PrivacyManagerEngine {
+    private config;
+    constructor(config?: Partial<PrivacyPolicyConfig>);
+    getConfig(): PrivacyPolicyConfig;
+    updateConfig(updates: Partial<PrivacyPolicyConfig>): void;
+    anonymizeIp(ip: string): string;
+    anonymizeUserAgent(ua: string): string;
+    anonymizeReferrer(referrer: string): string;
+    anonymizeOrderId(orderId: string): string;
+    processHit(ip: string, ua: string, referrer?: string, orderId?: string): AnonymizedPayload;
+    isLogExpired(logTimestampMs: number, nowMs?: number): boolean;
+}

package/dist/analytics/product-tour-telemetry.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ProductTourTelemetry — Télémétrie et entonnoirs d'onboarding in-app (Parité PostHog Product Tours / Appcues / Userflow).
+ *
+ * Analyse les parcours d'onboarding interactifs guidés :
+ * - Entonnoir de progression étape par étape (Step-by-step Funnel)
+ * - Taux d'abandon et identification de l'étape de friction majeure
+ * - Temps moyen passé par étape et détection des fermetures précipitées (rage-dismiss)
+ * - Taux d'achèvement global et recommandations d'optimisation UX
+ */
+export type TourAction = "impression" | "completed" | "dismissed" | "skipped" | "errored";
+export interface TourTelemetryEvent {
+    tourId: string;
+    stepIndex: number;
+    stepId: string;
+    userId: string;
+    action: TourAction;
+    durationMs?: number;
+    errorMessage?: string;
+    timestamp: number | string;
+}
+export interface TourStepMetric {
+    stepIndex: number;
+    stepId: string;
+    impressionsCount: number;
+    completionsCount: number;
+    dropOffCount: number;
+    dropOffRatePct: number;
+    dismissalsCount: number;
+    skipsCount: number;
+    errorsCount: number;
+    avgDurationMs: number;
+    medianDurationMs: number;
+}
+export interface ProductTourReport {
+    tourId: string;
+    totalParticipants: number;
+    completedParticipants: number;
+    overallCompletionRatePct: number;
+    avgTotalDurationSeconds: number;
+    worstFrictionStep: {
+        stepIndex: number;
+        stepId: string;
+        dropOffRatePct: number;
+        dropOffCount: number;
+    } | null;
+    stepMetrics: TourStepMetric[];
+    frictionAlerts: Array<{
+        type: "high_drop_off" | "quick_dismissal" | "high_error_rate";
+        stepId: string;
+        message: string;
+        recommendation: string;
+    }>;
+}
+export declare class ProductTourTelemetry {
+    /**
+     * Analyse les événements de télémétrie d'un ou plusieurs guides interactifs.
+     */
+    static analyzeTour(tourId: string, events: TourTelemetryEvent[]): ProductTourReport;
+}

package/dist/analytics/proof-of-work-gatekeeper.d.ts

@@ -0,0 +1,50 @@
+/**
+ * LynxSEO Engine - Proof-of-Work Anti-Bot Gatekeeper
+ *
+ * Provides a privacy-friendly, zero-tracking Proof-of-Work (PoW) challenge and verification
+ * system to shield public analytics endpoints, conversion submissions, and tracking beacons
+ * from headless bots without external CAPTCHA providers (reCAPTCHA, Turnstile).
+ *
+ * (Parity: Swetrix PoW Captcha Shield).
+ */
+export interface PoWChallenge {
+    nonce: string;
+    difficulty: number;
+    timestamp: number;
+    signature: string;
+}
+export interface PoWVerificationResult {
+    valid: boolean;
+    reason?: "expired" | "invalid_signature" | "insufficient_difficulty" | "nonce_replayed" | "invalid_format";
+    computedHash?: string;
+    solveTimeEstimateMs?: number;
+}
+export declare class ProofOfWorkGatekeeper {
+    private secretKey;
+    private defaultDifficulty;
+    private maxAgeMs;
+    private usedNonces;
+    constructor(config?: {
+        secretKey?: string;
+        defaultDifficulty?: number;
+        maxAgeMs?: number;
+    });
+    /**
+     * Generates a new cryptographic PoW challenge for the client.
+     */
+    generateChallenge(difficulty?: number): PoWChallenge;
+    /**
+     * Verifies the client's solution (salt) against the challenge.
+     */
+    verifySolution(challenge: PoWChallenge, solutionSalt: string, now?: number): PoWVerificationResult;
+    /**
+     * Solves a challenge (helper for testing and SDK clients).
+     */
+    solve(challenge: PoWChallenge, maxIterations?: number): string | null;
+    private signChallenge;
+    private generateRandomHex;
+    /**
+     * Portable pure-JS SHA-256 implementation (works seamlessly in Node, Bun, and Cloudflare Edge Workers).
+     */
+    private simpleSha256;
+}

package/dist/analytics/propensity-scorer-ga4.d.ts

@@ -0,0 +1,58 @@
+/**
+ * PropensityScorerGA4 — Moteur de Scoring Prédictif d'Achat et de Churn (Parité Google Analytics 4)
+ *
+ * Parité : Google Analytics 4 (Predictive Audiences & Metrics), Amplitude (Propensity Scoring).
+ *
+ * Calcule les probabilités prédictives pour chaque utilisateur ou visiteur identifié :
+ * 1. Probabilité d'achat dans les 7 prochains jours (Purchase Probability 7d, 0 à 100%).
+ * 2. Probabilité de désengagement / churn dans les 7 prochains jours (Churn Probability 7d, 0 à 100%).
+ * 3. Chiffre d'affaires prévisionnel à 28 jours (Predicted Revenue 28d).
+ * 4. Segmentation automatique en audiences prédictives GA4 standard :
+ *    - "likely_7d_purchasers" (Top 20% des utilisateurs les plus susceptibles d'acheter).
+ *    - "likely_7d_churners" (Top 20% des utilisateurs actifs risquant de ne plus revenir).
+ *    - "high_intent_low_risk" (Clients fidèles à forte récurrence).
+ *    - "dormant_window_shoppers" (Visiteurs occasionnels sans engagement fort).
+ *
+ * Modèle bayésien / logistique basé sur :
+ * - Récence de la dernière session (Recency).
+ * - Vélocité de fréquence des sessions (7j récents vs 21j précédents).
+ * - Profondeur d'engagement (durée moyenne, événements d'ajout au panier / checkout).
+ * - Historique monétaire cumulé.
+ *
+ * Implémentation Clean-Room sous licence AGPL-3.0.
+ */
+export interface UserBehaviorProfile {
+    userId: string;
+    daysSinceLastVisit: number;
+    sessionsLast7Days: number;
+    sessionsPrior21Days: number;
+    avgEngagementTimeSeconds: number;
+    hasAddToCartInLast7Days: boolean;
+    hasInitiatedCheckoutInLast7Days: boolean;
+    totalHistoricalPurchasesCount: number;
+    totalHistoricalSpend: number;
+}
+export type PredictiveAudienceBucket = "likely_7d_purchasers" | "likely_7d_churners" | "high_intent_low_risk" | "dormant_window_shoppers";
+export interface UserPropensityScore {
+    userId: string;
+    purchaseProbability7d: number;
+    churnProbability7d: number;
+    predictedRevenue28d: number;
+    audienceBucket: PredictiveAudienceBucket;
+    topDrivers: string[];
+}
+export interface PredictiveAudienceSummary {
+    totalUsersScored: number;
+    likelyPurchasersCount: number;
+    likelyChurnersCount: number;
+    projected28dRevenueTotal: number;
+    topConversionDrivers: string[];
+    userScores: UserPropensityScore[];
+    generatedAt: string;
+}
+export declare class PropensityScorerGA4 {
+    scoreUsers(users: UserBehaviorProfile[]): PredictiveAudienceSummary;
+    private computeUserScore;
+    private sigmoid;
+    private emptySummary;
+}

package/dist/analytics/proxy-adblock-bypasser.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Proxy & Adblock Bypasser Engine
+ *
+ * Clean-room implementation inspired by Matomo Proxy & Plausible/Swetrix adblock bypass strategies.
+ * Dynamically obfuscates analytics ingestion endpoints, generates customized proxy rewrite rules,
+ * and validates reverse-proxy CNAME configurations to ensure reliable tracking under strict adblockers.
+ */
+export interface ProxyRouteConfig {
+    projectId: string;
+    vanitySubdomain?: string;
+    customPathPrefix?: string;
+    obfuscationSalt: string;
+    allowedOrigins: string[];
+    enabled: boolean;
+}
+export interface ObfuscatedRouteMapping {
+    originalEndpoint: string;
+    obfuscatedPath: string;
+    scriptDeliveryPath: string;
+    headerOverrides: Record<string, string>;
+    cnameValidation: {
+        expectedTarget: string;
+        configured: boolean;
+    };
+}
+export declare class ProxyAdblockBypasser {
+    private configs;
+    registerConfig(config: ProxyRouteConfig): void;
+    getConfig(projectId: string): ProxyRouteConfig | undefined;
+    /**
+     * Generates unique obfuscated paths deterministically per project using a simple hash
+     */
+    generateObfuscatedRoutes(projectId: string): ObfuscatedRouteMapping;
+    validateIncomingOrigin(projectId: string, origin?: string): boolean;
+    private hashString;
+}

package/dist/analytics/pseo-pattern-rollup.d.ts

@@ -0,0 +1,64 @@
+/**
+ * pSEO Pattern Rollup & Cannibalization Analyzer
+ *
+ * Moteur exclusif à LynxSEO permettant de regrouper et d'analyser
+ * la performance macro des matrices programmatiques (pSEO)
+ * et de détecter les pages zombies (0 trafic) et la cannibalisation interne.
+ */
+export interface RawPseoPageMetric {
+    urlPath: string;
+    visits: number;
+    bounceRatePercent: number;
+    conversions: number;
+    aiBotCrawls: number;
+    avgTimeOnPageSec: number;
+    targetKeyword?: string;
+}
+export interface PseoPatternConfig {
+    id: string;
+    name: string;
+    /** Regex pattern matching the programmatic URL structure (e.g. ^/outils/[^/]+/[^/]+$) */
+    patternRegex: string;
+    /** Human friendly template signature (e.g. /outils/:category/:slug) */
+    templateSignature: string;
+}
+export interface PseoPatternRollup {
+    patternId: string;
+    name: string;
+    templateSignature: string;
+    totalPagesCount: number;
+    totalVisits: number;
+    averageBounceRatePercent: number;
+    totalConversions: number;
+    conversionRatePercent: number;
+    totalAiBotCrawls: number;
+    avgTimeOnPageSec: number;
+    zombiePagesCount: number;
+    zombieRatioPercent: number;
+    cannibalizationRiskCount: number;
+    topPerformingUrls: {
+        urlPath: string;
+        visits: number;
+        conversions: number;
+    }[];
+    zombieUrlsToPrune: string[];
+}
+export interface PseoRollupReport {
+    totalPseoPages: number;
+    totalPseoVisits: number;
+    overallConversionRatePercent: number;
+    overallZombieRatioPercent: number;
+    crawlEfficiencyScore: number;
+    patterns: PseoPatternRollup[];
+    unmatchedPagesCount: number;
+    recommendations: {
+        severity: "low" | "medium" | "high";
+        message: string;
+        actionableFix: string;
+    }[];
+}
+export declare class PseoPatternRollupAnalyzer {
+    static analyze(pages: RawPseoPageMetric[], customPatterns?: PseoPatternConfig[]): PseoRollupReport;
+    private static getDefaultPatterns;
+    private static generateRecommendations;
+}

package/dist/analytics/public-dashboard-manager.d.ts

@@ -0,0 +1,56 @@
+/**
+ * LynxSEO Engine - Public Dashboard & Shared Token Access Manager
+ * Parité Rybbit Public Dashboards, Plausible Shared Links & Umami Share Tokens.
+ *
+ * Génération de liens de partage sécurisés, restriction granulaire des onglets,
+ * masquage des métriques financières et validation de mots de passe pour tableaux de bord publics.
+ */
+export interface PublicDashboardShareConfig {
+    id: string;
+    siteId: string;
+    shareToken: string;
+    name: string;
+    createdAtIso: string;
+    expiresAtIso?: string;
+    isPasswordProtected: boolean;
+    passwordHash?: string;
+    allowedTabs: string[];
+    hideFinancialMetrics: boolean;
+    allowDateRangeSelection: boolean;
+    isActive: boolean;
+}
+export interface CreateShareLinkOptions {
+    name: string;
+    expiresInDays?: number;
+    password?: string;
+    allowedTabs?: string[];
+    hideFinancialMetrics?: boolean;
+    allowDateRangeSelection?: boolean;
+}
+export interface SharedAccessValidationResult {
+    isValid: boolean;
+    config?: Omit<PublicDashboardShareConfig, "passwordHash">;
+    rejectionReason?: "not_found" | "expired" | "disabled" | "invalid_password";
+}
+export declare class PublicDashboardManager {
+    private shares;
+    /**
+     * Crée un nouveau lien de partage sécurisé pour un site.
+     */
+    createShareLink(siteId: string, options: CreateShareLinkOptions): PublicDashboardShareConfig;
+    /**
+     * Valide un jeton d'accès public et vérifie le mot de passe éventuel.
+     */
+    validateAccess(shareToken: string, providedPassword?: string): SharedAccessValidationResult;
+    /**
+     * Filtre un payload analytique pour masquer les données sensibles / financières
+     * selon la configuration du lien de partage.
+     */
+    filterPublicPayload<T extends Record<string, any>>(payload: T, config: PublicDashboardShareConfig): T;
+    /**
+     * Désactive ou supprime un lien de partage.
+     */
+    revokeShare(shareToken: string): boolean;
+    private generateCryptographicToken;
+    private hashPassword;
+}

package/dist/analytics/query-canvas-graph.d.ts

@@ -0,0 +1,101 @@
+/**
+ * LynxSEO Engine - Query Canvas Graph Compiler
+ *
+ * Clean-room implementation of a visual query canvas (Code Canvas style, inspired
+ * by PostHog's SQL insights): a directed acyclic graph of source / filter / join /
+ * aggregate / limit nodes is validated, then compiled into a safe parameterized
+ * SQL query for both SQLite (D1) and PostgreSQL (Hyperdrive).
+ *
+ * Safety invariants:
+ * - every identifier is validated against `^[A-Za-z_][A-Za-z0-9_]*$` and quoted;
+ * - every literal travels through the `params` array, never through the SQL text;
+ * - `LIMIT` is an integer bounded by `MAX_LIMIT` (or the caller's `maxLimit`);
+ * - compilation refuses any graph that does not pass validation.
+ *
+ * AGPL-3.0-or-later
+ */
+export type QueryCanvasNodeType = "source" | "filter" | "join" | "aggregate" | "limit";
+export interface QueryCanvasSourceNode {
+    id: string;
+    type: "source";
+    table: string;
+    alias: string;
+    columns: string[];
+}
+export interface QueryCanvasFilterNode {
+    id: string;
+    type: "filter";
+    input: string;
+    column: string;
+    operator: "=" | "!=" | ">" | "<" | ">=" | "<=" | "LIKE" | "IN";
+    value: string | number | boolean | Array<string | number>;
+}
+export interface QueryCanvasJoinNode {
+    id: string;
+    type: "join";
+    left: string;
+    right: string;
+    joinType: "inner" | "left" | "right";
+    leftColumn: string;
+    rightColumn: string;
+}
+export interface QueryCanvasAggregateNode {
+    id: string;
+    type: "aggregate";
+    input: string;
+    groupBy: string[];
+    metrics: Array<{
+        alias: string;
+        fn: "count" | "sum" | "avg" | "min" | "max";
+        column?: string;
+    }>;
+}
+export interface QueryCanvasLimitNode {
+    id: string;
+    type: "limit";
+    input: string;
+    limit: number;
+}
+export type QueryCanvasNode = QueryCanvasSourceNode | QueryCanvasFilterNode | QueryCanvasJoinNode | QueryCanvasAggregateNode | QueryCanvasLimitNode;
+export interface QueryCanvasGraph {
+    nodes: QueryCanvasNode[];
+    output: string;
+}
+export interface QueryCanvasValidationError {
+    nodeId: string | null;
+    code: "empty_graph" | "duplicate_id" | "unknown_node_type" | "missing_input" | "cycle" | "invalid_output" | "invalid_identifier" | "invalid_limit" | "too_many_nodes" | "duplicate_alias" | "unknown_column";
+    message: string;
+}
+export interface QueryCanvasValidationResult {
+    valid: boolean;
+    errors: QueryCanvasValidationError[];
+    warnings: string[];
+}
+export interface CompileQueryCanvasOptions {
+    dialect: "sqlite" | "postgres";
+    maxLimit?: number;
+}
+export interface CompiledQueryCanvasQuery {
+    sql: string;
+    params: Array<string | number>;
+    warnings: string[];
+}
+/** Raised when `compile` receives a graph rejected by `validate`. */
+export declare class QueryCanvasCompileError extends Error {
+    readonly errors: QueryCanvasValidationError[];
+    constructor(errors: QueryCanvasValidationError[]);
+}
+export declare class QueryCanvasCompiler {
+    static readonly MAX_NODES = 50;
+    static readonly MAX_LIMIT = 1000;
+    /**
+     * Validates every structural, identifier, aliasing and column-resolution rule
+     * of a canvas graph. Deterministic: same graph, same error ordering.
+     */
+    static validate(graph: QueryCanvasGraph): QueryCanvasValidationResult;
+    /**
+     * Compiles a validated canvas into a parameterized SQL query.
+     * Throws `QueryCanvasCompileError` when validation fails.
+     */
+    static compile(graph: QueryCanvasGraph, options: CompileQueryCanvasOptions): CompiledQueryCanvasQuery;
+}

package/dist/analytics/realtime-concurrency-monitor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Real-Time Sliding-Window Concurrency & Heartbeat Monitor
+ *
+ * Implémentation clean-room équivalente à Matomo Live / Plausible Realtime / Swetrix Live.
+ * Agrège les visiteurs actifs concurrents sur fenêtres glissantes (30s, 1m, 3m, 5m),
+ * calcule la vélocité événementielle (events/sec) et détecte les pics de trafic instantanés.
+ */
+export interface VisitorPing {
+    sessionId: string;
+    visitorId: string;
+    url: string;
+    pageTitle?: string;
+    referrer?: string;
+    country?: string;
+    device?: 'desktop' | 'mobile' | 'tablet';
+    timestamp: number;
+    isHeartbeat?: boolean;
+}
+export interface ActivePageMetric {
+    url: string;
+    title: string;
+    activeVisitors: number;
+    percentage: number;
+}
+export interface CountryMetric {
+    country: string;
+    activeVisitors: number;
+}
+export interface RealTimeConcurrencySnapshot {
+    timestamp: number;
+    activeVisitors30s: number;
+    activeVisitors1m: number;
+    activeVisitors3m: number;
+    activeVisitors5m: number;
+    totalActiveSessions: number;
+    idleSessionsCount: number;
+    eventsPerSecond: number;
+    isSpikeDetected: boolean;
+    topPages: ActivePageMetric[];
+    topCountries: CountryMetric[];
+    deviceBreakdown: {
+        desktop: number;
+        mobile: number;
+        tablet: number;
+    };
+}
+export interface ConcurrencyMonitorConfig {
+    idleTimeoutMs?: number;
+    spikeThresholdFactor?: number;
+}
+export declare class RealTimeConcurrencyMonitor {
+    private readonly idleTimeoutMs;
+    private readonly spikeThresholdFactor;
+    constructor(config?: ConcurrencyMonitorConfig);
+    /**
+     * Analyse un lot de pings/événements récents et produit un instantané de concurrence en temps réel.
+     */
+    aggregate(pings: VisitorPing[], now?: number, baselineAverageEps?: number): RealTimeConcurrencySnapshot;
+}

package/dist/analytics/redirect-chain-shortcut-optimizer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 🔀 Redirect Chain & Loop Shortcut Optimizer
+ * Clean-room implementation inspired by Screaming Frog Redirect Chains & Cloudflare Bulk Redirects.
+ *
+ * Resolves multi-hop redirect chains, detects circular redirect loops and protocol downgrades,
+ * collapses intermediate hops into direct single-hop rules, and exports Nginx, Apache & Cloudflare configs.
+ *
+ * @license AGPL-3.0-or-later
+ */
+export interface RawRedirectRule {
+    sourceUrl: string;
+    targetUrl: string;
+    statusCode?: number;
+}
+export interface ResolvedRedirectChain {
+    initialSource: string;
+    finalTarget: string;
+    statusCode: number;
+    totalHops: number;
+    hops: string[];
+    isLoop: boolean;
+    isSelfRedirect: boolean;
+    hasProtocolDowngrade: boolean;
+    latencySavedEstimateMs: number;
+}
+export interface DirectShortcutRule {
+    sourceUrl: string;
+    targetUrl: string;
+    statusCode: number;
+    hopsEliminated: number;
+}
+export interface RedirectOptimizationReport {
+    totalRulesAnalyzed: number;
+    totalChainsCount: number;
+    longChainsCount: number;
+    loopsCount: number;
+    protocolDowngradesCount: number;
+    totalHopsEliminated: number;
+    totalEstimatedLatencySavedMs: number;
+    chains: ResolvedRedirectChain[];
+    directShortcuts: DirectShortcutRule[];
+    exports: {
+        cloudflareRedirects: string;
+        nginxRewrites: string;
+        apacheHtaccess: string;
+    };
+    summary: {
+        healthGrade: "A" | "B" | "C" | "D" | "F";
+        actionableAdvice: string[];
+    };
+}
+export declare class RedirectChainShortcutOptimizer {
+    private static readonly MAX_HOPS_LIMIT;
+    /**
+     * Optimizes redirect rules and collapses multi-hop chains into direct single-hop routes.
+     */
+    static optimize(rules: RawRedirectRule[]): RedirectOptimizationReport;
+    private static normalizeUrl;
+    private static extractPath;
+    private static emptyReport;
+}