@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/geo-score-calculator.d.ts

@@ -0,0 +1,214 @@
+/**
+ * 📊 GEO 0-100 Scoring Engine (Rubric v1 & Rubric v2)
+ *
+ * Implements both versioned GEO Scoring Rubrics:
+ * - Rubric v1 (Legacy 8 categories — max 100 pts):
+ *   robots (18), llms (18), schema (16), meta (14), content (12), brand_entity (10), signals (6), ai_discovery (6)
+ *
+ * - Rubric v2 (Default 9 categories — max 100 pts, aligned with Google AI Overviews & Search Central 2026):
+ *   google_ai (20), robots (14), schema (14), content (14), brand_entity (12), meta (11), llms (6), signals (6), ai_discovery (3)
+ */
+export type ScoreCategory = "google_ai" | "robots" | "llms" | "schema" | "meta" | "content" | "brand_entity" | "signals" | "ai_discovery";
+export type NonScoredCategory = "blockers" | "other";
+export type RecommendationCategory = ScoreCategory | NonScoredCategory;
+export declare const RECOMMENDATION_BLOCKERS_CATEGORY: NonScoredCategory;
+export declare const RECOMMENDATION_OTHER_CATEGORY: NonScoredCategory;
+export interface CategorizedRecommendation {
+    category: RecommendationCategory;
+    text: string;
+}
+export interface GeoCategoryScore {
+    category: ScoreCategory;
+    name: string;
+    score: number;
+    maxScore: number;
+    percentage: number;
+    details: string[];
+}
+export interface GeoAuditInput {
+    url: string;
+    domain: string;
+    rubricVersion?: 1 | 2;
+    html?: string;
+    headers?: Record<string, string>;
+    robotsTxt?: string;
+    error?: string | null;
+    httpStatus?: number | null;
+    googleAi?: {
+        score?: number;
+        checksPassed?: number;
+        details?: string[];
+    };
+    robots: {
+        found: boolean;
+        citationBotsAllowedRatio: number;
+        trainingBotsBlocked?: boolean;
+        blockedBots: string[];
+        crawlDelay?: number;
+    };
+    llms: {
+        found: boolean;
+        hasH1: boolean;
+        hasSummary: boolean;
+        hasSections: boolean;
+        hasFullCompanion: boolean;
+        wordCount?: number;
+        linksCount?: number;
+        sectionsCount?: number;
+        validationWarnings?: string[];
+    };
+    schema: {
+        found: boolean;
+        types: string[];
+        hasOrganizationOrWebsite: boolean;
+        hasSameAs: boolean;
+        attributeCount: number;
+        visibleMatch?: boolean;
+        jsonParseErrors?: number;
+        hasFaq?: boolean;
+        schemaMissingFields?: Record<string, string[]>;
+        hasProduct?: boolean;
+        productMissingFields?: string[];
+    };
+    meta: {
+        title: string | null;
+        description: string | null;
+        canonical: string | null;
+        hasOgTags: boolean;
+        hasOgTitle?: boolean;
+        hasOgDescription?: boolean;
+        hasNoai?: boolean;
+        noaiValue?: string;
+        xRobotsTag?: string;
+        xRobotsNoindex?: boolean;
+    };
+    content: {
+        hasH1: boolean;
+        wordCount: number;
+        hasHeadingHierarchy: boolean;
+        citabilityScore: number;
+        imageAltRatio?: number;
+        hasListsOrTables?: boolean;
+        hasFrontLoading?: boolean;
+        hasNumbers?: boolean;
+        hasLinks?: boolean;
+    };
+    brand: {
+        brandNameFound: boolean;
+        hasSameAsAuthority: boolean;
+        hasAboutOrContact: boolean;
+        hasGeoIdentity?: boolean;
+        hasTopicAuthority?: boolean;
+        brandNameConsistent?: boolean;
+        kgPillarCount?: number;
+        hasAboutLink?: boolean;
+        hasContactInfo?: boolean;
+    };
+    signals: {
+        hasHtmlLang: boolean;
+        hasRssFeed: boolean;
+        hasFreshnessDate: boolean;
+    };
+    aiDiscovery: {
+        hasWellKnownAiTxt: boolean;
+        hasAiSummaryJson: boolean;
+        hasAiFaqJson: boolean;
+        hasAiServiceJson?: boolean;
+        hasMarkdownNegotiation?: boolean;
+    };
+    penalties?: {
+        promptInjectionFound?: boolean;
+        llmInstructionFound?: boolean;
+        htmlCommentInjectionFound?: boolean;
+        hiddenTextFound?: boolean;
+        ugcSurfaceFound?: boolean;
+        ugcInjectionRisk?: boolean;
+        ugcSurfaceSamples?: string[];
+        keywordStuffingFound?: boolean;
+        thinContent?: boolean;
+        ctaDensityHigh?: boolean;
+        ctaCount?: number;
+        stuffedWord?: string;
+        stuffedDensity?: number;
+        boilerplateHigh?: boolean;
+        boilerplateRatio?: number;
+    };
+    cdnWaf?: {
+        checked: boolean;
+        anyBlocked: boolean;
+        cdnName?: string;
+        blockedBots: string[];
+    };
+    jsRendering?: {
+        checked: boolean;
+        jsDependent: boolean;
+        rawWordCount?: number;
+    };
+    webmcp?: {
+        checked: boolean;
+        readinessLevel?: "none" | "partial" | "full";
+        hasLabeledForms?: boolean;
+        hasToolAttributes?: boolean;
+        hasRegisterTool?: boolean;
+    };
+    multimodal?: {
+        checked: boolean;
+        totalImages?: number;
+        imagesWithAlt?: number;
+        altCoverage?: number;
+        hasVideo?: boolean;
+        hasVideoSchema?: boolean;
+        hasVideoCaptions?: boolean;
+        hasTranscript?: boolean;
+        hasAudio?: boolean;
+        hasAudioSchema?: boolean;
+    };
+}
+export interface GeoScoreResult {
+    url?: string;
+    rubricVersion: 1 | 2;
+    overallScore: number;
+    band: "CRITIQUE" | "FONDATION" | "BON" | "EXCELLENT" | "critical" | "foundation" | "good" | "excellent";
+    bandColor: "red" | "yellow" | "blue" | "green";
+    categories: Record<string, GeoCategoryScore>;
+    scoreBreakdown?: Record<string, number>;
+    score_breakdown?: Record<string, number>;
+    scoreMax?: Record<string, number>;
+    score_max?: Record<string, number>;
+    penaltiesDeducted: number;
+    prioritizedActionPlan: string[];
+    recommendations: string[];
+    recommendations_by_category: Record<string, string[]>;
+    timestamp: string;
+    error?: string | null;
+    httpStatus?: number | null;
+    http_status?: number | null;
+    pageSize?: number;
+    page_size?: number;
+}
+export declare const CATEGORY_MAX_V1: Record<ScoreCategory, number>;
+export declare const CATEGORY_MAX_V2: Record<ScoreCategory, number>;
+export declare class GeoScoreCalculator {
+    static calculate(input: GeoAuditInput): GeoScoreResult;
+    /**
+     * Builds the error result conforming to the JSON Contract v1:
+     * Single recommendation filed under "other", overallScore = 0.
+     */
+    static createErrorResult(url: string, error: string, httpStatus?: number | null, rubricVersion?: 1 | 2): GeoScoreResult;
+    /**
+     * Group (category, text) pairs into { [category]: [text, ...] }.
+     * Preserves insertion order. Categories with 0 recommendations are omitted.
+     */
+    static groupRecommendationsByCategory(items: CategorizedRecommendation[]): Record<string, string[]>;
+    /**
+     * Build flat list of recommendation strings (backward compatible API).
+     */
+    static buildRecommendations(input: GeoAuditInput, scoreBreakdown?: Record<string, number>): string[];
+    /**
+     * Single source of truth for prioritized recommendations according to GEO v4.19.2:
+     * Returns list of { category, text } pairs.
+     */
+    static buildCategorizedRecommendations(input: GeoAuditInput, scoreBreakdown?: Record<string, number>): CategorizedRecommendation[];
+    private static calculateV2;
+    private static calculateV1;
+}

package/dist/geo-semantic-coherence.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Cross-Page Semantic Coherence Engine
+ * Detects discrepancies, definition conflicts, duplicate titles, and language divergence
+ * across the site that cause AI answer models to fragment their citations or hallucinate.
+ */
+export interface PageSemanticExtract {
+    url: string;
+    title: string;
+    language?: string;
+    definitions: {
+        term: string;
+        definition: string;
+    }[];
+}
+export interface CoherenceIssue {
+    type: "conflicting_definition" | "duplicate_title" | "language_divergence";
+    severity: "high" | "medium" | "low";
+    description: string;
+    urls: string[];
+    terms?: string[];
+    suggestion: string;
+}
+export interface SemanticCoherenceResult {
+    checked: boolean;
+    pagesAnalyzed: number;
+    coherenceScore: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    issues: CoherenceIssue[];
+    issuesCountByType: Record<"conflicting_definition" | "duplicate_title" | "language_divergence", number>;
+    languageConsistencyRatio: number;
+    summary: string;
+    recommendations: string[];
+}
+export declare class GeoSemanticCoherenceAuditor {
+    static analyze(extracts: PageSemanticExtract[]): SemanticCoherenceResult;
+}

package/dist/geo-semantic-drift-detector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 📉 GeoSemanticDriftDetector — Semantic & Algorithmic Regression Detector
+ *
+ * Detects semantic drift between target queries and generated answers.
+ *
+ * Detects score drops and architectural regressions between two audit snapshots:
+ * 1. Score drops (>= 15 points: CRITICAL, >= 5 points: WARNING)
+ * 2. Loss of crawlability (robots.txt blocking citation bots)
+ * 3. Schema richness regression (structured data removed)
+ * 4. Pillar category degradation
+ */
+export interface AuditSnapshotRecord {
+    timestamp: string;
+    url: string;
+    overallScore: number;
+    categoryBreakdown: Record<string, number>;
+    crawlersAllowedCount: number;
+    schemaTypesCount: number;
+}
+export interface SemanticDriftResult {
+    hasDrift: boolean;
+    severity: "none" | "info" | "warning" | "critical";
+    scoreDelta: number;
+    categoryDeltas: Record<string, number>;
+    crawlabilityLost: boolean;
+    schemaDegraded: boolean;
+    criticalIssues: string[];
+    remediationSuggestions: string[];
+}
+export declare class GeoSemanticDriftDetector {
+    private static readonly CRITICAL_DROP;
+    private static readonly WARNING_DROP;
+    static detectDrift(before: AuditSnapshotRecord, after: AuditSnapshotRecord): SemanticDriftResult;
+}

package/dist/geo-site-scaffolding.d.ts

@@ -0,0 +1,71 @@
+/**
+ * LynxSEO AI Discovery Scaffolding Engine
+ * Generates llms.txt, llms-full.txt, .well-known/ai.txt, /ai/summary.json, /ai/faq.json, /ai/service.json
+ * Also exports plug-and-play Vite and Astro integrations for zero-config build-time generation.
+ */
+export interface PageMetadata {
+    title: string;
+    pathname: string;
+    description?: string;
+    section?: string;
+}
+export interface FaqItem {
+    question: string;
+    answer: string;
+}
+export interface ServiceDescriptor {
+    name: string;
+    description: string;
+    category?: string;
+    provider?: string;
+    url?: string;
+}
+export interface ScaffoldingConfig {
+    siteName: string;
+    siteUrl: string;
+    description?: string;
+    pages?: PageMetadata[];
+    faqs?: FaqItem[];
+    service?: ServiceDescriptor;
+    overwrite?: boolean;
+}
+export interface ScaffoldingGeneratedFiles {
+    llmsTxt: string;
+    aiTxt: string;
+    summaryJson: string;
+    faqJson?: string;
+    serviceJson?: string;
+}
+export declare class GeoSiteScaffolding {
+    static buildLlmsTxt(config: ScaffoldingConfig): string;
+    static buildAiTxt(config: ScaffoldingConfig): string;
+    static buildSummaryJson(config: ScaffoldingConfig): string;
+    static buildFaqJson(faqs: FaqItem[]): string;
+    static buildServiceJson(service: ServiceDescriptor): string;
+    /**
+     * Scaffolds and writes all AI discovery files to a directory on disk.
+     */
+    static scaffoldToDirectory(outDir: string, config: ScaffoldingConfig): ScaffoldingGeneratedFiles;
+}
+/**
+ * Plug-and-play Astro integration for build-time GEO AI discovery generation.
+ */
+export declare function lynxGeoReadyAstroIntegration(options: ScaffoldingConfig): {
+    name: string;
+    hooks: {
+        "astro:build:done": ({ dir, pages }: {
+            dir: URL;
+            pages: {
+                pathname: string;
+            }[];
+        }) => Promise<void>;
+    };
+};
+/**
+ * Plug-and-play Vite plugin for build-time GEO AI discovery generation.
+ */
+export declare function lynxGeoReadyVitePlugin(options: ScaffoldingConfig): {
+    name: string;
+    apply: "build";
+    closeBundle: () => Promise<void>;
+};

package/dist/geo-topical-authority-cluster.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 👑 GeoTopicalAuthorityClusterEngine — Multi-Page Entity & Cluster Depth Analyzer
+ *
+ * Topical authority clustering with content-gap grouping.
+ *
+ * Princeton KDD 2024 & Modern AI Search standard:
+ * "A brand with 5 interlinked pages covering a topic from different angles
+ * is 3.4x more likely to be cited by LLMs than a brand with 1 isolated strong page."
+ *
+ * Measures:
+ * 1. Topic Cluster Coverage (strength and depth of topic subpages)
+ * 2. Hub-and-Spoke Interlinking (internal links connecting pillar to cluster pages)
+ * 3. Pillar Page Presence & Canonical Hierarchy
+ * 4. Distinct Thematic Breadth
+ */
+export interface ClusterCrawlNode {
+    url: string;
+    title: string;
+    primaryKeywords: string[];
+    internalOutboundHrefs: string[];
+    isPillarCandidate?: boolean;
+}
+export interface TopicClusterItem {
+    clusterTopic: string;
+    pageCount: number;
+    pages: string[];
+    pillarUrl?: string;
+    interlinkingRatio: number;
+    authorityStrength: "low" | "medium" | "high" | "authoritative";
+}
+export interface TopicalAuthorityReport {
+    checked: boolean;
+    overallAuthorityScore: number;
+    dominantClusterTopic: string;
+    clusterCount: number;
+    clusters: TopicClusterItem[];
+    hasDedicatedPillarPage: boolean;
+    averageInterlinkingRatio: number;
+    verdict: "surface_coverage" | "emerging_authority" | "topical_dominance";
+    actionableInsights: string[];
+}
+export declare class GeoTopicalAuthorityClusterEngine {
+    static analyze(nodes: ClusterCrawlNode[]): TopicalAuthorityReport;
+}

package/dist/geo-topical-authority.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Site-Level Topical Authority & Cluster Depth Engine
+ * Evaluates how effectively a site establishes topical authority for AI search engines:
+ * - "5 interlinked pages beat 1 strong page"
+ * - Topic Cluster grouping by key entity terms
+ * - Cluster Depth: count of specialized sub-pages per topic
+ * - Internal Interlinking Density (Hub-and-spoke graph connectivity)
+ * - Pillar Page Detection (central conceptual guide linking to spokes)
+ * - Topical Breadth & Overall Topical Authority Score (0-100)
+ */
+export interface TopicCluster {
+    term: string;
+    pagesCount: number;
+    urls: string[];
+    interlinkRatio: number;
+    hasPillarPage: boolean;
+    pillarUrl?: string;
+    depthGrade: "shallow" | "moderate" | "authoritative";
+}
+export interface PageDocumentInput {
+    url: string;
+    title: string;
+    headings?: string[];
+    bodyText?: string;
+    internalLinks?: string[];
+}
+export interface TopicalAuthorityResult {
+    checked: boolean;
+    totalPagesAnalyzed: number;
+    authorityScore: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    clustersCount: number;
+    clusters: TopicCluster[];
+    strongestCluster?: TopicCluster;
+    interlinkingCoverage: number;
+    pillarCoveragePct: number;
+    summary: string;
+    recommendations: string[];
+}
+export declare class GeoTopicalAuthorityEngine {
+    static analyze(pages: PageDocumentInput[], brandName?: string): TopicalAuthorityResult;
+}

package/dist/geo-trust-stack.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Trust Stack Score : 5-Layer Trust Signal Aggregation Engine
+ * Evaluates holistic credibility signals required by AI answer engines (Perplexity, GPT Search, Gemini)
+ *
+ * Layers:
+ * 1. Technical Trust : HTTPS, HSTS, CSP, X-Frame-Options
+ * 2. Identity Trust : Brand consistency, About link, Contact info, Organization & Person schema
+ * 3. Social Trust : sameAs profiles, customer reviews, testimonials
+ * 4. Academic Trust : Authoritative citations (.gov, .edu, INSEE, WHO, ISO), statistics, research references
+ * 5. Consistency Trust : dateModified freshness, publication dates, uniform entity definitions
+ */
+export interface TrustLayerScore {
+    name: "technical" | "identity" | "social" | "academic" | "consistency";
+    label: string;
+    score: number;
+    maxScore: 5;
+    signalsFound: string[];
+    signalsMissing: string[];
+}
+export interface TrustStackResult {
+    totalScore: number;
+    percentage: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    layers: Record<"technical" | "identity" | "social" | "academic" | "consistency", TrustLayerScore>;
+    summary: string;
+    recommendations: string[];
+}
+export interface TrustStackInput {
+    url?: string;
+    html?: string;
+    headers?: Record<string, string>;
+    schemas?: any[];
+    brandName?: string;
+}
+export declare class GeoTrustStack {
+    /**
+     * Evaluate the complete 5-layer trust stack
+     */
+    static evaluate(input: TrustStackInput): TrustStackResult;
+    private static scoreTechnical;
+    private static scoreIdentity;
+    private static scoreSocial;
+    private static scoreAcademic;
+    private static scoreConsistency;
+}

package/dist/geo-webmcp-auditor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * WebMCP & Agent Readiness Auditor
+ * Evaluates whether a webpage exposes interactive tools, schema potentialActions,
+ * machine-readable form fields, and WebMCP declarations for autonomous AI agents.
+ */
+export interface PotentialActionSummary {
+    type: string;
+    target?: string;
+    queryInput?: string;
+}
+export interface WebMcpToolSummary {
+    name: string;
+    description: string;
+    parametersCount: number;
+}
+export interface WebMcpAuditResult {
+    checked: boolean;
+    readinessScore: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    agentInteractivityLevel: "agent-native" | "form-assisted" | "read-only";
+    hasPotentialAction: boolean;
+    potentialActions: PotentialActionSummary[];
+    hasWebMcpTools: boolean;
+    toolsDetected: WebMcpToolSummary[];
+    hasApiManifest: boolean;
+    formsAnalyzedCount: number;
+    accessibleFormsCount: number;
+    recommendations: string[];
+    summary: string;
+}
+export declare class GeoWebMcpAuditor {
+    static analyze(html: string, jsonLdSchemas?: any[]): WebMcpAuditResult;
+}

package/dist/geoip.d.ts

@@ -0,0 +1,61 @@
+/**
+ * GeoIP / Géographie des visiteurs — Matomo Plugin "GeoIp2 / UserCountry"
+ *
+ * Résolution du pays, ville, région et fournisseur d'accès depuis une adresse IP.
+ * Intègre une base de données IP (GeoLite2 ou similaire) pour la géolocalisation.
+ */
+export interface GeoLocation {
+    ip: string;
+    countryCode?: string;
+    countryName?: string;
+    regionCode?: string;
+    regionName?: string;
+    city?: string;
+    latitude?: number;
+    longitude?: number;
+    timezone?: string;
+    isp?: string;
+    organization?: string;
+    isEU?: boolean;
+    isPrivate?: boolean;
+}
+/**
+ * Résultat de lookup GeoIP.
+ */
+export interface GeoLookupResult {
+    ip: string;
+    found: boolean;
+    location?: GeoLocation;
+    error?: string;
+}
+/**
+ * Interface pour un fournisseur de base de données GeoIP.
+ * Permet d'injecter GeoLite2, MaxMind, ou un service externe.
+ */
+export interface GeoIPDatabase {
+    lookup(ip: string): Promise<GeoLookupResult>;
+    isReady(): boolean;
+}
+/**
+ * Base de données GeoIP en mémoire (fallback sans dépendance externe).
+ * Utilise des plages IP privées/réservées pour le développement local.
+ */
+export declare class MemoryGeoIPDatabase implements GeoIPDatabase {
+    private readonly privateRanges;
+    lookup(ip: string): Promise<GeoLookupResult>;
+    isReady(): boolean;
+    private ipInCidr;
+    private ipToInt;
+}
+/**
+ * Service GeoIP — expose la géolocalisation pour les plugins et le tracker.
+ */
+export declare class GeoIPService {
+    private db;
+    private cache;
+    constructor(db?: GeoIPDatabase);
+    lookup(ip: string): Promise<GeoLookupResult>;
+    setDatabase(db: GeoIPDatabase): void;
+    isReady(): boolean;
+}
+export declare const geoIPService: GeoIPService;

package/dist/google-ai-readiness-auditor.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 🤖 GoogleAiReadinessAuditor — Google AI Overviews & AI Search Readiness Audit
+ *
+ * Implements the 9 deterministic Google AI Readiness checks based on official
+ * Google Search Central documentation and specifications:
+ * - G-INDEX (5 pts): Indexability, HTTP 200, noindex & Googlebot allowance
+ * - G-SNIPPET (5 pts): Snippet rights, max-snippet, data-nosnippet coverage
+ * - G-CANONICAL (3 pts): Singular absolute canonical matching target URL
+ * - G-DATES (2 pts): Valid publication/modification dates (Schema + visible)
+ * - G-BYLINE (2 pts): Author/byline attribution in schema or visible DOM
+ * - G-LINKS (1 pt): Crawlable <a href> link structure
+ * - G-VIEWPORT (1 pt): Mobile viewport meta tag
+ * - G-SITEMAP (1 pt): Sitemap declaration in robots.txt
+ * - G-GENAI-CONTROL (0 pt): Search Console generative AI control advisory
+ *
+ * Total Category Max: 20 points
+ */
+export interface GoogleAiCheck {
+    id: "G-INDEX" | "G-SNIPPET" | "G-CANONICAL" | "G-DATES" | "G-BYLINE" | "G-LINKS" | "G-VIEWPORT" | "G-SITEMAP" | "G-GENAI-CONTROL";
+    title: string;
+    status: "pass" | "warn" | "fail" | "manual";
+    points: number;
+    maxPoints: number;
+    evidence: string;
+    docUrl: string;
+    level: "google-official" | "heuristic";
+}
+export interface GoogleAiAuditInput {
+    url: string;
+    finalUrl?: string;
+    httpStatus?: number;
+    html: string;
+    headers?: Record<string, string>;
+    robotsTxt?: string;
+    schemas?: Array<Record<string, unknown>>;
+    now?: Date;
+}
+export interface GoogleAiReadinessResult {
+    checked: boolean;
+    score: number;
+    maxScore: number;
+    percentage: number;
+    finalUrl: string;
+    checks: GoogleAiCheck[];
+    passCount: number;
+    warnCount: number;
+    failCount: number;
+    criticalIssues: string[];
+    recommendations: string[];
+}
+export declare const GOOGLE_DOC_URLS: Record<GoogleAiCheck["id"], string>;
+export declare const GOOGLE_AI_POINTS: Record<GoogleAiCheck["id"], number>;
+export declare class GoogleAiReadinessAuditor {
+    private static readonly KNOWN_DIRECTIVES;
+    /**
+     * Parses robots directives from <meta name="robots|googlebot"> and X-Robots-Tag headers.
+     */
+    static parseRobotsDirectives(html: string, headers?: Record<string, string>): Set<string>;
+    private static extractDirectives;
+    private static normalizeUrl;
+    /**
+     * Safely extracts JSON-LD schemas from HTML scripts if not explicitly provided.
+     */
+    static extractJsonLd(html: string): Array<Record<string, unknown>>;
+    /**
+     * Runs the complete Google AI Readiness Audit.
+     */
+    static audit(input: GoogleAiAuditInput): GoogleAiReadinessResult;
+    private static checkIndex;
+    private static checkSnippet;
+    private static checkCanonical;
+    private static checkDates;
+    private static checkByline;
+    private static checkLinks;
+    private static checkViewport;
+    private static checkSitemap;
+}