@lynxflow/seo-engine 2.8.0 → 3.2.0

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

@@ -0,0 +1,32 @@
+export interface SendlaneContactPayload {
+    listId: number | string;
+    apiToken: string;
+    email?: string;
+    phone?: string;
+    firstName?: string;
+    lastName?: string;
+    tagIds?: number[];
+    customFields?: Array<{
+        key: string;
+        value: string | number | boolean;
+    }>;
+}
+export interface SendlaneSyncResult {
+    success: boolean;
+    contactId?: number;
+    error?: string;
+}
+export interface SendlaneSyncConfig {
+    fetchFn?: typeof fetch;
+    apiBaseUrl?: string;
+}
+export declare class SendlaneSyncEngine {
+    private fetchFn;
+    private apiBaseUrl;
+    constructor(config?: SendlaneSyncConfig);
+    /**
+     * Crée ou ajoute un abonné (email/SMS) à une liste Sendlane via l'API v2.
+     * Endpoint: POST https://api.sendlane.com/v2/lists/{listId}/contacts
+     */
+    syncContact(input: SendlaneContactPayload): Promise<SendlaneSyncResult>;
+}

package/dist/seo-chart-spec.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Chart builder: turns a real series into a portable chart.
+ *
+ * Static Viz could already draw SVGs, but nothing produced a *chart request*
+ * from ingested data, so an agent (or a report) had no way to answer with a
+ * graphic — it could only print numbers. This module is the missing bridge:
+ * one call returns a JSON spec (re-renderable client-side, embeddable) plus the
+ * SVG, and a caption that states the same numbers in words for email, webhooks
+ * and screen readers.
+ */
+export type SeoChartMetric = "visitors" | "pageviews" | "conversions" | "pseoViews" | "clicks" | "impressions" | "average_position";
+export interface SeoChartPoint {
+    date: string;
+    value: number;
+}
+export interface SeoChartAnnotation {
+    date: string;
+    label: string;
+    color?: string;
+}
+export interface SeoChartRequest {
+    metric: SeoChartMetric;
+    points: SeoChartPoint[];
+    title?: string;
+    annotations?: SeoChartAnnotation[];
+    width?: number;
+    height?: number;
+    strokeColor?: string;
+}
+export interface SeoChartSpec {
+    metric: SeoChartMetric;
+    title: string;
+    /** `summed` for volumes, `averaged` for positions. */
+    measurement: "summed" | "averaged";
+    points: SeoChartPoint[];
+    pointCount: number;
+    annotations: SeoChartAnnotation[];
+    summary: {
+        /** Null for averaged metrics: a sum of positions means nothing. */
+        total: number | null;
+        average: number;
+        first: number;
+        last: number;
+        /** Signed change between the first and the last point, in percent. */
+        changePercent: number;
+        /** True when the movement goes the right way for this metric. */
+        isImprovement: boolean;
+        peak: SeoChartPoint | null;
+        trough: SeoChartPoint | null;
+    };
+    /** The same reading in words, safe to paste in an email or a webhook. */
+    caption: string;
+}
+export interface SeoChartResult {
+    spec: SeoChartSpec;
+    /** Standalone SVG with no external reference. */
+    svg: string;
+}
+/**
+ * Builds the spec and the SVG. An empty series yields an explicit "no data"
+ * chart rather than a flat line at zero pretending to be a measurement.
+ */
+export declare function buildSeoChart(request: SeoChartRequest): SeoChartResult;

package/dist/seo-diagram-generator.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 🦁 LynxSEO Engine - Deterministic SEO Diagram Generator
+ *
+ * 100% Pure Algorithmic SVG Generation - NO LLM / AI REQUIRED.
+ * Complies with the diagram-design editorial design system:
+ * - Radar / Spider Chart: Multi-axis competitive maturity scorecard
+ * - Gap / Dumbbell Chart: Direct delta analysis vs top competitor
+ * - Market Quadrant Chart: Authority vs Organic footprint positioning
+ */
+export interface CompetitorMetricScores {
+    technical: number;
+    content: number;
+    authority: number;
+    performance: number;
+    geoAi: number;
+}
+export interface CompetitorEntity {
+    name: string;
+    domain: string;
+    scores: CompetitorMetricScores;
+    isClient?: boolean;
+}
+export interface RadarChartOptions {
+    client: CompetitorEntity;
+    competitors: CompetitorEntity[];
+    title?: string;
+    subtitle?: string;
+    axes?: {
+        key: keyof CompetitorMetricScores;
+        label: string;
+    }[];
+    size?: {
+        width: number;
+        height: number;
+    };
+    theme?: "light" | "dark";
+    showLegend?: boolean;
+    maxCompetitorsRendered?: number;
+}
+export interface GapChartOptions {
+    client: CompetitorEntity;
+    competitor: CompetitorEntity;
+    title?: string;
+    theme?: "light" | "dark";
+    size?: {
+        width: number;
+        height: number;
+    };
+}
+export interface QuadrantChartOptions {
+    client: CompetitorEntity;
+    competitors: CompetitorEntity[];
+    title?: string;
+    xLabel?: string;
+    yLabel?: string;
+    theme?: "light" | "dark";
+    size?: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Generates an accessible, mathematically precise Radar (Spider) SVG chart.
+ * - Focal element: Client (accent color, 1.8px stroke, 0.18 fill, r=4 vertex dots)
+ * - Competitors: Clean editorial series lines, max 4 recommended simultaneously
+ */
+export declare function generateCompetitorRadarSvg(options: RadarChartOptions): string;
+/**
+ * Generates a Dumbbell / Gap Analysis SVG chart comparing Client vs. Best Competitor.
+ * Visualizes directly the delta (+/- points) on each SEO dimension.
+ */
+export declare function generateCompetitorGapSvg(options: GapChartOptions): string;
+/**
+ * Generates a 2-Axis Market Positioning Quadrant SVG chart:
+ * X: Domain Authority / Backlinks (0-100)
+ * Y: Organic Search Footprint / Content (0-100)
+ */
+export declare function generateCompetitorQuadrantSvg(options: QuadrantChartOptions): string;
+/**
+ * Wraps an SVG diagram into a self-contained, publication-ready HTML file.
+ */
+export declare function generateStandaloneHtml(svg: string, options: {
+    title: string;
+    subtitle?: string;
+    eyebrow?: string;
+}): string;

package/dist/seo-drift-comparator.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 📉 SEO Drift & Snapshot Regression Comparator
+ *
+ * Compares two audit snapshots of the same website over time to detect regressive issues:
+ * - Lost tags (Canonical, Meta Description, H1)
+ * - Newly broken links (404s, 500s)
+ * - Health score drops
+ * - Core Web Vitals latency degradations
+ * - Newly resolved fixes
+ */
+export interface SiteSnapshot {
+    domain: string;
+    auditDate: string;
+    healthScore: number;
+    totalPages: number;
+    brokenLinks404Count: number;
+    missingH1Count: number;
+    missingCanonicalCount: number;
+    averageResponseTimeMs: number;
+    detectedIssues: Array<{
+        code: string;
+        url: string;
+        severity: "critical" | "warning" | "info";
+        title: string;
+    }>;
+}
+export interface DriftDeltaItem {
+    type: "regression" | "improvement" | "unchanged";
+    metric: string;
+    baselineValue: string | number;
+    currentValue: string | number;
+    delta: number;
+    severity: "critical" | "warning" | "positive" | "neutral";
+    message: string;
+}
+export interface SeoDriftReport {
+    domain: string;
+    baselineDate: string;
+    currentDate: string;
+    healthScoreDelta: number;
+    overallStatus: "regressed" | "improved" | "stable";
+    newRegressionsCount: number;
+    resolvedIssuesCount: number;
+    deltas: DriftDeltaItem[];
+    urgentActionItems: string[];
+}
+export declare class SeoDriftComparator {
+    /**
+     * Compares baseline snapshot against current audit snapshot.
+     */
+    static compareSnapshots(baseline: SiteSnapshot, current: SiteSnapshot): SeoDriftReport;
+    /**
+     * Deterministic Murmur/FNV-like hash for strings without external dependencies.
+     */
+    private static hashString;
+    /**
+     * Computes a structural DOM & Schema.org fingerprint of a webpage,
+     * ignoring volatile timestamps, session nonces, and dynamic script tokens.
+     */
+    static computeHtmlFingerprint(html: string): HtmlFingerprintResult;
+    /**
+     * Compares two HTML snapshots and detects silent SEO regressions in DOM / Schema.
+     */
+    static compareHtmlDrift(baselineHtml: string, currentHtml: string): DomDriftDiff;
+}
+export interface HtmlFingerprintResult {
+    metaHash: string;
+    schemaHash: string;
+    contentStructureHash: string;
+    combinedFingerprint: string;
+    extractedCanonical?: string;
+    extractedTitle?: string;
+    extractedH1?: string;
+    schemasCount: number;
+}
+export interface DomDriftDiff {
+    hasDrift: boolean;
+    baselineFingerprint: HtmlFingerprintResult;
+    currentFingerprint: HtmlFingerprintResult;
+    changedSections: ("canonical" | "meta" | "schema" | "content_structure")[];
+    alerts: string[];
+}

package/dist/seo-metric-registry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Semantic layer: one definition per SEO metric.
+ *
+ * The same ratio used to be recomputed in a dozen places with different scales
+ * (CTR as 0..1 in the GSC/Bing reports, as a percentage in the keyword pages)
+ * and different zero-guards, so two screens could disagree on the same query
+ * set. Every metric now has a single formula, a declared unit and a declared
+ * direction, and callers ask for the metric by id instead of re-deriving it.
+ *
+ * Each definition also carries a **semantic expression** (`expression`): the
+ * same formula written in the expression language of the semantic layer
+ * (`semantic/expr.ts`). `compute` evaluates that expression, so the metric
+ * registry and the SQL compiler cannot drift apart — the formula is declared
+ * once and executed by the in-memory evaluator.
+ */
+import { type MetricExpr } from "./semantic/expr";
+export { normalizeCtrInput, safePercent, safeRatio } from "./semantic/primitives";
+export type SeoMetricUnit = "ratio" | "percent" | "position" | "score";
+export type SeoMetricDirection = "higher_is_better" | "lower_is_better" | "neutral";
+/** Inputs each metric needs. Declaring them makes the contract explicit. */
+export interface SeoMetricInputMap {
+    ctr: {
+        clicks: number;
+        impressions: number;
+    };
+    average_position: {
+        positions: {
+            position: number;
+            impressions: number;
+        }[];
+    };
+    conversion_rate: {
+        conversions: number;
+        visitors: number;
+    };
+    bounce_rate: {
+        bounces: number;
+        sessions: number;
+    };
+    pseo_traffic_share: {
+        pseoPageviews: number;
+        pageviews: number;
+    };
+    ai_crawl_share: {
+        aiCrawls: number;
+        totalCrawls: number;
+    };
+    indexation_rate: {
+        indexedPages: number;
+        discoveredPages: number;
+    };
+}
+export type SeoMetricId = keyof SeoMetricInputMap;
+export interface SeoMetricDefinition<K extends SeoMetricId = SeoMetricId> {
+    id: K;
+    label: string;
+    description: string;
+    unit: SeoMetricUnit;
+    /** Decimals kept in the returned number. */
+    precision: number;
+    direction: SeoMetricDirection;
+    /** Expected input keys, with the unit each one is expressed in. */
+    inputs: {
+        key: string;
+        description: string;
+    }[];
+    /**
+     * The formula, written in the expression language of the semantic layer.
+     *
+     * Column names are the **keys of the input object**. When an input value is
+     * an array (as for `average_position`), the array is expanded: each element
+     * becomes a row whose columns are the element's own keys, and the metric is
+     * computed over that group.
+     */
+    expression: MetricExpr;
+    compute: (input: SeoMetricInputMap[K]) => number;
+}
+export declare function getSeoMetricDefinition<K extends SeoMetricId>(id: K): SeoMetricDefinition<K>;
+/** Single entry point: metric id + declared inputs, nothing else. */
+export declare function computeSeoMetric<K extends SeoMetricId>(id: K, input: SeoMetricInputMap[K]): number;
+export declare function listSeoMetrics(): SeoMetricDefinition[];
+/**
+ * Human-readable value that respects the declared unit, so a ratio is never
+ * printed as if it were a percentage.
+ */
+export declare function formatSeoMetric(id: SeoMetricId, value: number): string;

package/dist/seo-opportunities-decay.d.ts

@@ -1,5 +1,5 @@
 /**
- * 🎯 Advanced SEO Opportunities & Content Decay Detector (Inspiration: crawlseo/seo-opportunities.ts)
+ * 🎯 Advanced SEO Opportunities & Content Decay Detector
  *
  * Implements mathematical models to detect:
  * 1. Striking Distance Keywords (Positions 4 to 20 with high impressions)

package/dist/seo-opportunity-prioritizer.d.ts

@@ -1,9 +1,10 @@
 /**
- * 📈 Multi-Factor SEO Opportunity Prioritizer
- * Ported & optimized from Python opportunity_scorer.py.
- * Computes an 8-factor Opportunity Score (0-100) using real CTR curves & GSC ranking proximity.
+ * 📈 Multi-Factor SEO Opportunity Prioritizer & Traffic Predictor
+ * Computes an 8-factor Opportunity Score (0-100) using real CTR curves,
+ * GSC ranking proximity, intent weights, cluster equity, and search trends.
  */
-export type OpportunityArchetype = "quick_win" | "top_3_push" | "high_volume_gap" | "underperformer" | "declining";
+export type OpportunityArchetype = "quick_win" | "top_3_push" | "high_volume_gap" | "underperformer" | "declining" | "new_content";
+export type OpportunityPriority = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "SKIP";
 export interface OpportunityInput {
     keyword: string;
     currentPosition?: number;
@@ -13,25 +14,62 @@ export interface OpportunityInput {
     searchVolume?: number;
     difficulty?: number;
     intent?: "informational" | "commercial_investigation" | "transactional" | "navigational";
+    serpFeatures?: string[];
+    clusterValue?: number;
+    trendDirection?: "rising" | "stable" | "declining";
+    trendPercent?: number;
+    opportunityType?: "quick_win" | "improvement" | "medium_term" | "new_content" | "declining" | "underperformer";
+}
+export interface FactorBreakdown {
+    volumeScore: number;
+    positionScore: number;
+    intentScore: number;
+    competitionScore: number;
+    clusterScore: number;
+    ctrScore: number;
+    freshnessScore: number;
+    trendScore: number;
+}
+export interface TrafficPotentialProjection {
+    currentClicks: number;
+    currentPosition: number;
+    currentCtrPercent: number;
+    currentExpectedCtrPercent: number;
+    targetPosition: number;
+    targetExpectedCtrPercent: number;
+    potentialClicks: number;
+    additionalClicks: number;
+    percentIncrease: number;
 }
 export interface OpportunityScoreResult {
+    keyword: string;
     opportunityScore: number;
-    archetype: OpportunityArchetype;
-    estimatedClickGain: number;
-    factors: {
-        volumeScore: number;
-        positionScore: number;
-        intentScore: number;
-        competitionScore: number;
-        ctrImprovementScore: number;
-    };
+    priority: OpportunityPriority;
     priorityLevel: "critical" | "high" | "medium" | "low";
+    archetype: OpportunityArchetype;
+    primaryFactor: string;
+    scoreExplanation: string;
+    factors: FactorBreakdown;
+    trafficPotential: TrafficPotentialProjection;
     actionPlan: string;
+    estimatedClickGain: number;
 }
 export declare class SeoOpportunityPrioritizer {
-    private static readonly BENCHMARK_CTR;
+    static readonly EXPECTED_CTR: Record<number, number>;
     /**
-     * Calculates comprehensive opportunity score for content prioritization.
+     * Calculates comprehensive 8-factor opportunity score for content prioritization.
      */
     static evaluate(input: OpportunityInput): OpportunityScoreResult;
+    /**
+     * Project traffic increase from ranking improvement.
+     */
+    static calculatePotentialTraffic(currentPosition: number, targetPosition: number, impressions: number, currentClicks: number): TrafficPotentialProjection;
+    private static calculateVolumeScore;
+    private static calculatePositionScore;
+    private static calculateIntentScore;
+    private static calculateCompetitionScore;
+    private static calculateCtrScore;
+    private static calculateFreshnessScore;
+    private static calculateTrendScore;
+    private static explainScore;
 }

package/dist/seo-quadrant-analyzer.d.ts

@@ -0,0 +1,133 @@
+/**
+ * ⚡ SEO Opportunity Quadrant & GSC Intelligence Analyzer
+ *
+ * Provides source-grounded classification of Search Console performance:
+ * 1. 4-Quadrant Opportunity Matrix:
+ *    - Stars (Pos 1-3): High authority, top traffic drivers.
+ *    - Quick Wins (Pos 4-10): Bottom of Page 1, high impressions, sub-optimal CTR (< expected).
+ *    - Striking Distance (Pos 11-20): Page 2, prime candidates for internal linking & content depth.
+ *    - Optimization Needed (Pos 21+): Requires structural changes or topical authority building.
+ *
+ * 2. Branded vs Non-Branded Analysis:
+ *    - Splits traffic and calculates true organic non-brand growth vs brand equity.
+ *
+ * 3. SERP Position Bucketing:
+ *    - Distribution into 1-3, 4-10, 11-20, and 21+.
+ *
+ * 4. AI Engine Referrals Detection:
+ *    - Identifies search traffic originating from generative AI engines (ChatGPT, Perplexity, Claude, Copilot, Gemini).
+ */
+export interface SeoQueryMetric {
+    query: string;
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+    page?: string;
+}
+export type SeoOpportunityQuadrantType = "stars" | "quick_wins" | "striking_distance" | "optimization_needed";
+export interface SeoOpportunityQuadrantItem extends SeoQueryMetric {
+    quadrant: SeoOpportunityQuadrantType;
+    normalizedCtr: number;
+    expectedBenchmarkCtr: number;
+    potentialClicksGain: number;
+    recommendation: string;
+}
+export interface SeoOpportunityQuadrantSummary {
+    stars: {
+        count: number;
+        clicks: number;
+        impressions: number;
+        items: SeoOpportunityQuadrantItem[];
+    };
+    quickWins: {
+        count: number;
+        clicks: number;
+        impressions: number;
+        estimatedClicksUpside: number;
+        items: SeoOpportunityQuadrantItem[];
+    };
+    strikingDistance: {
+        count: number;
+        clicks: number;
+        impressions: number;
+        estimatedClicksUpside: number;
+        items: SeoOpportunityQuadrantItem[];
+    };
+    optimizationNeeded: {
+        count: number;
+        clicks: number;
+        impressions: number;
+        items: SeoOpportunityQuadrantItem[];
+    };
+    totals: {
+        totalQueries: number;
+        totalClicks: number;
+        totalImpressions: number;
+        overallPotentialUpside: number;
+    };
+}
+export interface BrandedVsNonBrandedBreakdown {
+    branded: {
+        count: number;
+        clicks: number;
+        impressions: number;
+        avgCtr: number;
+        avgPosition: number;
+        queries: SeoQueryMetric[];
+    };
+    nonBranded: {
+        count: number;
+        clicks: number;
+        impressions: number;
+        avgCtr: number;
+        avgPosition: number;
+        queries: SeoQueryMetric[];
+    };
+    brandedClicksSharePercent: number;
+    brandedImpressionsSharePercent: number;
+    brandTermsUsed: string[];
+}
+export interface SerpPositionBucket {
+    bucket: "1-3" | "4-10" | "11-20" | "21+";
+    label: string;
+    count: number;
+    clicks: number;
+    impressions: number;
+    percentageShare: number;
+}
+export interface AiReferralSource {
+    source: string;
+    name: string;
+    visits: number;
+    category: "ai_search" | "ai_assistant";
+}
+export declare class SeoQuadrantAnalyzer {
+    /**
+     * Normalize CTR to a 0..1 decimal scale.
+     */
+    static normalizeCtr(ctr: number): number;
+    /**
+     * Expected benchmark CTR for a given Google SERP ranking position.
+     */
+    static getBenchmarkCtr(position: number): number;
+    /**
+     * Categorizes a collection of GSC query rows into the 4 Opportunity Quadrants.
+     */
+    static analyzeQuadrants(rows: SeoQueryMetric[]): SeoOpportunityQuadrantSummary;
+    /**
+     * Separates queries into Branded and Non-Branded categories.
+     */
+    static analyzeBrandedVsNonBranded(rows: SeoQueryMetric[], brandTerms: string[], domain?: string | null): BrandedVsNonBrandedBreakdown;
+    /**
+     * Distributes queries into SERP position buckets (1-3, 4-10, 11-20, 21+).
+     */
+    static analyzePositionBuckets(rows: SeoQueryMetric[]): SerpPositionBucket[];
+    /**
+     * Identifies referrals coming from generative AI search engines and assistants.
+     */
+    static detectAiSearchReferrals(referrers: {
+        source: string;
+        visits: number;
+    }[]): AiReferralSource[];
+}

package/dist/seo-query-builder.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Lynx SEO Explorer - Visual Query Builder Engine
+ * Permet l'interrogation visuelle, le filtrage multi-critères, le regroupement (group by / breakouts)
+ * et l'agrégation de métriques SEO sans écrire de requêtes SQL brutes.
+ */
+export { FILTER_OPERATORS, } from "./semantic/filters/types";
+export type { FilterFieldType, FilterOperator, QueryFilter, QueryRow, QueryValue, } from "./semantic/filters/types";
+export { evaluateFilter } from "./semantic/filters/evaluate";
+import type { FilterFieldType, QueryFilter, QueryRow } from "./semantic/filters/types";
+export type FieldType = FilterFieldType;
+export interface DatasetField {
+    id: string;
+    name: string;
+    type: FieldType;
+    aggregatable?: boolean;
+}
+export interface DatasetDefinition {
+    id: string;
+    name: string;
+    description: string;
+    fields: DatasetField[];
+}
+export declare const AGGREGATE_FUNCTIONS: readonly ["count", "sum", "avg", "min", "max"];
+export type AggregateFunction = (typeof AGGREGATE_FUNCTIONS)[number];
+export interface QueryAggregation {
+    field: string;
+    function: AggregateFunction;
+    as?: string;
+}
+export interface QuerySort {
+    field: string;
+    direction: "asc" | "desc";
+}
+export interface SeoQuery {
+    dataset: string;
+    filters?: QueryFilter[];
+    aggregations?: QueryAggregation[];
+    groupBy?: string[];
+    sort?: QuerySort;
+    limit?: number;
+}
+export interface SeoQueryResult {
+    columns: Array<{
+        key: string;
+        name: string;
+        type: FieldType;
+    }>;
+    rows: QueryRow[];
+    totalCount: number;
+    aggregationsSummary?: Record<string, number>;
+}
+export type QueryExecutionResult = SeoQueryResult;
+export type SeoDatasetDefinition = DatasetDefinition;
+export declare const SEO_DATASETS: Record<string, DatasetDefinition>;
+/**
+ * Moteur d'exécution de requêtes SEO visuelles (In-Memory / Dataset Processor)
+ */
+export declare function executeSeoQuery(query: SeoQuery, datasetRows: readonly QueryRow[]): SeoQueryResult;
+export declare const SeoQueryBuilder: {
+    executeQuery(rows: readonly QueryRow[], query: Partial<SeoQuery>): {
+        rowCount: number;
+        rows: QueryRow[];
+        columns: Array<{
+            key: string;
+            name: string;
+            type: FieldType;
+        }>;
+    };
+    getMockDataset(name: string): QueryRow[];
+};

package/dist/seo-spelling-grammar-auditor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 🦁 LynxSEO Spelling & Typo Auditor
+ *
+ *
+ * Lightweight, high-performance SEO typography and grammar auditor detecting
+ * high-impact typos, repeated words, and spelling mistakes across titles, H1s,
+ * and meta descriptions.
+ */
+export interface SeoTextAuditInput {
+    url: string;
+    title?: string | null;
+    metaDescription?: string | null;
+    h1?: string | null;
+}
+export type TypoIssueType = "repeated_word" | "misspelling" | "punctuation_error" | "dangling_connector" | "excessive_caps" | "unclosed_bracket";
+export interface TypoIssue {
+    url: string;
+    field: "title" | "metaDescription" | "h1";
+    type: TypoIssueType;
+    severity: "critical" | "warning";
+    message: string;
+    snippet: string;
+    suggestion: string;
+}
+export interface SeoSpellingGrammarReport {
+    totalPagesAudited: number;
+    pagesWithIssuesCount: number;
+    totalIssuesCount: number;
+    grammarHealthScore: number;
+    issues: TypoIssue[];
+    recommendations: string[];
+}
+export declare class SeoSpellingGrammarAuditor {
+    /**
+     * Audits a text string for repeated words, punctuation errors, dangling connectors, and typos
+     */
+    private static auditString;
+    /**
+     * Run crawl-wide audit on all page titles, descriptions, and H1 tags
+     */
+    static audit(pages: SeoTextAuditInput[]): SeoSpellingGrammarReport;
+}