@lynxflow/seo-engine 1.4.1 → 1.5.0

package/dist/instant-matrix-search.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 🔎 Instant In-Memory Matrix Search & Autocomplete ("Buscador") (Inspiration: santifer-irepair)
+ *
+ * Provides sub-millisecond client-side live filtering and autocomplete across all 8 programmatic matrices.
+ */
+export interface SearchableMatrixPage {
+    url: string;
+    title: string;
+    serviceName: string;
+    matrixType: string;
+    modifierName: string;
+    keywords: string[];
+}
+export declare class InstantMatrixSearchEngine {
+    /**
+     * Fast in-memory search over programmatic pages.
+     */
+    static search(query: string, pages: SearchableMatrixPage[], limit?: number): SearchableMatrixPage[];
+}

package/dist/isr-cache-manager.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ⚡ Incremental Static Regeneration (ISR) & Edge Invalidation Cache Manager
+ *
+ * Implements high-throughput in-memory LRU caching with stale-while-revalidate semantics
+ * and selective tag-based invalidation for programmatic pages.
+ */
+export interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+    tags: string[];
+}
+export declare class IsrCacheManager {
+    private static cache;
+    private static defaultTtlMs;
+    /**
+     * Retrieves an item from cache, or executes the resolver and caches the result.
+     */
+    static getOrSet<T>(key: string, resolver: () => Promise<T> | T, tags?: string[], ttlMs?: number): Promise<T>;
+    /**
+     * Invalidates a specific cache key.
+     */
+    static invalidateKey(key: string): boolean;
+    /**
+     * Invalidates all cache entries matching a tag (e.g. "service:crm-pipeline" or "city:lyon").
+     */
+    static invalidateTag(tag: string): number;
+    /**
+     * Clears the entire cache.
+     */
+    static clear(): void;
+    /**
+     * Returns cache size.
+     */
+    static size(): number;
+}

package/dist/knowledge-graph-linker.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 🧠 Google Knowledge Graph Entity Linker (Inspiration: advertools/knowledge_graph.py)
+ *
+ * Resolves official Google Entity IDs (`kgmid`), entity types, and Wikidata URIs
+ * to maximize semantic authority and Knowledge Panel recognition (Entity SEO).
+ */
+export interface KnowledgeGraphEntity {
+    name: string;
+    kgmid: string;
+    types: string[];
+    description?: string;
+    detailedDescriptionUrl?: string;
+    wikidataUri?: string;
+    resultScore: number;
+}
+export declare class KnowledgeGraphLinker {
+    /**
+     * Constructs search query parameters for the Google Knowledge Graph Search API.
+     */
+    static buildSearchUrl(query: string, apiKey: string, limit?: number, languages?: string[]): string;
+    /**
+     * Parses Google Knowledge Graph JSON-LD response items into normalized entities.
+     */
+    static parseApiResponse(jsonResponse: any): KnowledgeGraphEntity[];
+    /**
+     * Generates Schema.org `sameAs` entity triples combining Google kgmid and Wikipedia/Wikidata.
+     */
+    static generateEntitySameAsLinks(entity: KnowledgeGraphEntity, customUrls?: string[]): string[];
+}

package/dist/legal-disclaimers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Global Legal Compliance & Editorial Disclaimer Engine for B2B pSEO
+ * Multilingual compliance and anti-disparagement verification across 10+ languages.
+ */
+export type DisclaimerType = "comparison" | "pricing" | "feature" | "exclusivity" | "statistics" | "alternative" | "listicle";
+export interface DisclaimerTemplate {
+    type: DisclaimerType;
+    label: string;
+    templateText: string;
+}
+/**
+ * Multilingual Disclaimer Templates (English Default + Localized Fallbacks)
+ */
+export declare const MULTILINGUAL_DISCLAIMERS: Record<string, Record<DisclaimerType, DisclaimerTemplate>>;
+/**
+ * Multilingual Banned & Disparaging Words Dictionary across 10 Languages
+ */
+export declare const MULTILINGUAL_BANNED_DISPARAGING_WORDS: Record<string, string[]>;
+export interface LegalEngineOptions {
+    companyName?: string;
+    correctionsEmail?: string;
+    dataStalenessDays?: number;
+    language?: string;
+}
+export declare class LegalDisclaimerEngine {
+    private companyName;
+    private correctionsEmail;
+    private dataStalenessDays;
+    private defaultLanguage;
+    constructor(options?: LegalEngineOptions);
+    /**
+     * Generates a fully resolved disclaimer note in the target language (defaults to English).
+     */
+    getDisclaimer(type: DisclaimerType, lastVerifiedDate?: string, language?: string): string;
+    /**
+     * Evaluates if competitor pricing or feature claim data is older than the allowed staleness window (default: 90 days).
+     */
+    isDataStale(lastVerifiedDateStr?: string): boolean;
+    /**
+     * Validates content against disparaging or legally hazardous statements across all supported languages.
+     */
+    validateCompliance(content: string, competitorName: string, language?: string): {
+        isCompliant: boolean;
+        warnings: string[];
+    };
+}

package/dist/llm-content-cleaner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 🧹 Boilerplate Stripper & Clean Markdown Extractor for LLMs (Inspiration: openserp/extract)
+ *
+ * Strips navigation, headers, footers, cookie banners, and advertisements from raw HTML
+ * to produce clean, high-density markdown text for AI search ingestion (/llms.txt & ChatGPT).
+ */
+export declare class LlmContentCleaner {
+    /**
+     * Alias: Cleans text or markdown for LLMs.
+     */
+    static cleanForLlm(content: string): string;
+    /**
+     * Cleans raw HTML and returns pure readable markdown content.
+     */
+    static htmlToCleanMarkdown(rawHtml: string): string;
+}

package/dist/llm-prompt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Built-in AI Agent & LLM System Prompt Guide
+ * Provides complete operational context for autonomous coding agents (Claude, Cursor, Copilot, ChatGPT, Antigravity)
+ * to interact with the SDK without exposing proprietary internal algorithms in public documentation.
+ */
+export declare const PSEO_AGENT_SYSTEM_PROMPT: string;
+/**
+ * Returns the complete LLM guidance prompt for AI agents and developer copilots.
+ */
+export declare function getSeoAgentPrompt(customContext?: {
+    brandName?: string;
+    domain?: string;
+}): string;

package/dist/master-marketing-engine.d.ts

@@ -0,0 +1,114 @@
+/**
+ * 👑 Master Marketing Engine (LynxSEO × marketingskills)
+ *
+ * Implements the complete 50-Skill Marketing & Growth Architecture:
+ * 1. Directory Submissions Engine (ProductHunt, G2, AlternativeTo, Futurepedia, SaaSHub...)
+ * 2. Grand Slam Offer & Value Stack Builder (Alex Hormozi framework)
+ * 3. Viral Referral & Affiliate Growth Loops
+ * 4. Multi-Touch Attribution Engine (First, Last, Linear, W-Shaped)
+ * 5. Competitor Battlecards & Displacement Generator
+ * 6. Churn Prevention & Retention Engine
+ * 7. Onboarding & Lifecycle Drip Sequencer
+ */
+export interface DirectorySubmissionProfile {
+    directoryName: string;
+    category: "tier1_launch" | "saas_directories" | "ai_directories" | "review_platforms";
+    submissionUrl: string;
+    domainRating: number;
+    dofollow: boolean;
+    requiredFields: {
+        title60Chars: string;
+        tagline: string;
+        shortDescription: string;
+        fullDescription: string;
+        tags: string[];
+        suggestedLandingPagePath: string;
+    };
+}
+export interface GrandSlamOffer {
+    productName: string;
+    dreamOutcome: string;
+    perceivedLikelihoodScore: number;
+    timeDelayMinutes: number;
+    effortScore: number;
+    valueScore: number;
+    corePrice: number;
+    bonusStack: {
+        title: string;
+        perceivedValueEur: number;
+        description: string;
+    }[];
+    totalPerceivedValueEur: number;
+    guaranteeText: string;
+    scarcityText: string;
+}
+export interface CompetitorBattlecard {
+    competitorName: string;
+    competitorPriceMonthly: number;
+    lynxSeoPriceMonthly: number;
+    annualSavingsEur: number;
+    keyWeaknessesToExploit: string[];
+    ourUnfairAdvantages: string[];
+    killerSwitchingArgument: string;
+    objectionHandlers: {
+        objection: string;
+        winningResponse: string;
+    }[];
+}
+export declare class MasterMarketingEngine {
+    /**
+     * 1. Generates 40+ customized directory submissions formatted for ProductHunt, G2, SaaSHub, Futurepedia...
+     */
+    static generateDirectoryListings(domain?: string, brandName?: string): DirectorySubmissionProfile[];
+    /**
+     * 2. Builds a Grand Slam Offer (Alex Hormozi Value Equation).
+     */
+    static buildGrandSlamOffer(serviceName?: string): GrandSlamOffer;
+    /**
+     * 3. Generates Competitor Battlecard (Semrush, Ahrefs, HubSpot, Jasper).
+     */
+    static generateCompetitorBattlecard(competitor: "semrush" | "ahrefs" | "jasper"): CompetitorBattlecard;
+    /**
+     * 4. Multi-Touch Attribution Calculator (First Touch, Last Touch, Linear, W-Shaped).
+     */
+    static calculateAttribution(touchpoints: {
+        source: string;
+        channel: "organic_seo" | "ai_search" | "direct" | "referral";
+    }[], dealValueEur: number): {
+        dealValueEur?: undefined;
+        touchpointsCount?: undefined;
+        firstTouch?: undefined;
+        lastTouch?: undefined;
+        linearValuePerTouch?: undefined;
+        wShapedBreakdown?: undefined;
+    } | {
+        dealValueEur: number;
+        touchpointsCount: number;
+        firstTouch: {
+            source: string;
+            valueEur: number;
+        };
+        lastTouch: {
+            source: string;
+            valueEur: number;
+        };
+        linearValuePerTouch: number;
+        wShapedBreakdown: {
+            source: string;
+            channel: "ai_search" | "direct" | "referral" | "organic_seo";
+            attributedEur: number;
+        }[];
+    };
+    /**
+     * 5. Churn Prevention & Retention Engine.
+     */
+    static evaluateChurnRisk(signals: {
+        daysSinceLastLogin: number;
+        pagesGeneratedThisMonth: number;
+        rankDropAlertsCount: number;
+    }): {
+        riskScore: number;
+        riskLevel: string;
+        recommendedAction: string;
+    };
+}

package/dist/matrix-engine.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Global Multilingual Programmatic SEO Matrix Engine
+ * Defaults to English with international localization support across 10+ languages (EN, FR, DE, ES, IT, PT, NL, etc.)
+ *
+ * Implements strict SEO golden rules:
+ * - Clean canonical URL paths (no keyword stuttering, no stop words across 10+ languages)
+ * - Anti-cannibalization target clustering
+ * - Google Rich Result Schema.org Graphs (SoftwareApplication, LocalBusiness, HowTo, FAQ, Breadcrumbs)
+ * - SeedRank legal compliance disclaimers & staleness checks
+ * - Tiered Indexing (crawl budget protection) & Geodesic Mesh Linking
+ */
+export type MatrixFamily = "local-geo" | "vs-comparison" | "alternative" | "pricing" | "target" | "industry" | "persona" | "integration" | "use-case" | "template" | "glossary" | "calculator";
+export interface PseoService {
+    slug: string;
+    name: string;
+    category: string;
+    description: string;
+    keyFeatures: string[];
+    priceMonthly?: number;
+}
+export interface PseoLocation {
+    slug: string;
+    name: string;
+    region: string;
+    country: string;
+    currency: string;
+    currencySymbol: string;
+    population?: number;
+    latitude?: number;
+    longitude?: number;
+    neighborSlugs?: string[];
+}
+export interface PseoCompetitor {
+    slug: string;
+    name: string;
+    category: string;
+    drawbacks: string[];
+    advantagesOver: string[];
+    startingPrice?: number;
+    pricingUrl?: string;
+    lastVerifiedDate?: string;
+}
+export interface PseoTarget {
+    slug: string;
+    name: string;
+    type: "industry" | "role";
+    painPoints: string[];
+    benefits: string[];
+    workflowSteps?: string[];
+}
+export interface PseoIndustry {
+    slug: string;
+    name: string;
+    category?: string;
+    singular?: string;
+    painPoints?: string[];
+    benefits?: string[];
+}
+export interface PseoPersona {
+    slug: string;
+    role: string;
+    department?: string;
+    responsibilities?: string[];
+}
+export interface PseoIntegration {
+    slug: string;
+    name: string;
+    category: string;
+    syncFeatures: string[];
+}
+export interface PseoUseCase {
+    slug: string;
+    title: string;
+    problem: string;
+    solutionWorkflow: string[];
+    expectedRoi: string;
+}
+export interface PseoTemplate {
+    slug: string;
+    title: string;
+    topic: string;
+    format: "excel" | "sheets" | "notion" | "word" | "pdf";
+    downloadUrl?: string;
+    benefits: string[];
+}
+export interface PseoGlossaryTerm {
+    slug: string;
+    term: string;
+    shortDefinition: string;
+    fullMarkdown?: string;
+    relatedTermsSlugs?: string[];
+}
+export interface PseoCalculator {
+    slug: string;
+    title: string;
+    formulaDescription: string;
+    savingsMetric: string;
+}
+export interface SchemaOrgGraph {
+    "@context": "https://schema.org";
+    "@graph": Record<string, unknown>[];
+}
+export interface GeneratedPageMeta {
+    matrixFamily: MatrixFamily;
+    urlPath: string;
+    canonicalUrl: string;
+    title: string;
+    description: string;
+    h1: string;
+    robots: "index, follow" | "noindex, follow";
+    schemaGraph: SchemaOrgGraph;
+    disclaimerText?: string;
+    neighboringLinks?: {
+        name: string;
+        url: string;
+    }[];
+    service?: PseoService;
+    location?: PseoLocation;
+    competitor?: PseoCompetitor;
+    target?: PseoTarget;
+    integration?: PseoIntegration;
+    useCase?: PseoUseCase;
+    template?: PseoTemplate;
+    glossary?: PseoGlossaryTerm;
+    calculator?: PseoCalculator;
+}
+export interface MatrixOptions {
+    brandName: string;
+    language?: string;
+    minPopulationToIndex?: number;
+    defaultCurrency?: string;
+    defaultCurrencySymbol?: string;
+    organizationSameAs?: string[];
+    correctionsEmail?: string;
+}
+export declare class PseoMatrixEngine {
+    private legalEngine;
+    constructor(legalOptions?: {
+        correctionsEmail?: string;
+        companyName?: string;
+        language?: string;
+    });
+    /**
+     * Helper: Resolves route prefixes according to language (English default).
+     */
+    private getPrefix;
+    /**
+     * 1. Local & GEO Matrix (`/solutions/{service}/{country}/{city}`)
+     */
+    generateLocalGeoMatrix(domain: string, services: PseoService[], locations: PseoLocation[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 2. VS Comparisons Matrix (`/vs/{competitor}` in English default)
+     */
+    generateVsMatrix(domain: string, competitors: PseoCompetitor[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 3. Alternatives Matrix (`/alternatives/{competitor}`)
+     */
+    generateAlternativesMatrix(domain: string, competitors: PseoCompetitor[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 4. Pricing Matrix (`/pricing/{competitor}` in English default)
+     */
+    generatePricingMatrix(domain: string, competitors: PseoCompetitor[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 5. Unified Target Audience Matrix (`/for/{target}` in English default)
+     */
+    generateTargetMatrix(domain: string, targets: PseoTarget[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 6. Integrations Matrix (`/integrations/{software}`)
+     */
+    generateIntegrationMatrix(domain: string, integrations: PseoIntegration[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 7. Use Cases Matrix (`/use-cases/{useCase}` in English default)
+     */
+    generateUseCaseMatrix(domain: string, useCases: PseoUseCase[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 8. Templates & Lead Magnets Matrix (`/templates/{slug}` in English default)
+     */
+    generateTemplateMatrix(domain: string, templates: PseoTemplate[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 9. Glossary Matrix (`/glossary/{term}` in English default)
+     */
+    generateGlossaryMatrix(domain: string, terms: PseoGlossaryTerm[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * 10. Tools & Calculators Matrix (`/tools/{calculator}` in English default)
+     */
+    generateCalculatorMatrix(domain: string, calculators: PseoCalculator[], options: MatrixOptions): GeneratedPageMeta[];
+    /**
+     * Master Generator: Produces all programmatic families simultaneously.
+     */
+    generateAllMatrices(domain: string, data: {
+        services?: PseoService[];
+        locations?: PseoLocation[];
+        competitors?: PseoCompetitor[];
+        targets?: PseoTarget[];
+        integrations?: PseoIntegration[];
+        useCases?: PseoUseCase[];
+        templates?: PseoTemplate[];
+        glossaryTerms?: PseoGlossaryTerm[];
+        calculators?: PseoCalculator[];
+    }, options: MatrixOptions): GeneratedPageMeta[];
+}

package/dist/mcp-seo-server.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 🤖 Model Context Protocol (MCP) Native Server for LynxSEO (Inspiration: spider/spider_mcp)
+ *
+ * Exposes LynxSEO capabilities as standardized MCP Tools for autonomous AI Agents
+ * (Claude Desktop, Cursor, Antigravity, OpenRouter).
+ */
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare class McpSeoServerHub {
+    /**
+     * Returns all available LynxSEO tool definitions for MCP clients.
+     */
+    static getRegisteredTools(): McpToolDefinition[];
+    /**
+     * Handles tool execution requests from MCP agents.
+     */
+    static handleToolCall(toolName: string, args: Record<string, any>): Promise<any>;
+}

package/dist/ngram-density-analyzer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 📊 N-Gram Density & Weighted Lexical Frequency Analyzer (Inspiration: advertools/word_frequency.py)
+ *
+ * Computes 1-gram, 2-gram (bigrams), and 3-gram (trigrams) frequency and density percentages
+ * to detect keyword stuffing (> 3.5%) and identify high-value missing co-occurrences.
+ */
+export interface NGramMetric {
+    phrase: string;
+    count: number;
+    densityPercentage: number;
+    length: number;
+}
+export interface LexicalAnalysisReport {
+    totalWords: number;
+    topUnigrams: NGramMetric[];
+    topBigrams: NGramMetric[];
+    topTrigrams: NGramMetric[];
+    keywordStuffingAlerts: NGramMetric[];
+}
+export declare class NGramDensityAnalyzer {
+    private static stopwords;
+    /**
+     * Cleans text and tokenizes into words.
+     */
+    static tokenize(text: string): string[];
+    /**
+     * Generates N-Grams of specified length.
+     */
+    static generateNGrams(tokens: string[], n: number): string[];
+    /**
+     * Analyzes an HTML or text payload for N-Gram frequencies and density.
+     */
+    static analyzeText(text: string): LexicalAnalysisReport;
+    private static countAndRank;
+}

package/dist/rank-math-parity.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 👑 Rank Math Parity & Real-Time Content SEO Score Engine
+ *
+ * Implements the core features that made Rank Math famous (3M+ installs):
+ * 1. Real-Time 0-100 On-Page Content SEO Score (Checklist: Title, Slug, H2, Density, Words, Internal/External links)
+ * 2. 301/302/410 Redirection Manager & 404 Error Monitor
+ * 3. AI Image Alt Text Generator (Keyword-rich accessibility attributes)
+ * 4. Robots.txt Generator & AI Crawlers Rule Validator
+ */
+export interface OnPageCheckItem {
+    id: string;
+    category: "basic_seo" | "additional_seo" | "title_readability" | "content_readability";
+    label: string;
+    passed: boolean;
+    scoreImpact: number;
+    tip: string;
+}
+export interface OnPageSeoScoreResult {
+    score: number;
+    grade: "poor" | "fair" | "good" | "great";
+    focusKeyword: string;
+    wordCount: number;
+    keywordDensityPercent: number;
+    checklist: OnPageCheckItem[];
+    criticalFixes: string[];
+}
+export interface RedirectRule {
+    id: string;
+    sourcePath: string;
+    destinationUrl: string;
+    statusCode: 301 | 302 | 307 | 410 | 451;
+    isActive: boolean;
+    hitsCount: number;
+    createdAt: string;
+}
+export declare class RankMathParityEngine {
+    /**
+     * 1. Calculates the exact 0-100 Real-Time On-Page Content SEO Score (Rank Math Benchmark).
+     */
+    static calculateOnPageScore(opts: {
+        focusKeyword: string;
+        title: string;
+        description: string;
+        slug: string;
+        htmlOrMarkdownContent: string;
+        imagesCount?: number;
+        hasInternalLinks?: boolean;
+        hasExternalLinks?: boolean;
+    }): OnPageSeoScoreResult;
+    /**
+     * 2. Generates SEO-rich Alt text for images based on surrounding context.
+     */
+    static generateImageAltText(imageFilename: string, pageTopic: string, serviceName: string): string;
+    /**
+     * 3. Generates optimal robots.txt rules including Search Engine & AI bot crawler directives.
+     */
+    static generateRobotsTxt(domain: string, allowAiBots?: boolean): string;
+}

package/dist/real-reviews-sync.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 🌟 Real Reviews & Star Ratings Ingestion Engine
+ *
+ * Official Compliance with Google Search Central Review Snippet Guidelines:
+ * 1. Requires reviews to be visibly rendered in the DOM (`generateVisibleReviewsHtmlBlock`).
+ * 2. Restricts AggregateRating to legitimate non-self-serving entities (Product, SoftwareApplication).
+ * 3. Pulls live authentic review records from Google Places API (New), Trustpilot API or DataForSEO.
+ */
+export interface VerifiedReview {
+    id: string;
+    source: "google_places" | "trustpilot" | "g2" | "producthunt" | "verified_customer";
+    authorName: string;
+    ratingValue: number;
+    reviewText: string;
+    datePublished: string;
+    verifiedPurchase?: boolean;
+}
+export interface RealAggregateRating {
+    ratingValue: string;
+    reviewCount: string;
+    bestRating: "5";
+    worstRating: "1";
+    ratingDistribution: {
+        5: number;
+        4: number;
+        3: number;
+        2: number;
+        1: number;
+    };
+    sampleReviews: VerifiedReview[];
+}
+export declare class RealReviewsSyncEngine {
+    /**
+     * 1. Fetches authentic reviews directly from Google Places API (New).
+     * Endpoint: https://places.googleapis.com/v1/places/{PLACE_ID}?fields=rating,userRatingCount,reviews&key={API_KEY}
+     */
+    static fetchGooglePlacesReviews(opts: {
+        placeId: string;
+        googleApiKey: string;
+        languageCode?: string;
+    }): Promise<{
+        aggregate: RealAggregateRating | null;
+        reviews: VerifiedReview[];
+    }>;
+    /**
+     * 2. Computes real AggregateRating & distribution from an array of verified reviews.
+     */
+    static computeAggregateFromReviews(reviews: VerifiedReview[]): RealAggregateRating | null;
+    /**
+     * 3. Transforms raw DataForSEO or custom reviews into VerifiedReview format.
+     */
+    static mapGoogleBusinessReviews(rawGoogleReviews: Array<{
+        author_title?: string;
+        rating?: {
+            value?: number;
+        };
+        review_text?: string;
+        time_ago?: string;
+        timestamp?: string;
+    }>): VerifiedReview[];
+    /**
+     * 4. Converts verified reviews into Google Schema.org Review[] JSON-LD objects.
+     */
+    static toSchemaOrgReviews(reviews: VerifiedReview[]): Record<string, unknown>[];
+    /**
+     * 5. Generates the mandatory visible HTML review widget for the web page.
+     * Google Strict Requirement: Marked up reviews MUST be visible in the page content.
+     */
+    static generateVisibleReviewsHtmlBlock(opts: {
+        aggregate: RealAggregateRating;
+        productName: string;
+    }): string;
+}