@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/regex-redirect-engine.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 🔀 Regex Redirect Engine & Routing Manager
+ *
+ * Implements the signature feature of ethercreative/seo (Craft CMS):
+ * - High-speed Regex / PCRE route matching with capture group substitutions ($1, $2, or $<name>)
+ * - HTTP Status Code Management (301 Permanent, 302 Found, 307 Temp, 308 Permanent Redirect, 410 Gone, 451 Legal)
+ * - Infinite Loop / Circular Redirect Detector (detects A -> B -> A and self-redirects)
+ * - Query String Preservation / Stripping
+ * - Batch Rule Evaluator for regression testing migrations
+ */
+export interface RegexRedirectRule {
+    id: string;
+    pattern: string;
+    target: string;
+    statusCode: 301 | 302 | 307 | 308 | 410 | 451;
+    isRegex: boolean;
+    preserveQueryString?: boolean;
+    caseSensitive?: boolean;
+    note?: string;
+    isActive?: boolean;
+}
+export interface RedirectMatchResult {
+    matched: boolean;
+    rule?: RegexRedirectRule;
+    originalUrl: string;
+    targetUrl?: string;
+    statusCode?: number;
+    executionTimeMicros: number;
+}
+export interface RedirectLoopCheckResult {
+    hasLoop: boolean;
+    loopChain: string[];
+    message: string;
+}
+export declare class RegexRedirectEngine {
+    private rules;
+    constructor(initialRules?: RegexRedirectRule[]);
+    /**
+     * Adds or updates a rule in the engine.
+     */
+    addRule(rule: RegexRedirectRule): this;
+    /**
+     * Evaluates an incoming URL path against all registered redirect rules.
+     */
+    match(requestPath: string): RedirectMatchResult;
+    /**
+     * Traces a URL through the redirection chain to detect circular loops or infinite chains.
+     * Maximum hops allowed: 10.
+     */
+    detectLoop(startUrl: string, maxHops?: number): RedirectLoopCheckResult;
+    /**
+     * Runs a batch regression test on migration URLs.
+     */
+    batchTest(testCases: {
+        inputPath: string;
+        expectedTarget?: string;
+        expectedStatus?: number;
+    }[]): {
+        total: number;
+        passedCount: number;
+        failedCount: number;
+        successRate: number;
+        results: {
+            inputPath: string;
+            matched: boolean;
+            targetUrl?: string;
+            statusCode?: number;
+            passed: boolean;
+            error?: string;
+        }[];
+    };
+    private normalizePath;
+    private parsePathAndQuery;
+    private buildTargetUrl;
+}

package/dist/report-builder.d.ts

@@ -0,0 +1,79 @@
+/**
+ * G5 — Report Builder (SQL ad-hoc)
+ *
+ * LynxSEO: SqlTab.tsx + SqlEditor.tsx + SeoQueryBuilder + sql-query-builder.ts
+ *          + report-builder.ts (nouveau - logique SQL builder pure)
+ * Inspiration: Metabase SQL editor + documentation mentionnée
+ *
+ * NOTE: SqlTab.tsx + SqlEditor.tsx + SeoQueryBuilder + sql-query-builder.ts
+ * fournissent l'interface SQL dans l'interface LynxSEO, mais report-builder.ts
+ * offre la logique de construction de requêtes SQL pures (sans dépendance
+ * à l'interface React) réutilisable dans des scripts, des API, ou des tests.
+ */
+/** Types de fonctions SQL supportées */
+export type SqlFunction = "COUNT" | "SUM" | "AVG" | "MIN" | "MAX" | "STDEV" | "VARIANCE";
+/** Opérateurs de filtrage SQL */
+export type SqlOperator = "=" | "!=" | ">" | ">=" | "<" | "<=" | "LIKE" | "ILIKE";
+/** Condition de filtrage SQL */
+export type SqlCondition = {
+    field: string;
+    operator: SqlOperator;
+    value: unknown;
+};
+/** Sous-requête SQL */
+export type SqlSubQuery = {
+    select: string[];
+    from: string;
+    where?: SqlCondition[];
+    groupBy?: string[];
+    having?: SqlCondition[];
+};
+/** Requête SQL construite */
+export type BuiltSqlQuery = {
+    select: string[];
+    from: string;
+    where?: SqlCondition[];
+    groupBy?: string[];
+    having?: SqlCondition[];
+    orderBy?: {
+        field: string;
+        direction: "ASC" | "DESC";
+    };
+    limit?: number;
+    functions?: SqlFunction[];
+};
+/** Builder de requête SQL pas à pas */
+export declare class SqlQueryBuilderClass {
+    private parts;
+    /** Définir la clause SELECT */
+    select(...fields: string[]): this;
+    /** Ajouter une fonction d'agrégation */
+    aggregate(func: SqlFunction, field: string): this;
+    /** Définir la clause FROM */
+    from(table: string): this;
+    /** Ajouter une condition WHERE */
+    where(condition: SqlCondition | SqlCondition[]): this;
+    /** Ajouter un GROUP BY */
+    groupBy(...fields: string[]): this;
+    /** Ajouter une clause HAVING */
+    having(condition: SqlCondition | SqlCondition[]): this;
+    /** Ajouter un ORDER BY */
+    orderBy(field: string, direction?: "ASC" | "DESC"): this;
+    /** Ajouter un LIMIT */
+    limit(n: number): this;
+    /** Construire la chaîne de requête */
+    build(): string;
+}
+/** Créer une requête à partir d'un schéma structuré */
+export declare function buildQueryFromSchema(schema: BuiltSqlQuery): string;
+/** Exécuter une requête SQL (placeholder - la vraie exécution via Drizzle/Hyperdrive) */
+export declare function executeQuery<T = any>(query: string, parameters?: unknown[]): Promise<T[]>;
+/** Obtenir les métadonnées d'une table */
+export declare function getTableMetadata(tableName: string): Promise<{
+    columns: {
+        name: string;
+        type: string;
+        nullable: boolean;
+    }[];
+    primaryKey?: string[];
+}>;

package/dist/resource-hub-generator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 📚 Curated Resource Hub & Programmatic Listicle Page Generator
+ *
+ * Automatically transforms curated bookmarks and web archives into
+ * indexable, high-ranking SEO resource hub pages (Listicles, Directories, Tool Repositories)
+ * with complete Schema.org CollectionPage + ItemList markup, AEO/GEO citability,
+ * and multi-format publishing readiness.
+ */
+export interface ResourceHubItem {
+    title: string;
+    url: string;
+    description?: string;
+    category?: string;
+    tags?: string[];
+    readTimeMinutes?: number;
+    waybackUrl?: string | null;
+    httpStatus?: number | null;
+}
+export interface ResourceHubInput {
+    hubTitle: string;
+    targetKeyword: string;
+    hubDescription?: string;
+    authorName?: string;
+    items: ResourceHubItem[];
+    canonicalUrl?: string;
+    linkAttributes?: "dofollow" | "nofollow" | "sponsored";
+}
+export interface GeneratedResourceHub {
+    metaTitle: string;
+    metaDescription: string;
+    h1: string;
+    slug: string;
+    schemaJsonLd: Record<string, unknown>;
+    markdownContent: string;
+    htmlContent: string;
+    itemCount: number;
+    estimatedTotalReadTime: number;
+}
+export declare class ResourceHubGenerator {
+    /**
+     * Generates a complete SEO-optimized Resource Hub / Directory page from an array of links.
+     */
+    static generateHubPage(input: ResourceHubInput): GeneratedResourceHub;
+}

package/dist/reverse-etl/audience-sync.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Reverse ETL — Audience Sync & Customer Match Engine
+ * RudderStack CDP Parity
+ *
+ * Synchronise des segments d'utilisateurs ou des cohortes de base de données
+ * vers les plateformes publicitaires (Meta Custom Audiences, Google Customer Match,
+ * TikTok Audiences, LinkedIn Matched Audiences).
+ *
+ * Règles :
+ * - Normalisation stricte et hachage SHA-256 de chaque PII (email, téléphone, identifiant externe).
+ * - Formatage des payloads par plateforme (Meta schema arrays, Google operations, etc.).
+ * - Découpage automatique en lots (batching) pour respecter les plafonds d'API des plateformes.
+ * - Idempotence et génération de rapports de synchronisation (statistiques de synchronisation).
+ */
+export type AudienceSyncDestination = "meta_custom_audience" | "google_customer_match" | "tiktok_audience" | "linkedin_matched_audience";
+export type AudienceSyncAction = "add" | "remove" | "replace";
+export interface RawAudienceRecord {
+    email?: string | null;
+    phone?: string | null;
+    externalId?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    country?: string | null;
+    city?: string | null;
+    zipCode?: string | null;
+    mobileAdvertisingId?: string | null;
+}
+export interface HashedAudienceRecord {
+    emailHash?: string;
+    phoneHash?: string;
+    externalIdHash?: string;
+    firstNameHash?: string;
+    lastNameHash?: string;
+    countryCode?: string;
+    cityHash?: string;
+    zipCodeHash?: string;
+    mobileAdvertisingId?: string;
+}
+export interface AudienceSyncConfig {
+    id: string;
+    name: string;
+    destination: AudienceSyncDestination;
+    /** Identifiant de la liste ou audience côté régie (ex: act_123/customaudiences/456, ou userListId) */
+    targetAudienceId: string;
+    action: AudienceSyncAction;
+    /** Taille maximale d'un lot envoyé en un appel API (défaut: 5000) */
+    batchSize?: number;
+}
+export interface PreparedAudienceBatch {
+    destination: AudienceSyncDestination;
+    targetAudienceId: string;
+    action: AudienceSyncAction;
+    batchIndex: number;
+    totalRecordsInBatch: number;
+    payload: Record<string, unknown>;
+}
+export interface AudienceSyncStats {
+    totalRecords: number;
+    validRecords: number;
+    droppedRecords: number;
+    batchesCount: number;
+    destination: AudienceSyncDestination;
+    action: AudienceSyncAction;
+}
+export interface AudienceSyncResult {
+    stats: AudienceSyncStats;
+    batches: PreparedAudienceBatch[];
+}
+/**
+ * Normalise et hache les identifiants d'un enregistrement utilisateur selon les standards publicitaires.
+ */
+export declare function normalizeAndHashAudienceRecord(record: RawAudienceRecord): Promise<HashedAudienceRecord | null>;
+/**
+ * Prépare et structure l'ensemble de la synchronisation Reverse ETL d'une cohorte.
+ */
+export declare function prepareAudienceSync(config: AudienceSyncConfig, records: RawAudienceRecord[]): Promise<AudienceSyncResult>;

package/dist/rich-results-validator.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 🦁 LynxSEO Google Rich Results & Schema.org Validator
+ *
+ *
+ * Implements Google Search Central's official Rich Results validation rules for
+ * structured data (JSON-LD, Microdata, RDFa).
+ *
+ * Supported Google Rich Result Types:
+ * - Product (including Merchant listings, offers, aggregateRating)
+ * - Article / NewsArticle / BlogPosting
+ * - LocalBusiness / Store / Restaurant
+ * - FAQPage
+ * - Recipe
+ * - BreadcrumbList
+ * - VideoObject
+ * - Event
+ * - Organization / Brand
+ * - JobPosting
+ */
+export interface SchemaValidationError {
+    property: string;
+    message: string;
+    severity: "CRITICAL_MISSING" | "RECOMMENDED_MISSING" | "INVALID_VALUE";
+    googleDocRef: string;
+}
+export interface SchemaAuditResult {
+    schemaType: string;
+    isEligibleForRichResults: boolean;
+    errors: SchemaValidationError[];
+    warnings: SchemaValidationError[];
+}
+export interface RichResultsValidationReport {
+    url?: string;
+    totalSchemasFound: number;
+    eligibleSchemasCount: number;
+    ineligibleSchemasCount: number;
+    overallRichResultEligible: boolean;
+    schemas: SchemaAuditResult[];
+    recommendations: string[];
+}
+export declare class GoogleRichResultsValidator {
+    /**
+     * Parse and extract all JSON-LD schemas from an HTML string or array of objects
+     */
+    static extractJsonLd(htmlOrObjects: string | Record<string, unknown>[]): Record<string, unknown>[];
+    /**
+     * Validate a single schema object against Google Search Central Rich Results criteria
+     */
+    static validateSingleSchema(schema: Record<string, unknown>): SchemaAuditResult;
+    /**
+     * Audit all JSON-LD structured data on a page or HTML content
+     */
+    static validatePage(htmlOrSchemas: string | Record<string, unknown>[], url?: string): RichResultsValidationReport;
+}

package/dist/rivo-sync-engine.d.ts

@@ -0,0 +1,33 @@
+export interface RivoPointsEventPayload {
+    merchantApiKey: string;
+    customerIdentifier: string;
+    pointsAmount: number;
+    source?: "manual" | "custom_action" | "referral_complete" | "visit_url";
+    externalNote?: string;
+    internalNote?: string;
+    skipEmail?: boolean;
+}
+export interface RivoSyncResult {
+    success: boolean;
+    pointsEventId?: string;
+    error?: string;
+}
+export interface RivoSyncConfig {
+    fetchFn?: typeof fetch;
+    apiBaseUrl?: string;
+}
+export declare class RivoSyncEngine {
+    private fetchFn;
+    private apiBaseUrl;
+    constructor(config?: RivoSyncConfig);
+    /**
+     * Crédite des points de fidélité ou enrôle un client dans le programme Rivo Loyalty.
+     * Endpoint: POST https://developer-api.rivo.io/merchant_api/v1/points_events
+     */
+    grantLoyaltyPoints(input: RivoPointsEventPayload): Promise<RivoSyncResult>;
+    /**
+     * Enrôle un client dans le palier gratuit Rivo Loyalty & Referrals.
+     * Endpoint: POST https://developer-api.rivo.io/merchant_api/v1/memberships/{customer_identifier}/enroll_free_tier
+     */
+    enrollFreeTier(merchantApiKey: string, customerIdentifier: string): Promise<RivoSyncResult>;
+}

package/dist/robots-policy.d.ts

@@ -0,0 +1,54 @@
+/**
+ * RFC 9309 robots.txt policy engine.
+ *
+ * Parses robots.txt into merged user-agent groups, selects the most specific
+ * group for a crawler and evaluates allow/disallow rules with longest-match
+ * precedence. Pure in-memory, zero runtime dependencies.
+ */
+export interface RobotsRule {
+    type: "allow" | "disallow";
+    pattern: string;
+}
+export interface RobotsGroup {
+    userAgents: string[];
+    rules: RobotsRule[];
+    crawlDelaySec?: number;
+}
+export interface RobotsPolicy {
+    groups: RobotsGroup[];
+    sitemaps: string[];
+    host?: string;
+}
+export interface RobotsMatchResult {
+    allowed: boolean;
+    matchedRule: RobotsRule | null;
+    crawlDelaySec?: number;
+}
+export type RobotsFetchDecision = "allow_all" | "disallow_all" | "retry_later" | "parse";
+/**
+ * Parses robots.txt content into a normalized policy.
+ */
+export declare function parseRobotsTxt(text: string): RobotsPolicy;
+/**
+ * Returns the group whose product token is the longest case-insensitive
+ * substring of the crawler user-agent, falling back to the wildcard group.
+ */
+export declare function selectRobotsGroup(policy: RobotsPolicy, userAgent: string): RobotsGroup | null;
+/**
+ * Tests a robots.txt path pattern against a path and query string.
+ */
+export declare function matchRobotsPattern(pattern: string, pathAndQuery: string): boolean;
+/**
+ * Applies a pre-selected group to a path. The optional user-agent is kept for
+ * API symmetry; group selection has already happened by this point.
+ */
+export declare function isPathAllowedByGroup(group: RobotsGroup | null, pathAndQuery: string, userAgent?: string): RobotsMatchResult;
+/**
+ * Evaluates a URL for a crawler. An unparseable URL is denied because denying
+ * is safer for crawlers than speculatively fetching it.
+ */
+export declare function isUrlAllowed(policy: RobotsPolicy, url: string, userAgent: string): RobotsMatchResult;
+/**
+ * Maps a robots.txt HTTP status to the crawler fetch strategy.
+ */
+export declare function robotsFetchDecision(status: number): RobotsFetchDecision;

package/dist/robots-txt-simulator.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 🤖 RFC 9309 Robots.txt Simulator & Multi-Agent Tester
+ *
+ * Provides production-grade robots.txt evaluation in pure TypeScript:
+ * 1. Parses User-agent, Allow, Disallow, Crawl-delay, and Sitemap directives.
+ * 2. Implements RFC 9309 longest-match priority rule (more specific path wins).
+ * 3. Supports standard wildcards (* and $).
+ * 4. Multi-agent cross-testing (Cartesian product of Agents × URLs) to verify
+ *    crawler access for Googlebot, GPTBot, ClaudeBot, PerplexityBot, Applebot, etc.
+ *
+ * Pure In-Memory, 0 native dependencies, < 0.1ms per lookup.
+ */
+export interface RobotsDirective {
+    type: "allow" | "disallow";
+    path: string;
+    pattern: RegExp;
+    length: number;
+}
+export interface AgentRules {
+    directives: RobotsDirective[];
+    crawlDelay?: number;
+}
+export interface RobotsTxtParseResult {
+    sitemaps: string[];
+    agents: Record<string, AgentRules>;
+    rawLineCount: number;
+}
+export interface CrawlAccessCheck {
+    urlPath: string;
+    userAgent: string;
+    allowed: boolean;
+    matchingRule?: {
+        type: "allow" | "disallow";
+        path: string;
+    };
+    matchedUserAgent: string;
+}
+export type BotTier = "training" | "search" | "user";
+export interface BotProfile {
+    name: string;
+    category: "search" | "ai_training" | "ai_search" | "social";
+    tier: BotTier;
+    purpose: string;
+    searchRankImpact: boolean;
+}
+export declare const KNOWN_BOT_PROFILES: Record<string, BotProfile>;
+export interface BotPolicyDiagnostic {
+    googlebotAllowed: boolean;
+    googleExtendedAllowed: boolean;
+    aiSearchBotsBlocked: string[];
+    aiTrainingBotsBlocked: string[];
+    aiUserBotsBlocked: string[];
+    tierSummary: {
+        trainingAllowed: number;
+        trainingTotal: number;
+        searchAllowed: number;
+        searchTotal: number;
+        userAllowed: number;
+        userTotal: number;
+    };
+    advisories: string[];
+}
+export declare class RobotsTxtSimulator {
+    /**
+     * Parses robots.txt into the simulator's grouped view. Delegates to the
+     * shared RFC 9309 parser so group merging and empty-directive handling match
+     * every other consumer in the engine.
+     */
+    static parse(robotsTxtContent: string): RobotsTxtParseResult;
+    /**
+     * Evaluates if a given URL path is allowed for a specific user-agent according to RFC 9309 rules.
+     */
+    static isAllowed(parsed: RobotsTxtParseResult, urlPath: string, userAgent?: string): CrawlAccessCheck;
+    /**
+     * Tests a matrix of User-Agents × URLs (cartesian product).
+     * Évalue une règle robots.txt pour un agent donné
+     */
+    static testMatrix(robotsTxtContent: string, userAgents: string[], urls: string[]): CrawlAccessCheck[];
+    /**
+     * Analyzes crawler access rules across all 27 AI bots and classifies access by tier.
+     * Differentiates AI Training, AI Search/Citations, and AI User on-demand browsing.
+     */
+    static diagnoseBotPolicy(robotsTxtContent: string, samplePath?: string): BotPolicyDiagnostic;
+    /**
+     * Generates a production-grade, RFC 9309 compliant robots.txt template
+     * specifically optimized for Generative Engine Optimization (GEO/AEO).
+     */
+    static generateAeoRobotsTxt(options?: {
+        allowSearchCitations?: boolean;
+        blockTraining?: boolean;
+        customDisallows?: string[];
+        sitemapUrl?: string;
+    }): string;
+}

package/dist/robots-unified.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 🤖 Unified Robots.txt Parser (RFC 9309)
+ *
+ * Module unique et unifié pour l'évaluation des règles robots.txt. Fusionne les
+ * trois parseurs divergents existants (`robots-policy.ts`, `site-crawler.ts`,
+ * `crawler/native-crawler.ts`) en une seule source de vérité.
+ *
+ * Conformité RFC 9309 :
+ * - Règle du plus long match (longest-match priority).
+ * - Wildcards * et $.
+ * - Crawl-delay par agent.
+ * - Sitemaps.
+ * - Code HTTP 429/5xx → skip (ne pas explorer, réessayer plus tard) — inspiré
+ *   de la logique de robustesse crawl.
+ * - Cibles de redirection vérifiées.
+ *
+ * Zéro dépendance, pur TypeScript.
+ */
+import { type RobotsFetchDecision, type RobotsRule } from "./robots-policy";
+/** Résultat d'une vérification d'accès unifiée. */
+export interface UnifiedCrawlAccess {
+    /** L'URL testée. */
+    url: string;
+    /** Le chemin testé. */
+    path: string;
+    /** L'agent utilisateur testé. */
+    userAgent: string;
+    /** L'accès est-il autorisé ? */
+    allowed: boolean;
+    /** Décision de fetch (allow / disallow_all / unreachable). */
+    fetchDecision: RobotsFetchDecision;
+    /** Règle qui a匹配 (si aucune, l'accès par défaut s'applique). */
+    matchedRule?: {
+        type: "allow" | "disallow";
+        pattern: string;
+    };
+    /** Agent utilisateur correspondant. */
+    matchedUserAgent: string;
+    /** Délai de crawl en secondes (undefined si non spécifié). */
+    crawlDelaySec?: number;
+    /** Sitemaps déclarés dans le robots.txt. */
+    sitemaps: string[];
+    /** Raison textuelle de la décision. */
+    reason: string;
+}
+/** Règle par agent (format unifié). */
+export interface UnifiedAgentRule {
+    userAgent: string;
+    disallows: string[];
+    allows: string[];
+    crawlDelaySec?: number;
+}
+/** Résultat de parsing unifié. */
+export interface UnifiedRobotsPolicy {
+    groups: UnifiedAgentRule[];
+    sitemaps: string[];
+    /** Délai de crawl par défaut (secondes). */
+    defaultCrawlDelaySec?: number;
+}
+/** Statut HTTP pertinent pour la décision robots. */
+export type RobotsHttpStatus = 200 | 403 | 401 | 429 | 500 | 502 | 503 | 504;
+/**
+ * Parse un contenu robots.txt en politique unifiée.
+ *
+ * @param content Contenu brut du fichier robots.txt.
+ * @returns Politique unifiée avec règles par agent et sitemaps.
+ */
+export declare function parseUnifiedRobotsTxt(content: string): UnifiedRobotsPolicy;
+/**
+ * Convertit une politique unifiée au format RobotsRule[] (liste plate de
+ * règles allow/disallow, compatibilité avec robots-policy.ts).
+ */
+export declare function toRobotsRuleList(policy: UnifiedRobotsPolicy): RobotsRule[];
+/**
+ * Convertit une liste RobotsRule[] en politique unifiée.
+ * Les règles sans user-agent sont regroupées sous "*".
+ */
+export declare function fromRobotsRuleList(rules: RobotsRule[]): UnifiedRobotsPolicy;
+/**
+ * Vérifie si un chemin est autorisé pour un agent donné, en tenant compte
+ * du statut HTTP de la requête robots.txt.
+ *
+ * - 200 : évaluation normale des règles.
+ * - 401/403 : disallow_all (accès refusé par le serveur).
+ * - 429/500/502/503/504 : unreachable (serveur indisponible → skip, réessayer).
+ *
+ * @param urlStr URL absolue ou chemin à tester.
+ * @param userAgent Agent utilisateur (défaut "*").
+ * @param policy Politique robots unifiée (ou contenu brut).
+ * @param statusCode Statut HTTP de la réponse robots.txt (défaut 200).
+ * @returns Résultat d'accès unifié.
+ */
+export declare function checkUnifiedAccess(urlStr: string, userAgent: string | undefined, policyOrContent: UnifiedRobotsPolicy | string, statusCode?: RobotsHttpStatus): UnifiedCrawlAccess;
+/**
+ * Vérifie si une URL est autorisée pour un agent (booléen simple).
+ */
+export declare function isUnifiedAllowed(urlStr: string, userAgent: string | undefined, policyOrContent: UnifiedRobotsPolicy | string, statusCode?: RobotsHttpStatus): boolean;
+/**
+ * Récupère le crawl-delay pour un agent donné.
+ */
+export declare function getUnifiedCrawlDelay(userAgent: string, policyOrContent: UnifiedRobotsPolicy | string): number | undefined;
+/**
+ * Récupère les sitemaps déclarés.
+ */
+export declare function getUnifiedSitemaps(policyOrContent: UnifiedRobotsPolicy | string): string[];
+/**
+ * Vérifie une matrice User-Agents × URLs (produit cartésien).
+ */
+export declare function checkUnifiedMatrix(userAgents: string[], urls: string[], policyOrContent: UnifiedRobotsPolicy | string, statusCode?: RobotsHttpStatus): UnifiedCrawlAccess[];
+/**
+ * Détermine si le contenu robots.txt doit être ignoré (skip) en raison
+ * d'un statut HTTP 429 ou 5xx.
+ */
+export declare function shouldSkipRobots(statusCode: number): boolean;
+/**
+ * Vérifie une cible de redirection : si l'URL de destination est autorisée.
+ * Utile pour s'assurer qu'on ne suit pas une redirection vers une page bloquée.
+ */
+export declare function checkRedirectTarget(sourceUrl: string, targetUrl: string, userAgent: string, policyOrContent: UnifiedRobotsPolicy | string, statusCode?: RobotsHttpStatus): UnifiedCrawlAccess;
+declare const _default: {
+    parseUnifiedRobotsTxt: typeof parseUnifiedRobotsTxt;
+    checkUnifiedAccess: typeof checkUnifiedAccess;
+    isUnifiedAllowed: typeof isUnifiedAllowed;
+    getUnifiedCrawlDelay: typeof getUnifiedCrawlDelay;
+    getUnifiedSitemaps: typeof getUnifiedSitemaps;
+    checkUnifiedMatrix: typeof checkUnifiedMatrix;
+    shouldSkipRobots: typeof shouldSkipRobots;
+    checkRedirectTarget: typeof checkRedirectTarget;
+    toRobotsRuleList: typeof toRobotsRuleList;
+    fromRobotsRuleList: typeof fromRobotsRuleList;
+};
+export default _default;