@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/dataset-matrix-architect.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 🧬 Dataset Matrix Architect & Route Synthesis Engine
+ *
+ * Empowers users to import custom datasets (CSV / JSON), auto-detect data structures,
+ * construct the 3 primary pSEO archetypes (Géo-Local, B2B/VS Comparison, Directory/Recipes),
+ * evaluate Google Quality & Indexation Safety (preventing "thin content" & penalty bait),
+ * and instantly generate production routes for React (Next.js App Router, TanStack Router)
+ * and WordPress (Rewrite Rules & Custom Post Types).
+ */
+import type { MatrixFamily } from "./matrix-engine";
+export interface GeoCitabilityAdvisory {
+    predictedCitabilityScore: number;
+    geoStatus: "EXCELLENT" | "ACCEPTABLE" | "NEEDS_OPTIMIZATION" | "HALLUCINATION_RISK";
+    answerFirstBlockSample: string;
+    statisticsTableSample: string;
+    authoritativeSourcesSample: Array<{
+        sourceName: string;
+        url?: string;
+        anchorText: string;
+    }>;
+    programmaticLlmsTxt: string;
+    programmaticAiSummaryJson: string;
+    recommendations: string[];
+}
+export type PseoArchetype = "geo_local" | "b2b_vs" | "directory_recipe" | "templates" | "curation" | "conversions" | "examples" | "personas" | "integrations" | "glossary" | "translations" | "directory" | "profiles" | "custom_hybrid";
+export interface PseoDefensibilityAudit {
+    defensibilityScore: number;
+    tierLevel: "TIER_1_PROPRIETARY" | "TIER_2_PRODUCT_DERIVED" | "TIER_3_UGC" | "TIER_4_LICENSED" | "TIER_5_PUBLIC_SCRAPED";
+    thinContentRisk: "LOW" | "MODERATE" | "HIGH_PENALTY_RISK";
+    subfolderCompliance: boolean;
+    strengths: string[];
+    vulnerabilities: string[];
+    recommendations: string[];
+}
+export interface DatasetColumnAnalysis {
+    name: string;
+    inferredType: "slug" | "title" | "city" | "country" | "price" | "rating" | "category" | "ingredient" | "text" | "number";
+    sampleValues: string[];
+    uniqueCount: number;
+    nullPercentage: number;
+}
+export interface GoogleQualityAdvisory {
+    safetyScore: number;
+    riskLevel: "safe" | "moderate" | "high_risk_penalty";
+    strengths: string[];
+    vulnerabilities: string[];
+    recommendations: string[];
+    canonicalStrategy: "direct_hierarchical" | "sorted_alphabetical" | "faceted_filtered";
+}
+export interface RouteGenerationSnippets {
+    nextJsAppRouter: {
+        filePath: string;
+        code: string;
+    };
+    tanStackRouter: {
+        filePath: string;
+        code: string;
+    };
+    wordPress: {
+        phpSnippet: string;
+        rewriteRule: string;
+    };
+}
+export interface MatrixBlendConfig {
+    primaryArchetype: PseoArchetype;
+    matrixFamilies: MatrixFamily[];
+    routePattern: string;
+    primaryKeyColumn: string;
+    secondaryKeyColumn?: string;
+    attributeColumns: string[];
+    richSnippetType: "LocalBusiness" | "Product" | "Recipe" | "SoftwareApplication" | "Review";
+}
+export interface DatasetArchitectureResult {
+    detectedArchetype: PseoArchetype;
+    recommendedBlend: MatrixBlendConfig;
+    columns: DatasetColumnAnalysis[];
+    totalRows: number;
+    qualityAdvisory: GoogleQualityAdvisory;
+    geoAdvisory: GeoCitabilityAdvisory;
+    routes: RouteGenerationSnippets;
+    sampleGeneratedUrls: string[];
+}
+export declare class DatasetMatrixArchitect {
+    /**
+     * Parse raw CSV text into typed objects and headers.
+     */
+    static parseCsv(csvText: string, delimiter?: string): {
+        headers: string[];
+        rows: Record<string, string>[];
+    };
+    /**
+     * Analyze columns to infer data types and uniqueness.
+     */
+    static analyzeColumns(headers: string[], rows: Record<string, string>[]): DatasetColumnAnalysis[];
+    /**
+     * Evaluates dataset, recommends archetypes, produces Google safety advice & code snippets.
+     */
+    static analyzeDataset(dataset: {
+        headers: string[];
+        rows: Record<string, string>[];
+    }, options?: {
+        brandName?: string;
+        domain?: string;
+        language?: string;
+    }): DatasetArchitectureResult;
+    /**
+     * Scores dataset against Google 2026 Core Update & Helpful Content Guidelines.
+     */
+    private static calculateGoogleQuality;
+    /**
+     * Synthesizes ready-to-use routing code for React (Next.js & TanStack) and WordPress.
+     */
+    private static generateRouteCode;
+    /**
+     * 🛡️ Audit Data Defensibility & Thin Content Shield
+     * Enforces the 5-Tier Data Defensibility Hierarchy and subfolder URL structure
+     */
+    static auditDefensibility(input: {
+        dataTier: "proprietary" | "product_derived" | "ugc" | "licensed" | "public_scraped";
+        uniqueContentRatio: number;
+        usesSubfolders: boolean;
+        averageWordCount: number;
+        hasInteractiveToolsOrCalculators?: boolean;
+    }): PseoDefensibilityAudit;
+}

package/dist/datasets/index.d.ts

@@ -0,0 +1 @@
+export * from "./inferColumnTypes";

package/dist/datasets/inferColumnTypes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 🧬 Inférence de types de colonnes pour l'import de datasets tabulaires.
+ *
+ * À partir d'un échantillon de lignes (CSV, TSV ou feuille XLSX), ce module
+ * devine le type le plus spécifique de chaque colonne afin de créer une table
+ * physique typée. Module pur : aucune dépendance externe, aucun accès réseau,
+ * aucune horloge. Le même échantillon produit toujours la même inférence.
+ *
+ * Ordre de spécificité : `integer` > `number` > `boolean` > `date` > `string`.
+ * Une colonne vide (aucune valeur non blanche) reste `string` et nullable.
+ */
+export type DatasetImportColumnType = "integer" | "number" | "date" | "boolean" | "string";
+/** Schéma inféré d'une colonne, prêt à être sérialisé en JSON. */
+export interface InferredColumn {
+    name: string;
+    type: DatasetImportColumnType;
+    nullable: boolean;
+}
+/**
+ * Infère le type et la nullabilité de chaque colonne à partir de son en-tête
+ * et d'un échantillon de lignes. `sampleRows` peut être plus court que le jeu
+ * complet : les lignes suivantes sont typées vers ces colonnes.
+ */
+export declare function inferColumnTypes(headers: string[], sampleRows: ReadonlyArray<ReadonlyArray<unknown>>): InferredColumn[];
+/**
+ * Convertit une cellule brute vers la valeur typée correspondante.
+ *
+ * Retourne `null` pour une cellule blanche ou non convertible : le type a été
+ * inféré sur un échantillon, une ligne hors échantillon peut légitimement
+ * porter une valeur atypique qu'on préfère neutraliser plutôt que corrompre.
+ */
+export declare function coerceValue(raw: unknown, type: DatasetImportColumnType): string | number | boolean | null;

package/dist/deep-crawl-importer.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 🦁 @lynxseo/engine - Enterprise Deep Crawl Importer & Diagnostic Engine
+ *
+ * High-performance offline parser and diagnostic engine for enterprise crawl
+ * export files (internal URLs, redirect chains, canonicals, issues).
+ *
+ * Features:
+ * - Ingests large crawl CSV exports with zero API overhead
+ * - Automatic indexability breakdown (Indexable vs Non-Indexable with reason)
+ * - Deep redirect & canonical chain resolver (detects loops, chains > 2 hops)
+ * - Content quality diagnostics (thin content, missing titles, missing H1, unlinked pages)
+ * - Crawl health scorecard & prioritized recommendations
+ */
+import type { CrawlApiEnrichmentData } from "./crawl-api-enricher";
+export interface DeepCrawlUrlItem {
+    url: string;
+    statusCode: number;
+    status: string;
+    indexability: "Indexable" | "Non-Indexable";
+    indexabilityReason?: string;
+    title?: string;
+    titleLength?: number;
+    metaDescription?: string;
+    metaDescriptionLength?: number;
+    h1?: string;
+    h2?: string;
+    wordCount: number;
+    canonicalUrl?: string;
+    inlinksCount: number;
+    outlinksCount: number;
+    crawlDepth?: number;
+    imagesCount?: number;
+    imagesWithoutAlt?: number;
+    apiEnrichment?: CrawlApiEnrichmentData;
+}
+export interface DeepCrawlSummary {
+    totalUrls: number;
+    indexableUrlsCount: number;
+    nonIndexableUrlsCount: number;
+    statusCodesSummary: {
+        "2xx": number;
+        "3xx": number;
+        "4xx": number;
+        "5xx": number;
+    };
+    issuesSummary: {
+        missingTitlesCount: number;
+        duplicateTitlesCount: number;
+        missingMetaDescCount: number;
+        missingH1Count: number;
+        thinContentCount: number;
+        brokenLinks4xxCount: number;
+        serverErrors5xxCount: number;
+        canonicalMismatchCount: number;
+    };
+    averageWordCount: number;
+    items: DeepCrawlUrlItem[];
+}
+export interface DeepRedirectChainItem {
+    sourceUrl: string;
+    chainLength: number;
+    intermediateUrls: string[];
+    finalDestinationUrl: string;
+    isLoop: boolean;
+    statusCode: number;
+}
+export interface DeepCanonicalItem {
+    url: string;
+    canonicalUrl: string;
+    isSelfReferencing: boolean;
+    isCanonicalised: boolean;
+    isMissing: boolean;
+    isRelative: boolean;
+}
+export interface DeepCrawlIssue {
+    id: string;
+    category: "Indexability" | "Redirects" | "Canonicals" | "Content" | "Meta" | "Security";
+    severity: "CRITICAL" | "HIGH" | "MEDIUM" | "LOW";
+    title: string;
+    count: number;
+    description: string;
+    howToFix: string;
+    urlsSample: string[];
+}
+export interface DeepCrawlHealthReport {
+    healthScore: number;
+    grade: "A+" | "A" | "B" | "C" | "D" | "F";
+    totalCrawled: number;
+    indexabilityPercentage: number;
+    issues: DeepCrawlIssue[];
+    topRecommendations: string[];
+}
+export type SfCrawlUrlItem = DeepCrawlUrlItem;
+export type SfCrawlSummary = DeepCrawlSummary;
+export type SfRedirectChainItem = DeepRedirectChainItem;
+export type SfCanonicalItem = DeepCanonicalItem;
+export type SfCrawlIssue = DeepCrawlIssue;
+export type SfCrawlHealthReport = DeepCrawlHealthReport;
+export declare class DeepCrawlImporter {
+    /**
+     * Parse internal_all.csv or internal_html.csv export
+     */
+    static parseInternalAllCsv(csvContent: string): DeepCrawlSummary;
+    /**
+     * Parse redirect_chains.csv export
+     */
+    static parseRedirectChainsCsv(csvContent: string): SfRedirectChainItem[];
+    /**
+     * Parse canonicals.csv export
+     */
+    static parseCanonicalsCsv(csvContent: string): SfCanonicalItem[];
+    /**
+     * Evaluate crawl health and compile deep crawl audit report
+     */
+    static evaluateCrawlHealth(summary: SfCrawlSummary): SfCrawlHealthReport;
+    /**
+     * Helper: parse a single CSV line with quoted string handling
+     */
+    private static parseCsvLine;
+}

package/dist/deep-crawler-auditor.d.ts

@@ -0,0 +1,185 @@
+/**
+ * 🦁 LynxSEO Deep Crawler Auditor (Enterprise Parity Engine)
+ *
+ * Provides advanced enterprise-grade crawl audit modules:
+ * 1. DomHtmlDriftAuditor: Compares raw HTTP response vs rendered JavaScript DOM (Title, Canonical, Robots, Word Count, Injected Links).
+ * 2. HreflangMatrixAuditor: Full multi-locale reciprocal cross-validation, ISO code checks, self-referencing validation, and non-200 target detection.
+ * 3. SitemapReconciliationAuditor: Cross-reconciliation between XML sitemap entries and crawled URLs (dirty sitemaps, orphan URLs, missing indexable pages).
+ * 4. PaginationIntegrityAuditor: Identifies paginated pages canonicalising to page 1, broken sequences, and pagination loops.
+ */
+export interface DomDriftComparisonInput {
+    url: string;
+    rawHtml: string;
+    renderedDom: string;
+}
+export interface DomDriftIssue {
+    type: "title_drift" | "canonical_drift" | "robots_drift" | "word_count_drift" | "injected_links_drift";
+    severity: "critical" | "warning" | "info";
+    message: string;
+    recommendation: string;
+    rawHtmlValue?: string | number | null;
+    renderedDomValue?: string | number | null;
+}
+export interface DomDriftReport {
+    url: string;
+    hasSignificantDrift: boolean;
+    rawTitle: string | null;
+    renderedTitle: string | null;
+    rawCanonical: string | null;
+    renderedCanonical: string | null;
+    rawRobots: string | null;
+    renderedRobots: string | null;
+    rawWordCount: number;
+    renderedWordCount: number;
+    wordCountDifferencePct: number;
+    rawLinksCount: number;
+    renderedLinksCount: number;
+    injectedLinksCount: number;
+    issues: DomDriftIssue[];
+}
+export declare class DomHtmlDriftAuditor {
+    private static extractTitle;
+    private static extractCanonical;
+    private static extractRobots;
+    private static extractLinks;
+    private static countWords;
+    /**
+     * Compare initial raw server-side HTML against post-JS hydrated DOM
+     */
+    static compare(input: DomDriftComparisonInput): DomDriftReport;
+}
+export interface HreflangDeclaration {
+    url: string;
+    hreflang: string;
+    targetUrl: string;
+    isSelfReferencing: boolean;
+}
+export interface HreflangPageInput {
+    url: string;
+    statusCode: number;
+    isIndexable: boolean;
+    hreflangs: {
+        lang: string;
+        href: string;
+    }[];
+}
+export interface HreflangAnomaly {
+    sourceUrl: string;
+    hreflangCode: string;
+    targetUrl: string;
+    type: "missing_return_tag" | "invalid_iso_code" | "missing_self_reference" | "missing_x_default" | "non_200_target";
+    severity: "critical" | "warning" | "info";
+    message: string;
+    recommendation: string;
+}
+export interface HreflangMatrixReport {
+    totalPagesAudited: number;
+    totalHreflangLinks: number;
+    reciprocalMatchPercentage: number;
+    missingReturnTagsCount: number;
+    invalidIsoCodesCount: number;
+    non200TargetsCount: number;
+    missingSelfRefCount: number;
+    anomalies: HreflangAnomaly[];
+}
+export declare class HreflangMatrixAuditor {
+    private static isValidHreflangCode;
+    /**
+     * Audit multi-lingual cross-linking and verify strict bidirectional return tags
+     */
+    static auditMatrix(pages: HreflangPageInput[]): HreflangMatrixReport;
+}
+export interface SitemapEntry {
+    loc: string;
+    lastmod?: string;
+}
+export interface CrawledUrlSummary {
+    url: string;
+    statusCode: number;
+    isIndexable: boolean;
+    inlinksCount: number;
+}
+export interface SitemapReconciliationReport {
+    totalSitemapUrls: number;
+    totalCrawledUrls: number;
+    dirtySitemapUrls: {
+        url: string;
+        reason: string;
+        statusCode: number;
+    }[];
+    orphanSitemapUrls: string[];
+    unsubmittedIndexableUrls: string[];
+    sitemapHealthScore: number;
+    recommendations: string[];
+}
+export declare class SitemapReconciliationAuditor {
+    /**
+     * Reconciles XML sitemap entries against the live crawled URL database
+     */
+    static reconcile(sitemapEntries: SitemapEntry[], crawledPages: CrawledUrlSummary[]): SitemapReconciliationReport;
+}
+export interface PaginatedPageItem {
+    url: string;
+    canonicalUrl: string | null;
+    prevUrl?: string | null;
+    nextUrl?: string | null;
+    hasNoindex?: boolean;
+}
+export interface PaginationIssue {
+    url: string;
+    type: "canonical_to_root" | "paginated_noindex" | "broken_prev_next" | "pagination_loop";
+    severity: "critical" | "warning";
+    message: string;
+    recommendation: string;
+}
+export declare class PaginationIntegrityAuditor {
+    private static isPaginatedUrl;
+    /**
+     * Audit paginated sequences to detect common de-indexing traps
+     */
+    static audit(pages: PaginatedPageItem[]): {
+        totalPaginatedPages: number;
+        issues: PaginationIssue[];
+    };
+}
+export interface ConsoleLogEntry {
+    type: "error" | "warning" | "info";
+    message: string;
+    sourceUrl?: string;
+    lineNumber?: number;
+}
+export interface ResourceLoadEntry {
+    url: string;
+    resourceType: "script" | "stylesheet" | "image" | "font" | "fetch" | "other";
+    statusCode: number;
+    blockedByRobots?: boolean;
+    isMixedContent?: boolean;
+}
+export interface HeadlessRuntimePageInput {
+    url: string;
+    consoleLogs?: ConsoleLogEntry[];
+    loadedResources?: ResourceLoadEntry[];
+}
+export interface HeadlessRuntimeIssue {
+    url: string;
+    type: "js_fatal_error" | "mixed_content_resource" | "broken_asset_4xx_5xx" | "blocked_by_robots";
+    severity: "critical" | "warning" | "info";
+    message: string;
+    recommendation: string;
+    offendingResourceOrError?: string;
+}
+export interface HeadlessRuntimeReport {
+    totalPagesAudited: number;
+    pagesWithJsErrorsCount: number;
+    pagesWithMixedContentCount: number;
+    brokenAssetsCount: number;
+    blockedAssetsCount: number;
+    issues: HeadlessRuntimeIssue[];
+}
+export declare class HeadlessConsoleResourceAuditor {
+    /**
+     * Audit browser console errors and blocked resources matching Screaming Frog's
+     * Chrome Console Log and Blocked Resource tabs
+     */
+    static audit(pages: HeadlessRuntimePageInput[]): HeadlessRuntimeReport;
+}

package/dist/deep-data-audit.d.ts

@@ -0,0 +1,134 @@
+/**
+ * 🔍 LynxSEO Deep Data Audit (G21)
+ *
+ * Comprehensive data quality checks across crawl, analytics, content,
+ * schema, links and technical signals. Produces an actionable audit report
+ * with severity levels and concrete recommendations.
+ */
+export type AuditSeverity = "critical" | "high" | "medium" | "low" | "info";
+export type DataQualityCheckCategory = "completeness" | "consistency" | "accuracy" | "freshness" | "uniqueness" | "validity" | "integrity" | "coverage";
+export interface DataQualityCheck {
+    id: string;
+    category: DataQualityCheckCategory;
+    name: string;
+    description: string;
+    severity: AuditSeverity;
+    passed: boolean;
+    score: number;
+    affectedCount: number;
+    totalCount: number;
+    details: string;
+    recommendation: string;
+    metadata?: Record<string, unknown>;
+}
+export interface DeepDataAuditInput {
+    pages?: Array<{
+        url: string;
+        title?: string | null;
+        metaDescription?: string | null;
+        h1?: string | null;
+        canonical?: string | null;
+        robots?: string | null;
+        statusCode?: number;
+        wordCount?: number;
+        lastModified?: string | null;
+        schema?: unknown[] | null;
+        images?: number;
+        internalLinks?: number;
+        externalLinks?: number;
+        indexable?: boolean;
+    }>;
+    keywords?: Array<{
+        keyword: string;
+        clicks?: number;
+        impressions?: number;
+        position?: number;
+        ctr?: number;
+    }>;
+    backlinks?: Array<{
+        sourceUrl: string;
+        targetUrl: string;
+        anchor?: string | null;
+        follow?: boolean;
+    }>;
+    sitemaps?: Array<{
+        url: string;
+        lastmod?: string | null;
+        inSitemap: boolean;
+    }>;
+    analytics?: {
+        sessions?: number;
+        pageviews?: number;
+        bounceRate?: number;
+        avgSessionDuration?: number;
+    };
+    crawlDate?: string;
+}
+export interface AuditFinding {
+    id: string;
+    checkId: string;
+    severity: AuditSeverity;
+    category: DataQualityCheckCategory;
+    title: string;
+    description: string;
+    affectedUrls?: string[];
+    affectedCount: number;
+    impact: string;
+    recommendation: string;
+    effort: "low" | "medium" | "high";
+    priority: number;
+}
+export interface DeepDataAuditReport {
+    id: string;
+    generatedAt: string;
+    crawlDate?: string;
+    overallScore: number;
+    grade: "A" | "B" | "C" | "D" | "F";
+    summary: string;
+    checks: DataQualityCheck[];
+    findings: AuditFinding[];
+    recommendations: Array<{
+        priority: number;
+        severity: AuditSeverity;
+        title: string;
+        description: string;
+        actionItems: string[];
+        estimatedImpact: "high" | "medium" | "low";
+        estimatedEffort: "low" | "medium" | "high";
+    }>;
+    metrics: {
+        totalPages: number;
+        criticalIssues: number;
+        highIssues: number;
+        mediumIssues: number;
+        lowIssues: number;
+        checksPassed: number;
+        checksFailed: number;
+        passRate: number;
+    };
+    dataQuality: {
+        completeness: number;
+        consistency: number;
+        accuracy: number;
+        freshness: number;
+        uniqueness: number;
+        validity: number;
+        integrity: number;
+        coverage: number;
+    };
+}
+export declare class DeepDataAuditor {
+    /**
+     * Run comprehensive deep data quality audit
+     */
+    static audit(input: DeepDataAuditInput): DeepDataAuditReport;
+    /**
+     * Get quick health summary
+     */
+    static getHealthSummary(report: DeepDataAuditReport): string;
+    /**
+     * Filter findings by severity
+     */
+    static getFindingsBySeverity(report: DeepDataAuditReport, severity: AuditSeverity): AuditFinding[];
+}
+export default DeepDataAuditor;

package/dist/destinations/destination-circuit-breaker.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Destination Health & Circuit Breaker Manager — RudderStack Parity
+ * (Destination Fault Isolation & SLA Protection)
+ *
+ * Protège les destinations contre les surcharges et pannes en cascade :
+ * - État "closed" : Fonctionnement normal, distribution directe.
+ * - État "open" : Déclenché après N échecs consécutifs. Les requêtes sont
+ *   automatiquement dérivées vers la Dead Letter Queue (DLQ).
+ * - État "half-open" : Période d'évaluation après un délai de récupération
+ *   (cooldown) avec injection de requêtes sondes.
+ * - Calcul en continu du score de santé (Health Score 0-100%).
+ */
+export type CircuitState = "closed" | "open" | "half-open";
+export interface CircuitBreakerConfig {
+    /** Nombre d'échecs consécutifs avant ouverture du coupe-circuit (défaut: 5) */
+    failureThreshold?: number;
+    /** Durée en millisecondes avant passage en état half-open (défaut: 30 000 ms) */
+    recoveryTimeoutMs?: number;
+    /** Nombre de succès requis en mode half-open pour rétablir (défaut: 2) */
+    halfOpenSuccessThreshold?: number;
+}
+export interface DestinationHealthMetrics {
+    destinationId: string;
+    state: CircuitState;
+    healthScore: number;
+    consecutiveFailures: number;
+    totalCalls: number;
+    successCalls: number;
+    failedCalls: number;
+    lastStateChange: string;
+    lastFailureReason?: string;
+}
+export declare class DestinationCircuitBreaker {
+    private readonly destinationId;
+    private readonly failureThreshold;
+    private readonly recoveryTimeoutMs;
+    private readonly halfOpenSuccessThreshold;
+    private state;
+    private consecutiveFailures;
+    private consecutiveSuccesses;
+    private totalCalls;
+    private successCalls;
+    private failedCalls;
+    private lastOpenedAt;
+    private lastStateChange;
+    private lastFailureReason?;
+    constructor(destinationId: string, config?: CircuitBreakerConfig);
+    /**
+     * Vérifie si le circuit permet l'envoi d'une requête vers la destination.
+     */
+    canExecute(): boolean;
+    /**
+     * Enregistre un succès de distribution.
+     */
+    recordSuccess(): void;
+    /**
+     * Enregistre un échec de distribution.
+     */
+    recordFailure(reason?: string): void;
+    private transitionTo;
+    getMetrics(): DestinationHealthMetrics;
+    reset(): void;
+}