@consilioweb/payload-seo-analyzer 1.7.1

package/dist/index.d.cts

@@ -0,0 +1,1416 @@
+import { Field, Plugin, Payload, PayloadHandler, CollectionConfig, CollectionAfterChangeHook } from 'payload';
+
+/**
+ * SEO Analyzer — Type definitions.
+ * Shared across all rule modules and the main orchestrator.
+ */
+type CheckStatus = 'pass' | 'warning' | 'fail';
+type CheckCategory = 'critical' | 'important' | 'bonus';
+/** Rule group label — used by the UI to group checks by topic */
+type RuleGroup = 'title' | 'meta-description' | 'url' | 'headings' | 'content' | 'images' | 'linking' | 'social' | 'schema' | 'readability' | 'quality' | 'secondary-keywords' | 'cornerstone' | 'freshness' | 'technical' | 'accessibility' | 'ecommerce';
+interface SeoCheck {
+    id: string;
+    label: string;
+    status: CheckStatus;
+    message: string;
+    category: CheckCategory;
+    weight: number;
+    /** Which rule group this check belongs to */
+    group: RuleGroup;
+    /** Actionable tip displayed below the message when status is not 'pass' */
+    tip?: string;
+}
+type SeoLevel = 'poor' | 'ok' | 'good' | 'excellent';
+interface SeoAnalysis {
+    score: number;
+    level: SeoLevel;
+    checks: SeoCheck[];
+}
+interface SeoInput {
+    metaTitle?: string;
+    metaDescription?: string;
+    metaImage?: unknown;
+    slug?: string;
+    focusKeyword?: string;
+    /** Secondary focus keywords (in addition to the primary keyword) */
+    focusKeywords?: string[];
+    heroTitle?: string;
+    heroRichText?: unknown;
+    heroLinks?: unknown[];
+    heroMedia?: unknown;
+    blocks?: unknown[];
+    /** For posts — the Lexical content field */
+    content?: unknown;
+    /** Whether the content is a post (for word count thresholds) */
+    isPost?: boolean;
+    /** Whether the content is a product (triggers e-commerce SEO checks) */
+    isProduct?: boolean;
+    /** Whether the content is marked as cornerstone/pillar content */
+    isCornerstone?: boolean;
+    /** ISO date string — last time the document was updated */
+    updatedAt?: string;
+    /** ISO date string — last time the content was manually reviewed */
+    contentLastReviewed?: string;
+    /** Canonical URL for this page (if explicitly set) */
+    canonicalUrl?: string;
+    /** Robots meta directives (e.g. 'noindex', 'nofollow', 'noindex, nofollow') */
+    robotsMeta?: string;
+    /** Whether this content is a Payload Global (disables URL/slug checks) */
+    isGlobal?: boolean;
+}
+/** Page type for adapting SEO rule severity */
+type PageType = 'legal' | 'contact' | 'form' | 'home' | 'service' | 'local-seo' | 'blog' | 'agency' | 'resource' | 'generic';
+/**
+ * Overridable thresholds for the SEO analyzer.
+ * All fields are optional — defaults from constants.ts are used when omitted.
+ */
+interface SeoThresholds {
+    titleLengthMin?: number;
+    titleLengthMax?: number;
+    metaDescLengthMin?: number;
+    metaDescLengthMax?: number;
+    minWordsGeneric?: number;
+    minWordsPost?: number;
+    keywordDensityMin?: number;
+    keywordDensityMax?: number;
+    fleschScorePass?: number;
+    slugMaxLength?: number;
+}
+/**
+ * Configuration for the SEO analyzer.
+ * All fields are optional — sensible defaults are used when omitted.
+ * Use this to adapt the analyzer to different projects/sites.
+ */
+interface SeoConfig {
+    /** Additional local SEO slugs to recognize (appended to pattern detection) */
+    localSeoSlugs?: string[];
+    /** Regex pattern for detecting local-SEO pages (checked in addition to slug list) */
+    localSeoPattern?: RegExp;
+    /** Additional stop word compounds for slug analysis (appended to defaults) */
+    stopWordCompounds?: Array<readonly [string, string]>;
+    /** Maximum recursion depth for Lexical tree extraction (default: 50) */
+    maxRecursionDepth?: number;
+    /** Base URL of the site (used for canonical URL validation) */
+    siteUrl?: string;
+    /** Site name (used for brand duplicate check in titles) */
+    siteName?: string;
+    /** Rule groups to disable entirely */
+    disabledRules?: RuleGroup[];
+    /** Override the weight of all checks within a rule group */
+    overrideWeights?: Partial<Record<RuleGroup, number>>;
+    /** Custom thresholds (override defaults from constants.ts) */
+    thresholds?: SeoThresholds;
+    /** Locale for language-specific analysis (default: 'fr') */
+    locale?: 'fr' | 'en';
+}
+/**
+ * Granular feature flags for the SEO plugin.
+ * All features default to `true`. Set a feature to `false` to disable it
+ * and avoid loading its collections, endpoints, and admin views.
+ *
+ * The core analyzer sidebar, validate endpoint, and meta fields are always active.
+ */
+interface SeoFeatures {
+    /** Core SEO analyzer sidebar — always enabled, cannot be disabled */
+    analyzer?: boolean;
+    /** Dashboard view with overview of all pages (/admin/seo) */
+    dashboard?: boolean;
+    /** Redirect manager (collection + CRUD endpoints + view) */
+    redirects?: boolean;
+    /** Performance / GSC import (collection + endpoints + view) */
+    performance?: boolean;
+    /** Link graph visualization (endpoint + view) */
+    linkGraph?: boolean;
+    /** Keyword research (endpoint + view) */
+    keywords?: boolean;
+    /** Cannibalization detection (endpoint + view) */
+    cannibalization?: boolean;
+    /** Schema.org / JSON-LD builder (endpoint + view) */
+    schemaBuilder?: boolean;
+    /** Sitemap audit (endpoint + view) */
+    sitemapAudit?: boolean;
+    /** SEO Logs — 404 tracking (collection + endpoints) */
+    seoLogs?: boolean;
+    /** Score history tracking (collection + hook + endpoint) */
+    scoreHistory?: boolean;
+    /** External links checker (endpoint) */
+    externalLinks?: boolean;
+    /** AI content generation/rewrite (endpoints) */
+    aiFeatures?: boolean;
+    /** Duplicate content detection (endpoint) */
+    duplicateContent?: boolean;
+    /** Settings view (/admin/seo-config) */
+    settings?: boolean;
+}
+/** Pre-computed context shared across all rule modules to avoid redundant work */
+interface AnalysisContext {
+    /** All plain text extracted from the page */
+    fullText: string;
+    /** Word count of fullText */
+    wordCount: number;
+    /** Normalised focus keyword (lowercase, trimmed) — empty string if none */
+    normalizedKeyword: string;
+    /** Normalised secondary keywords (lowercase, trimmed, duplicates removed) */
+    secondaryNormalizedKeywords: string[];
+    /** All headings found in the content */
+    allHeadings: Array<{
+        tag: string;
+        text: string;
+    }>;
+    /** All links found in the content (url + anchor text) */
+    allLinks: Array<{
+        url: string;
+        text: string;
+    }>;
+    /** Image statistics from blocks + content */
+    imageStats: {
+        total: number;
+        withAlt: number;
+        altTexts: string[];
+    };
+    /** All sentences extracted from fullText */
+    sentences: string[];
+    /** Whether the content is a blog post (affects thresholds) */
+    isPost: boolean;
+    /** Detected page type for adapting rule severity */
+    pageType: PageType;
+    /** SEO configuration (merged defaults + user overrides) */
+    config: SeoConfig;
+    /** Active locale for language-specific rules */
+    locale: 'fr' | 'en';
+}
+
+/**
+ * SEO Analyzer — Helper utilities.
+ * Pure functions for extracting data from Lexical JSON, counting words/syllables,
+ * and performing French-language readability analysis.
+ */
+/**
+ * Strip diacritical marks (accents) from text for comparison.
+ * "Réalité augmentée" → "realite augmentee"
+ * Used to avoid false negatives when comparing keywords against content.
+ */
+declare function normalizeForComparison(text: string): string;
+/**
+ * Slugify a keyword for URL comparison.
+ * Strips accents, special chars (.&/), and converts spaces to hyphens.
+ * "Next.js & React" → "nextjs-react"
+ * "design UX/UI" → "design-ux-ui"
+ */
+declare function slugifyKeyword(kw: string): string;
+/**
+ * Smart keyword matching adapted for French.
+ *
+ * For 1-2 word keywords: exact substring match (accent-insensitive).
+ * For 3+ word keywords: all significant words (>3 chars) must be present
+ * in the text. This handles French articles/prepositions that naturally
+ * separate keyword components ("politique de confidentialité" vs
+ * "politique confidentialité RGPD").
+ *
+ * Both `keyword` and `text` must be pre-normalized with `normalizeForComparison()`.
+ */
+declare function keywordMatchesText(normalizedKeyword: string, normalizedText: string): boolean;
+/**
+ * Count keyword occurrences in text with smart French matching.
+ *
+ * Returns exact occurrence count plus a word-level match flag for multi-word
+ * keywords where individual significant words appear but not as exact phrase.
+ * Also returns an estimated effective density.
+ */
+declare function countKeywordOccurrences(normalizedKeyword: string, normalizedText: string, totalWordCount: number): {
+    exactCount: number;
+    wordLevelMatch: boolean;
+    effectiveDensity: number;
+};
+
+/**
+ * Detect the page type from the slug (and optionally the collection) to adapt
+ * SEO rule severity. Unified version used by both the analyzer and AI prompts.
+ *
+ * Priority order:
+ * 1. Collection-based detection (posts → blog)
+ * 2. Exact slug matches (home, legal)
+ * 3. Pattern-based detection (local-seo, service, resource, agency, blog)
+ * 4. Fallback → generic
+ *
+ * @param extraLocalSeoSlugs Additional local SEO slugs from SeoConfig
+ */
+declare function detectPageType(slug: string, collection?: string, extraLocalSeoSlugs?: string[], locale?: 'fr' | 'en'): PageType;
+/**
+ * Recursively extract plain text from a Lexical JSON tree.
+ * @param maxDepth Maximum recursion depth to prevent stack overflow (default: 50)
+ */
+declare function extractTextFromLexical(node: unknown, maxDepth?: number): string;
+/**
+ * Extract headings from a Lexical JSON tree.
+ * Returns an array of { tag: 'h1' | 'h2' | ..., text: string }
+ * @param maxDepth Maximum recursion depth to prevent stack overflow (default: 50)
+ */
+declare function extractHeadingsFromLexical(node: unknown, maxDepth?: number): Array<{
+    tag: string;
+    text: string;
+}>;
+/**
+ * Extract links from a Lexical JSON tree.
+ * Returns an array of { url: string, text: string }
+ * @param maxDepth Maximum recursion depth to prevent stack overflow (default: 50)
+ */
+declare function extractLinksFromLexical(node: unknown, maxDepth?: number): Array<{
+    url: string;
+    text: string;
+}>;
+/**
+ * Extract link URLs from Lexical (flat array — backward compat).
+ */
+declare function extractLinkUrlsFromLexical(node: unknown): string[];
+/**
+ * Extract images from a Lexical JSON tree.
+ * @param maxDepth Maximum recursion depth to prevent stack overflow (default: 50)
+ */
+declare function extractImagesFromLexical(node: unknown, maxDepth?: number): {
+    total: number;
+    withAlt: number;
+    altTexts: string[];
+};
+/**
+ * Check images in blocks (MediaBlock, Content columns, etc.).
+ */
+declare function checkImagesInBlocks(blocks: unknown[]): {
+    total: number;
+    withAlt: number;
+    altTexts: string[];
+};
+/**
+ * Count words in a string.
+ */
+declare function countWords(text: string): number;
+/**
+ * Split text into sentences (French/English-aware).
+ * Handles common abbreviations (M., Mme., Mr., Mrs., etc.) to avoid false splits.
+ */
+declare function countSentences(text: string, locale?: 'fr' | 'en'): string[];
+/**
+ * Count syllables in a French word (Kandel-Moles approximation).
+ *
+ * Rules:
+ * 1. Count vowel groups (a, e, i, o, u, y, accented variants)
+ * 2. Silent final 'e' does not count (except single-syllable words)
+ * 3. Common diphthongs (eau, ou, ai, ei, au, oi, eu) count as 1 vowel group
+ */
+declare function countSyllablesFR(word: string): number;
+/**
+ * Count syllables in an English word.
+ * Handles silent-e, -ed/-es endings, common exceptions.
+ */
+declare function countSyllablesEN(word: string): number;
+/**
+ * Calculate Flesch reading ease adapted for French (Kandel-Moles formula).
+ * Flesch FR = 207 - 1.015 * (words/sentences) - 73.6 * (syllables/words)
+ *
+ * Returns a score from 0 (very difficult) to ~100 (very easy).
+ */
+declare function calculateFleschFR(text: string): number;
+/**
+ * Calculate Flesch reading ease — bilingual.
+ * FR: Kandel-Moles (207 - 1.015xASL - 73.6xASW)
+ * EN: Flesch-Kincaid (206.835 - 1.015xASL - 84.6xASW)
+ */
+declare function calculateFlesch(text: string, locale?: 'fr' | 'en'): number;
+/**
+ * Detect passive voice in a French sentence.
+ * Looks for "être" conjugations followed by a past participle,
+ * while excluding common passé composé verbs (aller, venir, arriver, etc.)
+ * that use "être" as auxiliary but are NOT passive voice.
+ *
+ * Also excludes state descriptions ("est basé à", "est situé à") that are
+ * natural in French B2B copy and not true passive constructions.
+ */
+declare function detectPassiveVoice(sentence: string, locale?: 'fr' | 'en'): boolean;
+/**
+ * Check whether a sentence contains a transition word/phrase.
+ */
+declare function hasTransitionWord(sentence: string, locale?: 'fr' | 'en'): boolean;
+/**
+ * Get the list of French stop words (for slug analysis).
+ */
+declare function getStopWordsFR(): readonly string[];
+/**
+ * Compound expressions in French where stop words are meaningful.
+ * These should NOT be flagged in slug analysis.
+ * Checks if a stop word at position `idx` in slug parts is part of a known expression.
+ */
+declare function isStopWordInCompoundExpression(parts: string[], idx: number, extraCompounds?: Array<readonly [string, string]>): boolean;
+/**
+ * French action verbs commonly used in CTAs.
+ */
+declare function getActionVerbsFR(): readonly string[];
+/**
+ * Check for long sections (>N words without a heading break).
+ * Returns the number of sections that exceed the threshold.
+ */
+declare function countLongSections(node: unknown, threshold?: number): number;
+/**
+ * Extract lists (ol/ul) from a Lexical JSON tree.
+ * Returns an array of { listType: 'bullet' | 'number', items: number }.
+ */
+declare function extractListsFromLexical(node: unknown, maxDepth?: number): Array<{
+    listType: string;
+    items: number;
+}>;
+/**
+ * Check heading hierarchy: no level skipping (e.g. h2 -> h4 without h3).
+ */
+declare function checkHeadingHierarchy(headings: Array<{
+    tag: string;
+    text: string;
+}>): boolean;
+
+/**
+ * Dashboard i18n — FR/EN translations for all dashboard UI components.
+ * Provides a simple, pragmatic translation system for the SEO Analyzer dashboard.
+ */
+type DashboardLocale = 'fr' | 'en' | (string & {});
+interface DashboardTranslations {
+    common: {
+        loading: string;
+        loadingError: string;
+        retry: string;
+        save: string;
+        saving: string;
+        cancel: string;
+        refresh: string;
+        exportCsv: string;
+        exportJson: string;
+        exportPdf: string;
+        edit: string;
+        delete: string;
+        add: string;
+        noResults: string;
+        previous: string;
+        next: string;
+        page: string;
+        selected: string;
+        deselectAll: string;
+        characters: string;
+        generate: string;
+        generating: string;
+        copy: string;
+        serverError: string;
+        networkError: string;
+        noTitle: string;
+        none: string;
+        article: string;
+        ok: string;
+        modify: string;
+    };
+    nav: {
+        dashboard: string;
+        sitemapAudit: string;
+        redirects: string;
+        cannibalization: string;
+        performance: string;
+        keywords: string;
+        schemaOrg: string;
+        linkGraph: string;
+        settings: string;
+        seo: string;
+    };
+    seoView: {
+        loadingAudit: string;
+        errorSaving: string;
+        auditTitle: string;
+        pagesAnalyzed: string;
+        markCornerstone: string;
+        unmarkCornerstone: string;
+        searchPlaceholder: string;
+        allCollections: string;
+        allScores: string;
+        goodScores: string;
+        needsWork: string;
+        criticalScores: string;
+        missingMeta: string;
+        missingH1: string;
+        lowReadability: string;
+        averageScore: string;
+        goodLabel: string;
+        needsWorkLabel: string;
+        criticalLabel: string;
+        noKeyword: string;
+        wordsAvg: string;
+        metaTitle: string;
+        metaDesc: string;
+        cornerstone: string;
+        collection: string;
+        score: string;
+        keyword: string;
+        h1: string;
+        og: string;
+        internal: string;
+        external: string;
+        words: string;
+        readability: string;
+        updated: string;
+        seoReport: string;
+        overview: string;
+        missingMetaTitle: string;
+        missingMetaDescription: string;
+        missingKeyword: string;
+        shortContent: string;
+        lowReadabilityIssue: string;
+        missingOgImage: string;
+        noInternalLinks: string;
+        lowOverallScore: string;
+        shortMetaTitle: string;
+        longMetaTitle: string;
+        shortMetaDesc: string;
+        longMetaDesc: string;
+        top5PriorityActions: string;
+        perPageDetails: string;
+        title: string;
+        slug: string;
+        issues: string;
+        identifiedIssues: string;
+        scoreDistribution: string;
+        good: string;
+        critical: string;
+        generatedBy: string;
+        resultsDisplayed: string;
+        noKeywordLabel: string;
+        wordsAverage: string;
+        readabilityAvg: string;
+        noTitleDesc: string;
+        previousLabel: string;
+    };
+    sitemapAudit: {
+        loading404: string;
+        title: string;
+        totalPages: string;
+        internalLinks: string;
+        linksPerPage: string;
+        average: string;
+        orphaned: string;
+        fragile: string;
+        brokenLinks: string;
+        searchPlaceholder: string;
+        orphanedPages: string;
+        fragilePages: string;
+        linkHubs: string;
+        logs404: string;
+        externalLinks: string;
+        noOrphanedPages: string;
+        orphanedPagesDesc: string;
+        zeroIncomingLinks: string;
+        noFragilePages: string;
+        fragilePagesDesc: string;
+        oneIncomingLink: string;
+        from: string;
+        anchor: string;
+        noLinkHubs: string;
+        linkHubsDesc: string;
+        links: string;
+        brokenLinksDesc: string;
+        created: string;
+        errors: string;
+        selectedItems: string;
+        selectAll: string;
+        suggestion: string;
+        targetSlug: string;
+        createdLabel: string;
+        no404Errors: string;
+        pages404Desc: string;
+        last: string;
+        ref: string;
+        ignore: string;
+        checkExternalLinksDesc: string;
+        scanExternalLinks: string;
+        verificationInProgress: string;
+        noBrokenLinks: string;
+        noExternalLinks: string;
+        total: string;
+        broken: string;
+        timeout: string;
+        all: string;
+        brokenLabel: string;
+        rescan: string;
+        forceNewVerification: string;
+        analyzingInternal: string;
+        brokenLinkTo: string;
+        linkFrom: string;
+    };
+    seoConfig: {
+        loading: string;
+        title: string;
+        subtitle: string;
+        saved: string;
+        siteName: string;
+        siteNameDesc: string;
+        ignoredPages: string;
+        ignoredPagesDesc: string;
+        pageSlugPlaceholder: string;
+        noIgnoredSlugs: string;
+        disabledRules: string;
+        disabledRulesDesc: string;
+        customThresholds: string;
+        customThresholdsDesc: string;
+        defaultLabel: string;
+        ruleGroupTitle: string;
+        ruleGroupMetaDescription: string;
+        ruleGroupUrlSlug: string;
+        ruleGroupHeadings: string;
+        ruleGroupContent: string;
+        ruleGroupImages: string;
+        ruleGroupLinks: string;
+        ruleGroupSocial: string;
+        ruleGroupStructuredData: string;
+        ruleGroupReadability: string;
+        ruleGroupQuality: string;
+        ruleGroupSecondaryKeywords: string;
+        ruleGroupCornerstone: string;
+        ruleGroupFreshness: string;
+        ruleGroupTechnical: string;
+        ruleGroupAccessibility: string;
+        ruleGroupEcommerce: string;
+        thresholdTitleMin: string;
+        thresholdTitleMax: string;
+        thresholdMetaDescMin: string;
+        thresholdMetaDescMax: string;
+        thresholdMinWordsPages: string;
+        thresholdMinWordsPosts: string;
+        thresholdKeywordDensityMin: string;
+        thresholdKeywordDensityMax: string;
+        thresholdFleschMin: string;
+        thresholdSlugMaxLength: string;
+        sitemapConfig: string;
+        sitemapExcludedSlugs: string;
+        slugToExcludePlaceholder: string;
+        noExcludedSlugs: string;
+        defaultChangeFrequency: string;
+        daily: string;
+        weekly: string;
+        monthly: string;
+        yearly: string;
+        defaultPriority: string;
+        defaultPriorityDesc: string;
+        priorityOverrides: string;
+        priorityOverridesDesc: string;
+        patternPlaceholder: string;
+        priority: string;
+        defaultShort: string;
+        addOverride: string;
+        sitemapPreview: string;
+        viewPreview: string;
+        refreshPreview: string;
+        pages: string;
+        included: string;
+        excluded: string;
+        url: string;
+        lastModified: string;
+        frequency: string;
+        breadcrumbConfig: string;
+        breadcrumbConfigDesc: string;
+        enableBreadcrumbs: string;
+        homePageLabel: string;
+        separator: string;
+        separatorDesc: string;
+        showOnHomePage: string;
+        showOnHomePageDesc: string;
+        preview: string;
+        websiteCreation: string;
+    };
+    redirectManager: {
+        loading: string;
+        title: string;
+        totalRedirects: string;
+        importCsv: string;
+        total: string;
+        permanent301: string;
+        temporary302: string;
+        addRedirect: string;
+        sourceUrl: string;
+        sourceUrlPlaceholder: string;
+        destinationUrl: string;
+        destinationUrlPlaceholder: string;
+        type: string;
+        adding: string;
+        searchPlaceholder: string;
+        urlToTestPlaceholder: string;
+        test: string;
+        noMatch: string;
+        sourceFrom: string;
+        destinationTo: string;
+        date: string;
+        actions: string;
+        noMatchingRedirects: string;
+        noRedirects: string;
+        redirectCreated: string;
+        redirectDeleted: string;
+        redirectsDeleted: string;
+        redirectModified: string;
+        noValidCsvRedirects: string;
+        redirectsExported: string;
+        exportError: string;
+        createdCount: string;
+        duplicatesCount: string;
+        errorsCount: string;
+    };
+    performance: {
+        days7: string;
+        days30: string;
+        days90: string;
+        loading: string;
+        title: string;
+        subtitle: string;
+        closeImport: string;
+        import: string;
+        importGscData: string;
+        fileType: string;
+        pasteJsonHint: string;
+        importing: string;
+        importedCount: string;
+        updatedCount: string;
+        noData: string;
+        noDataDesc: string;
+        importData: string;
+        totalClicks: string;
+        totalImpressions: string;
+        averageCtr: string;
+        averagePosition: string;
+        topPages: string;
+        clicks: string;
+        impressions: string;
+        ctrPercent: string;
+        position: string;
+        topQueries: string;
+        query: string;
+        xlsxEntriesLoaded: string;
+        pages: string;
+        queries: string;
+    };
+    schemaBuilder: {
+        localBusiness: string;
+        article: string;
+        product: string;
+        faq: string;
+        howTo: string;
+        organization: string;
+        event: string;
+        choose: string;
+        jsonLdPreview: string;
+        liveUpdate: string;
+        copyJsonLd: string;
+        copyScriptTag: string;
+        copied: string;
+        copyError: string;
+        tip: string;
+        beforeDeploying: string;
+        visualGeneratorDesc: string;
+        addButton: string;
+        name: string;
+        description: string;
+        address: string;
+        city: string;
+        postalCode: string;
+        country: string;
+        phone: string;
+        email: string;
+        openingHours: string;
+        latitude: string;
+        longitude: string;
+        website: string;
+        contactEmail: string;
+        socialMediaUrls: string;
+        startDate: string;
+        endDate: string;
+        location: string;
+        locationAddress: string;
+        ticketUrl: string;
+        title: string;
+        author: string;
+        publisher: string;
+        imageUrl: string;
+        publicationDate: string;
+        sku: string;
+        brand: string;
+        price: string;
+        currency: string;
+        availability: string;
+        inStock: string;
+        outOfStock: string;
+        preOrder: string;
+        madeToOrder: string;
+        questionsAnswers: string;
+        question: string;
+        answer: string;
+        steps: string;
+        stepTitle: string;
+        stepDescription: string;
+        priceRange: string;
+        modificationDate: string;
+        publisherName: string;
+        publisherLogo: string;
+        productName: string;
+        reviewCount: string;
+        ratingValue: string;
+        guideTitle: string;
+        logoUrl: string;
+        imageLabel: string;
+        urlLabel: string;
+        validateOnRichResults: string;
+    };
+    keywordResearch: {
+        loading: string;
+        title: string;
+        subtitle: string;
+        activeKeywords: string;
+        uniqueTerms: string;
+        suggestions: string;
+        searchPlaceholder: string;
+        noSuggestions: string;
+        noSuggestionsDesc: string;
+        noMatchingSuggestions: string;
+        unused: string;
+        associated: string;
+        trending: string;
+        longTail: string;
+        all: string;
+        unusedPlural: string;
+        associatedPlural: string;
+        trendingPlural: string;
+        keyword: string;
+        freq: string;
+        seeLess: string;
+        type: string;
+        score: string;
+        frequency: string;
+        usedBy: string;
+        suggestedFor: string;
+    };
+    cannibalization: {
+        loading: string;
+        title: string;
+        subtitle: string;
+        conflicts: string;
+        affectedPages: string;
+        searchPlaceholder: string;
+        noCannibalization: string;
+        noCannibalizationDesc: string;
+        noMatchingConflicts: string;
+        highRisk: string;
+        warning: string;
+        pages: string;
+    };
+    seoAnalyzer: {
+        groupTitle: string;
+        groupDescription: string;
+        groupUrlSlug: string;
+        groupHeadings: string;
+        groupContent: string;
+        groupImages: string;
+        groupLinks: string;
+        groupSocial: string;
+        groupStructuredData: string;
+        groupReadability: string;
+        groupQuality: string;
+        groupSecondaryKeywords: string;
+        groupCornerstone: string;
+        groupFreshness: string;
+        groupTechnical: string;
+        groupAccessibility: string;
+        groupEcommerce: string;
+        levelExcellent: string;
+        levelGood: string;
+        levelFair: string;
+        levelNeedsImprovement: string;
+        categoryCritical: string;
+        categoryImportant: string;
+        categoryBonus: string;
+        seoScore: string;
+        outOf100: string;
+        cornerstoneLabel: string;
+        checksPassed: string;
+        errorsCount: string;
+        warningsCount: string;
+        improvementSuggestions: string;
+        adjustTitle: string;
+        currently: string;
+        titleCharactersIdeal: string;
+        writeMetaDesc: string;
+        enrichContent: string;
+        includeKeywordInTitle: string;
+        includeKeywordInDesc: string;
+        addAltText: string;
+        addInternalLinks: string;
+        seoCannibalization: string;
+        highRisk: string;
+        duplicationHarmsRanking: string;
+        diluteRanking: string;
+        viewPages: string;
+        uniqueKeywordAdvice: string;
+        suggestedInternalLinks: string;
+        analyzingContent: string;
+        readingTime: string;
+        wordsLabel: string;
+        secondaryKeywords: string;
+        generateMeta: string;
+        metaTitle: string;
+        metaDescription: string;
+        emptyValue: string;
+    };
+    scoreHistory: {
+        loading: string;
+        loadingError: string;
+        noHistory: string;
+        noHistoryDesc: string;
+        improving: string;
+        declining: string;
+        stable: string;
+        scoreEvolution: string;
+        measures: string;
+        latestScore: string;
+    };
+    contentDecay: {
+        title: string;
+        lessThan3Months: string;
+        months3to6: string;
+        months6to12: string;
+        moreThan12Months: string;
+        description: string;
+        lastUpdate: string;
+        lastReview: string;
+        ageDays: string;
+        action: string;
+        reviewed: string;
+        markReviewed: string;
+        noData: string;
+    };
+    socialPreview: {
+        title: string;
+        facebook: string;
+        twitter: string;
+        ogImage: string;
+        cardImage: string;
+        previewTitle: string;
+        previewDescription: string;
+        characters: string;
+        pageTitlePlaceholder: string;
+        pageDescriptionPlaceholder: string;
+    };
+    serpPreview: {
+        title: string;
+        desktop: string;
+        mobile: string;
+        noMetaTitle: string;
+        noMetaDescription: string;
+        previewTitle: string;
+        previewDescription: string;
+        url: string;
+        characters: string;
+    };
+    metaTitle: {
+        label: string;
+        placeholder: string;
+        characters: string;
+        optimal: string;
+        charactersMissing: string;
+        charactersTooMany: string;
+        idealLength: string;
+    };
+    metaDescription: {
+        label: string;
+        placeholder: string;
+        characters: string;
+        optimal: string;
+        charactersMissing: string;
+        charactersTooMany: string;
+        idealLength: string;
+    };
+    metaImage: {
+        label: string;
+        imageSet: string;
+        noImage: string;
+        set: string;
+    };
+    overview: {
+        metaCompleteness: string;
+        incomplete: string;
+        partial: string;
+        almostComplete: string;
+        complete: string;
+        titleLabel: string;
+        descriptionLabel: string;
+        imageLabel: string;
+        set: string;
+        missing: string;
+    };
+}
+/**
+ * Register custom translations for a locale.
+ * Supports partial overrides — only the keys you provide will be replaced.
+ * Call this before the dashboard renders (e.g. in plugin init).
+ *
+ * @example
+ * ```ts
+ * registerDashboardTranslations('cs', {
+ *   common: { loading: 'Načítání...', save: 'Uložit', cancel: 'Zrušit', ... },
+ *   nav: { dashboard: 'Přehled', seo: 'SEO', ... },
+ *   ...
+ * })
+ * ```
+ */
+declare function registerDashboardTranslations(locale: string, custom: Partial<DashboardTranslations> | DashboardTranslations, 
+/** Base locale to use for missing keys (default: 'en') */
+fallbackLocale?: string): void;
+declare function getDashboardT(locale: DashboardLocale): DashboardTranslations;
+
+/** Arguments passed to generate functions (generateTitle, generateDescription, etc.) */
+interface GenerateFnArgs$1 {
+    doc: Record<string, unknown>;
+    locale?: string;
+    req: unknown;
+    collectionSlug?: string;
+    globalSlug?: string;
+}
+interface SeoPluginConfig {
+    /** Collections to add SEO fields to (default: ['pages', 'posts']) */
+    collections?: string[];
+    /** Globals to add SEO fields to (default: []) */
+    globals?: string[];
+    /** Whether to add the SEO dashboard view at /admin/seo (default: true) */
+    addDashboardView?: boolean;
+    /** Rule groups to disable entirely */
+    disabledRules?: RuleGroup[];
+    /** Override the weight of all checks within a rule group */
+    overrideWeights?: Partial<Record<RuleGroup, number>>;
+    /** Custom thresholds (override defaults from constants) */
+    thresholds?: SeoThresholds;
+    /** Additional local SEO slugs for the project */
+    localSeoSlugs?: string[];
+    /** Site name (used for brand duplicate check in titles) */
+    siteName?: string;
+    /** Base URL of the site (used for canonical URL validation, e.g. 'https://example.com') */
+    siteUrl?: string;
+    /** Base path for API endpoints (default: '/seo-plugin') */
+    endpointBasePath?: string;
+    /** Whether to track SEO score history (adds a collection + afterChange hook, default: true) */
+    trackScoreHistory?: boolean;
+    /** Whether to add the sitemap audit view at /admin/sitemap-audit (default: true) */
+    addSitemapAuditView?: boolean;
+    /** Collection slug for redirects (default: 'seo-redirects'). The plugin auto-creates this collection. */
+    redirectsCollection?: string;
+    /** Known dynamic routes that are not stored as document slugs (e.g. ['blog', 'réalisations', 'posts']). These won't be flagged as broken links or orphan pages. */
+    knownRoutes?: string[];
+    /** Secret header value for seo-logs POST endpoint. If set, POST requests must include X-SEO-Secret header with this value. If not set, POST requires authenticated admin user. */
+    seoLogsSecret?: string;
+    /** Locale for language-specific analysis (default: 'fr') */
+    locale?: 'fr' | 'en';
+    /** Collection slug for uploads/media (used for meta.image relationTo). Default: 'media' */
+    uploadsCollection?: string;
+    /** Auto-create meta fields (title, description, image) on target collections. Default: true */
+    autoCreateMetaFields?: boolean;
+    /** Granular feature flags — all default to true. Disable features you don't need
+     *  to reduce collections, endpoints, and admin views loaded by the plugin.
+     *  The core analyzer sidebar, validate endpoint, and meta fields are always active. */
+    features?: SeoFeatures;
+    /** Custom function to generate meta title */
+    generateTitle?: (args: GenerateFnArgs$1) => string | Promise<string>;
+    /** Custom function to generate meta description */
+    generateDescription?: (args: GenerateFnArgs$1) => string | Promise<string>;
+    /** Custom function to generate meta image (returns media ID or URL) */
+    generateImage?: (args: GenerateFnArgs$1) => string | number | Promise<string | number>;
+    /** Custom function to generate page URL */
+    generateURL?: (args: GenerateFnArgs$1) => string | Promise<string>;
+    /** Mapping from Payload locale codes to analysis locale ('fr' | 'en') */
+    localeMapping?: Record<string, 'fr' | 'en'>;
+    /** Custom dashboard translations for additional locales (e.g. 'cs', 'de', 'es').
+     *  Partial overrides are supported — missing keys fall back to English.
+     *  @example
+     *  ```ts
+     *  customTranslations: {
+     *    cs: {
+     *      common: { loading: 'Načítání...', save: 'Uložit' },
+     *      nav: { dashboard: 'Přehled', seo: 'SEO' },
+     *    }
+     *  }
+     *  ```
+     */
+    customTranslations?: Record<string, Partial<DashboardTranslations>>;
+    /** Override or reorganize the default meta fields inside the 'meta' group.
+     *  Receives the default fields (overview, title, description, image, preview) and must return a Field[].
+     *  Use this to add custom fields, remove defaults, or reorder them. */
+    fields?: (args: {
+        defaultFields: Field[];
+    }) => Field[];
+    /** If true, wraps collection/global fields in a tabbed UI with "Content" and "SEO" tabs.
+     *  Compatible with collections that already use a tabs field as their first field. */
+    tabbedUI?: boolean;
+    /** Custom TypeScript interface name for the generated meta group type (e.g. 'SharedSEO') */
+    interfaceName?: string;
+}
+declare const seoAnalyzerPlugin: (pluginConfig?: SeoPluginConfig) => Plugin;
+
+/**
+ * SEO fields added automatically to collections by the plugin.
+ * Includes: focusKeyword, focusKeywords array, isCornerstone, and the SeoAnalyzer UI.
+ */
+
+declare function seoFields(): Field[];
+
+/**
+ * Auto-created meta fields definition.
+ * Generates a "meta" group field with title, description, image, overview, and preview sub-fields.
+ * These fields mirror @payloadcms/plugin-seo's field structure for compatibility.
+ *
+ * Usage:
+ *   import { metaFields } from '@consilioweb/payload-seo-analyzer'
+ *   // ...fields: [...metaFields({ uploadsCollection: 'media', hasGenerateTitle: true })]
+ */
+
+interface MetaFieldsConfig {
+    /** Collection slug for image uploads (default: 'media') */
+    uploadsCollection?: string;
+    /** Custom TypeScript interface name for the meta group (for generated types) */
+    interfaceName?: string;
+    /** Whether a generateTitle function is configured */
+    hasGenerateTitle?: boolean;
+    /** Whether a generateDescription function is configured */
+    hasGenerateDescription?: boolean;
+    /** Whether a generateImage function is configured */
+    hasGenerateImage?: boolean;
+    /** Base API path for the generate endpoint (default: '/api/seo-plugin') */
+    basePath?: string;
+}
+/**
+ * Generate the meta field group (title, description, image, overview, preview).
+ * Compatible with @payloadcms/plugin-seo's field naming for easy migration.
+ */
+declare function metaFields(config?: MetaFieldsConfig): Field[];
+
+/**
+ * SEO Plugin — Lightweight i18n translation system.
+ * Provides French (default) and English translations for all plugin views
+ * and all rule messages/labels/tips.
+ * No external dependencies.
+ */
+type SeoLocale = 'fr' | 'en';
+
+/**
+ * Resolve the effective analysis locale from multiple sources.
+ *
+ * Cascade order:
+ *   1. Explicit pluginLocale override (from SeoPluginConfig.locale)
+ *   2. Custom mapping (pluginConfig.localeMapping) applied to reqLocale
+ *   3. Auto-detect from reqLocale (req.locale from Payload's i18n)
+ *   4. Fallback → 'fr'
+ *
+ * Mapping logic: 'fr*' → 'fr', 'en*' → 'en', anything else → fallback
+ */
+
+interface ResolveLocaleArgs {
+    /** req.locale from Payload (e.g. 'fr', 'en', 'en-US', 'fr-FR') */
+    reqLocale?: string;
+    /** Static locale from SeoPluginConfig.locale — overrides everything */
+    pluginLocale?: 'fr' | 'en';
+    /** Custom mapping from Payload locale → analysis locale */
+    customMapping?: Record<string, 'fr' | 'en'>;
+}
+/**
+ * Resolve the effective locale for SEO analysis.
+ * Returns 'fr' or 'en'.
+ */
+declare function resolveAnalysisLocale(args: ResolveLocaleArgs): SeoLocale;
+
+/**
+ * Fetch all documents from target collections + globals in a uniform format.
+ * Reused by audit, cannibalization, linkGraph, keywordResearch, etc.
+ */
+
+type DocSourceType = 'collection' | 'global';
+interface FetchedDoc {
+    doc: any;
+    sourceType: DocSourceType;
+    sourceSlug: string;
+}
+interface FetchAllDocsOptions {
+    collections: string[];
+    globals?: string[];
+    /** Limit per collection query (default: 500) */
+    limit?: number;
+    /** Depth for population (default: 1) */
+    depth?: number;
+}
+/**
+ * Fetch all documents from the specified collections and globals.
+ * Returns a unified array of { doc, sourceType, sourceSlug }.
+ */
+declare function fetchAllDocs(payload: Payload, options: FetchAllDocsOptions): Promise<FetchedDoc[]>;
+
+/**
+ * SEO Validate endpoint handler.
+ * Runs the full SEO engine (50+ checks) on a page or post.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware (e.g., express-rate-limit,
+ * Next.js middleware, or a reverse proxy like Nginx/Caddy).
+ */
+
+/**
+ * Build a SeoInput object from a Payload document (page or post).
+ * Exported for reuse in other endpoints or custom integrations.
+ */
+declare function buildSeoInputFromDoc(doc: any, collection: string, options?: {
+    isGlobal?: boolean;
+}): SeoInput;
+
+/**
+ * SEO Score History endpoint handler.
+ * Returns score history + trend for a specific document.
+ *
+ * Query params:
+ *   - documentId (required) — ID of the document
+ *   - collection (required) — collection slug ('pages', 'posts')
+ *   - limit (optional, default: 30) — max snapshots to return
+ *
+ * Response:
+ *   { history: [...], trend: 'improving' | 'declining' | 'stable', scoreDelta: number }
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware (e.g., express-rate-limit,
+ * Next.js middleware, or a reverse proxy like Nginx/Caddy).
+ */
+
+declare function createHistoryHandler(): PayloadHandler;
+
+/**
+ * Sitemap Audit endpoint handler.
+ * Performs a full internal link graph analysis to detect orphan pages,
+ * weak pages, link hubs, and broken internal links.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware (e.g., express-rate-limit,
+ * Next.js middleware, or a reverse proxy like Nginx/Caddy).
+ */
+
+declare function createSitemapAuditHandler(collections: string[], redirectsCollection?: string, knownRoutes?: string[]): PayloadHandler;
+
+/**
+ * SEO Score History collection.
+ * Stores SEO score snapshots over time for trend tracking.
+ *
+ * Usage (in plugin.ts):
+ *   config.collections = [
+ *     ...(config.collections || []),
+ *     createSeoScoreHistoryCollection(),
+ *   ]
+ */
+
+declare function createSeoScoreHistoryCollection(): CollectionConfig;
+
+/**
+ * SEO Performance collection.
+ * Stores Google Search Console performance data imported via CSV or API.
+ * Each row represents one URL+query combination for a given date.
+ *
+ * Usage (in plugin.ts):
+ *   config.collections = [
+ *     ...(config.collections || []),
+ *     createSeoPerformanceCollection(),
+ *   ]
+ */
+
+declare function createSeoPerformanceCollection(): CollectionConfig;
+
+/**
+ * SEO Score tracking hook.
+ * Automatically records a score snapshot after each document save.
+ *
+ * Usage (in plugin.ts):
+ *   collection.hooks.afterChange = [
+ *     ...(collection.hooks?.afterChange || []),
+ *     createTrackSeoScoreHook(seoConfig),
+ *   ]
+ */
+
+declare function createTrackSeoScoreHook(seoConfig?: SeoConfig): CollectionAfterChangeHook;
+
+/**
+ * Performance data endpoint.
+ * GET — Fetch performance data with aggregation by period.
+ * POST — Import performance data from CSV string or JSON entries array.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware (e.g., express-rate-limit,
+ * Next.js middleware, or a reverse proxy like Nginx/Caddy).
+ */
+
+declare function createPerformanceHandler(): PayloadHandler;
+
+/**
+ * Keyword Research endpoint.
+ * Analyzes existing content across target collections to suggest keywords.
+ * Uses TF-IDF scoring, stop word filtering, and focusKeyword gap analysis.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware (e.g., express-rate-limit,
+ * Next.js middleware, or a reverse proxy like Nginx/Caddy).
+ */
+
+declare function createKeywordResearchHandler(targetCollections: string[], globals?: string[]): PayloadHandler;
+
+/**
+ * SEO Generate endpoint handler.
+ * Calls user-provided generate functions (generateTitle, generateDescription,
+ * generateImage, generateURL) to produce meta values from a Payload document.
+ *
+ * The consuming application registers generate functions via the plugin config,
+ * and this endpoint exposes them as a POST API for the admin UI or external tools.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware (e.g., express-rate-limit,
+ * Next.js middleware, or a reverse proxy like Nginx/Caddy).
+ */
+
+interface GenerateFnArgs {
+    doc: Record<string, unknown>;
+    locale?: string;
+    req: unknown;
+    collectionSlug?: string;
+    globalSlug?: string;
+}
+interface GeneratePluginConfig {
+    generateTitle?: (args: GenerateFnArgs) => string | Promise<string>;
+    generateDescription?: (args: GenerateFnArgs) => string | Promise<string>;
+    generateImage?: (args: GenerateFnArgs) => string | number | Promise<string | number>;
+    generateURL?: (args: GenerateFnArgs) => string | Promise<string>;
+}
+/**
+ * Creates a Payload endpoint handler that invokes user-provided generate
+ * functions (title, description, image, URL) for a given document.
+ *
+ * @param pluginConfig - The plugin configuration containing generate functions
+ * @returns A PayloadHandler for the generate endpoint
+ */
+declare function createGenerateHandler(pluginConfig: GeneratePluginConfig): PayloadHandler;
+
+/**
+ * Schema.org JSON-LD Auto-Generator endpoint.
+ * Generates structured data (JSON-LD) from Payload document fields.
+ * Supports: Article, LocalBusiness, BreadcrumbList, FAQPage, Product, Organization.
+ *
+ * Auto-detects schema type from collection/content, with optional override.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware.
+ */
+
+declare function createSchemaGeneratorHandler(targetCollections?: string[]): PayloadHandler;
+
+/**
+ * Redirect Chain Detection endpoint.
+ * Reads all redirects from the seo-redirects collection, builds a graph,
+ * and detects chains (A→B→C) and loops (A→B→A).
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware.
+ */
+
+declare function createRedirectChainsHandler(redirectsCollection: string): PayloadHandler;
+
+/**
+ * Duplicate Content Detection endpoint (sitewide).
+ * Compares pages pairwise using Jaccard similarity on word trigrams.
+ * Flags pairs with >70% similarity.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware.
+ */
+
+declare function createDuplicateContentHandler(collections: string[]): PayloadHandler;
+
+/**
+ * AI Meta Rewrite endpoint.
+ * Generates optimized meta title/description using either:
+ * - Heuristic extraction (default, no API key needed)
+ * - Claude AI API (when anthropicApiKey is provided)
+ *
+ * Accepts: collection, id, field (title|description), optional anthropicApiKey.
+ *
+ * NOTE: Rate limiting is not handled by this plugin. The consuming application
+ * should implement rate limiting via its own middleware.
+ */
+
+declare function createAiRewriteHandler(targetCollections?: string[]): PayloadHandler;
+
+/**
+ * SEO Analyzer — Shared constants.
+ * Centralizes thresholds, limits, and shared lists used across rule modules.
+ * Importing from here ensures consistency and makes tuning easy.
+ *
+ * v1.4.0: Bilingual support (FR/EN) for all language-specific constants.
+ */
+declare const TITLE_LENGTH_MIN = 30;
+declare const TITLE_LENGTH_MAX = 60;
+declare const META_DESC_LENGTH_MIN = 120;
+declare const META_DESC_LENGTH_MAX = 160;
+declare const MIN_WORDS_POST = 800;
+declare const MIN_WORDS_FORM = 150;
+declare const MIN_WORDS_LEGAL = 200;
+declare const MIN_WORDS_GENERIC = 300;
+declare const MIN_WORDS_THIN = 100;
+declare const KEYWORD_DENSITY_MAX = 3;
+declare const KEYWORD_DENSITY_WARN = 2.5;
+declare const KEYWORD_DENSITY_MIN = 0.5;
+declare const MAX_RECURSION_DEPTH = 50;
+declare const SCORE_EXCELLENT = 91;
+declare const SCORE_GOOD = 71;
+declare const SCORE_OK = 41;
+declare const WARNING_MULTIPLIER = 0.5;
+/** Generic anchor texts that should be avoided in links */
+declare const GENERIC_ANCHORS: Record<'fr' | 'en', readonly string[]>;
+/** Standard utility page slugs where keyword-in-URL is not applicable */
+declare const UTILITY_SLUGS: Record<'fr' | 'en', readonly string[]>;
+/** Evergreen pages where freshness is less relevant */
+declare const EVERGREEN_SLUGS: Record<'fr' | 'en', readonly string[]>;
+/** Stop words (for slug analysis) */
+declare const STOP_WORDS: Record<'fr' | 'en', readonly string[]>;
+/** Action verbs commonly used in CTAs */
+declare const ACTION_VERBS: Record<'fr' | 'en', readonly string[]>;
+/** Compound expressions where stop words are meaningful */
+declare const STOP_WORD_COMPOUNDS_MAP: Record<'fr' | 'en', ReadonlyArray<readonly [string, string]>>;
+/** Power words that boost CTR in titles */
+declare const POWER_WORDS: Record<'fr' | 'en', readonly string[]>;
+/** Legal page slugs (used by detectPageType) */
+declare const LEGAL_SLUGS_MAP: Record<'fr' | 'en', readonly string[]>;
+declare const FLESCH_THRESHOLDS: Record<'fr' | 'en', {
+    pass: number;
+    warn: number;
+}>;
+declare const READABILITY_THRESHOLDS: Record<'fr' | 'en', {
+    longSentenceWords: number;
+    passiveMax: number;
+    transitionsMin: number;
+}>;
+/** @deprecated Use POWER_WORDS.fr */
+declare const POWER_WORDS_FR: readonly string[];
+declare function getStopWords(locale: 'fr' | 'en'): readonly string[];
+declare function getActionVerbs(locale: 'fr' | 'en'): readonly string[];
+declare function getPowerWords(locale: 'fr' | 'en'): readonly string[];
+declare function getGenericAnchors(locale: 'fr' | 'en'): readonly string[];
+declare function getLegalSlugs(locale: 'fr' | 'en'): readonly string[];
+declare function getUtilitySlugs(locale: 'fr' | 'en'): readonly string[];
+declare function getEvergreenSlugs(locale: 'fr' | 'en'): readonly string[];
+declare function getStopWordCompounds(locale: 'fr' | 'en'): ReadonlyArray<readonly [string, string]>;
+
+/**
+ * SEO Analyzer — Main orchestrator.
+ * Imports all rule modules, builds the analysis context, runs every check,
+ * and computes the final score.
+ *
+ * Public API:
+ *   analyzeSeo(data: SeoInput, config?: SeoConfig): SeoAnalysis
+ *
+ * All types and useful helpers are re-exported for convenience.
+ */
+
+declare function analyzeSeo(data: SeoInput, config?: SeoConfig): SeoAnalysis;
+
+export { ACTION_VERBS, type AnalysisContext, type CheckCategory, type CheckStatus, type DashboardLocale, type DashboardTranslations, type DocSourceType, EVERGREEN_SLUGS, FLESCH_THRESHOLDS, type FetchAllDocsOptions, type FetchedDoc, GENERIC_ANCHORS, type GenerateFnArgs$1 as GenerateFnArgs, KEYWORD_DENSITY_MAX, KEYWORD_DENSITY_MIN, KEYWORD_DENSITY_WARN, LEGAL_SLUGS_MAP, MAX_RECURSION_DEPTH, META_DESC_LENGTH_MAX, META_DESC_LENGTH_MIN, MIN_WORDS_FORM, MIN_WORDS_GENERIC, MIN_WORDS_LEGAL, MIN_WORDS_POST, MIN_WORDS_THIN, type MetaFieldsConfig, POWER_WORDS, POWER_WORDS_FR, type PageType, READABILITY_THRESHOLDS, type ResolveLocaleArgs, type RuleGroup, SCORE_EXCELLENT, SCORE_GOOD, SCORE_OK, STOP_WORDS, STOP_WORD_COMPOUNDS_MAP, type SeoAnalysis, type SeoCheck, type SeoConfig, type SeoFeatures, type SeoInput, type SeoLevel, type SeoPluginConfig, type SeoThresholds, TITLE_LENGTH_MAX, TITLE_LENGTH_MIN, UTILITY_SLUGS, WARNING_MULTIPLIER, analyzeSeo, buildSeoInputFromDoc, calculateFlesch, calculateFleschFR, checkHeadingHierarchy, checkImagesInBlocks, countKeywordOccurrences, countLongSections, countSentences, countSyllablesEN, countSyllablesFR, countWords, createAiRewriteHandler, createDuplicateContentHandler, createGenerateHandler, createHistoryHandler, createKeywordResearchHandler, createPerformanceHandler, createRedirectChainsHandler, createSchemaGeneratorHandler, createSeoPerformanceCollection, createSeoScoreHistoryCollection, createSitemapAuditHandler, createTrackSeoScoreHook, detectPageType, detectPassiveVoice, extractHeadingsFromLexical, extractImagesFromLexical, extractLinkUrlsFromLexical, extractLinksFromLexical, extractListsFromLexical, extractTextFromLexical, fetchAllDocs, getActionVerbs, getActionVerbsFR, getDashboardT, getEvergreenSlugs, getGenericAnchors, getLegalSlugs, getPowerWords, getStopWordCompounds, getStopWords, getStopWordsFR, getUtilitySlugs, hasTransitionWord, isStopWordInCompoundExpression, keywordMatchesText, metaFields, normalizeForComparison, registerDashboardTranslations, resolveAnalysisLocale, seoAnalyzerPlugin, seoFields, seoAnalyzerPlugin as seoPlugin, slugifyKeyword };