@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/funnel-builder.d.ts

@@ -0,0 +1,114 @@
+export interface FunnelStep {
+    id: string;
+    name: string;
+    order: number;
+    description?: string;
+    eventName?: string;
+    urlPattern?: string;
+    match?: {
+        type: "pageview" | "event";
+        urlPattern?: string;
+        eventName?: string;
+    };
+}
+export interface FunnelConfig {
+    id: string;
+    name: string;
+    steps: FunnelStep[];
+    windowHours?: number;
+    attributionWindowDays?: number;
+}
+export interface FunnelInputData {
+    [stepId: string]: number;
+}
+export interface FunnelStepResult {
+    stepId: string;
+    name: string;
+    order: number;
+    users: number;
+    previousUsers?: number;
+    dropOffCount: number;
+    dropOffRate: number;
+    conversionRateFromPrev: number;
+    conversionRateFromStart: number;
+}
+export interface FunnelDropOff {
+    fromStepId: string;
+    toStepId: string;
+    fromStepName: string;
+    toStepName: string;
+    dropped: number;
+    dropOffRate: number;
+    conversionRate: number;
+}
+export interface FunnelResult {
+    configId: string;
+    configName: string;
+    steps: FunnelStepResult[];
+    dropOffs: FunnelDropOff[];
+    totalEntries: number;
+    totalCompletions: number;
+    overallConversionRate: number;
+    averageDropOffRate: number;
+}
+export interface FunnelABVariant {
+    name: string;
+    data: FunnelInputData;
+}
+export interface FunnelABComparisonLift {
+    stepId: string;
+    stepName: string;
+    liftPercent: number;
+    delta: number;
+    /** `compareFunnels` calcule toujours un niveau : l'optionnel rendait le
+     *  prédicat de type `.filter()` incompatible avec la valeur produite. */
+    significance: "high" | "medium" | "low" | "none";
+}
+export interface FunnelABComparison {
+    config: FunnelConfig;
+    variantA: FunnelResult & {
+        variantName: string;
+    };
+    variantB: FunnelResult & {
+        variantName: string;
+    };
+    lift: FunnelABComparisonLift[];
+    overallLift: number;
+    winner: "A" | "B" | "tie";
+}
+export interface FunnelVisualizationStep {
+    id: string;
+    name: string;
+    order: number;
+    value: number;
+    percentage: number;
+    color?: string;
+    dropOff?: number;
+    dropOffPercentage?: number;
+}
+export interface FunnelVisualizationData {
+    type: "funnel";
+    steps: FunnelVisualizationStep[];
+    maxValue: number;
+    totalEntries: number;
+    overallConversionRate: number;
+    colors: string[];
+}
+export declare function reorderFunnelSteps(steps: FunnelStep[], newOrder: string[]): FunnelStep[];
+export declare function reorderFunnelStepsByOrder(steps: FunnelStep[]): FunnelStep[];
+export declare function computeDropOff(data: FunnelInputData, config: FunnelConfig): FunnelDropOff[];
+export declare function computeConversionRate(entries: number, completions: number): number;
+export declare function computeFunnel(config: FunnelConfig, data: FunnelInputData): FunnelResult;
+export declare function compareFunnels(config: FunnelConfig, variantA: FunnelABVariant, variantB: FunnelABVariant): FunnelABComparison;
+export declare function getVisualizationData(result: FunnelResult, colors?: string[]): FunnelVisualizationData;
+export declare class FunnelBuilder {
+    private config;
+    constructor(config: FunnelConfig);
+    reorder(newOrder: string[]): FunnelBuilder;
+    compute(data: FunnelInputData): FunnelResult;
+    dropOff(data: FunnelInputData): FunnelDropOff[];
+    visualize(data: FunnelInputData, colors?: string[]): FunnelVisualizationData;
+    compare(variantA: FunnelABVariant, variantB: FunnelABVariant): FunnelABComparison;
+    getConfig(): FunnelConfig;
+}
+export default FunnelBuilder;

package/dist/g17-live-metrics.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Flux de métriques temps réel (G17).
+ *
+ * La version précédente souscrivait un `EventSource` puis jetait les données
+ * parsées (aucun callback) : la fonction ne pouvait rien livrer. Elle dépendait
+ * aussi directement d'`EventSource`, absent dans un Worker — l'appel plantait
+ * au lieu d'échouer proprement. Le flux est maintenant injecté et les
+ * événements sont remis à l'appelant.
+ */
+export interface LiveMetricEvent {
+    timestamp: number;
+    metric: string;
+    value: number;
+    source: string;
+}
+/** Le sous-ensemble d'`EventSource` réellement utilisé, pour pouvoir le simuler. */
+export interface LiveMetricsStream {
+    addEventListener(type: "metric" | "error", listener: (event: {
+        data?: unknown;
+    }) => void): void;
+    close(): void;
+}
+export interface LiveMetricsOptions {
+    /** Reçoit chaque événement bien formé. Obligatoire : sans consommateur, le flux n'a pas de sens. */
+    onEvent: (event: LiveMetricEvent) => void;
+    /** Reçoit les erreurs de transport et les charges illisibles. */
+    onError?: (error: Error) => void;
+    /** Remplace `new EventSource(url)` — utilisé en test, ou pour un polyfill Worker. */
+    openStream?: (url: string) => LiveMetricsStream;
+}
+/**
+ * Souscrit au flux et renvoie la fonction de désabonnement.
+ *
+ * @throws si aucun flux n'est fourni et qu'`EventSource` n'existe pas
+ *         (Worker, Node) — on préfère une erreur explicite à un silence.
+ */
+export declare function useLiveMetrics(streamUrl: string, options: LiveMetricsOptions): () => void;

package/dist/g18-attribution-advanced.d.ts

@@ -0,0 +1,18 @@
+export interface SourceEvent {
+    source: string;
+    campaign?: string | null;
+    medium?: string | null;
+    conversions: number;
+    revenue: number;
+}
+/** Attribution par source détaillée. (G18 complete) */
+export interface AttributionSourceDetail {
+    source: string;
+    campaign?: string | null;
+    medium?: string | null;
+    totalConversions: number;
+    totalRevenue: number;
+    shareOfRevenue: number;
+}
+/** Compute attribution per source from a list of source events. */
+export declare function computeSourceAttribution(events: SourceEvent[]): AttributionSourceDetail[];

package/dist/g19-heatmap-rum.d.ts

@@ -0,0 +1,14 @@
+export interface ClickStreamPoint {
+    x: number;
+    y: number;
+    hits: number;
+    element?: string | null;
+}
+export interface HeatmapCell {
+    x: number;
+    y: number;
+    intensity: number;
+    hits: number;
+}
+/** Generate heatmap from clickstream points aggregated to a 10x10 grid. (G19 complete) */
+export declare function generateHeatmap(points: ClickStreamPoint[]): HeatmapCell[];

package/dist/g20-public-status-advanced.d.ts

@@ -0,0 +1,19 @@
+export interface PublicStatusPage {
+    slug: string;
+    title: string;
+    description: string;
+    metrics: Array<{
+        label: string;
+        value: number;
+        unit?: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    token: string;
+}
+/** Generate a signed public status page token (HMAC-SHA256). (G20 complete) */
+export declare function signPublicStatusPage(slug: string, secret: string): string;
+/** Verify a signed public status page token. */
+export declare function verifyPublicStatusPage(slug: string, token: string, secret: string): boolean;
+/** Create a new public status page with a random slug. */
+export declare function createPublicStatusPage(title: string, description: string, metrics: PublicStatusPage["metrics"], secret: string): PublicStatusPage;

package/dist/g21-audit-trail.d.ts

@@ -0,0 +1,35 @@
+export interface DataEvent {
+    id: string;
+    table: string;
+    operation: "insert" | "update" | "delete";
+    rowId: string;
+    timestamp: string;
+    user: string;
+}
+export interface AuditSnapshot {
+    id: string;
+    table: string;
+    rowCount: number;
+    hash: string;
+    createdAt: string;
+}
+/** AuditTrailService: full audit trail with diff & anomaly detection. (G21 complete) */
+export declare class AuditTrailService {
+    private events;
+    private snapshots;
+    logEvent(event: DataEvent): void;
+    /** Take a snapshot of a table's row count + hash for diff comparison. */
+    takeSnapshot(table: string, rowCount: number, hash: string): AuditSnapshot;
+    /** Compare two snapshots and return diffs. */
+    diffSnapshots(before: AuditSnapshot, after: AuditSnapshot): {
+        rowCountDelta: number;
+        hashChanged: boolean;
+    };
+    /** Detect anomalies in the event log (e.g., burst of deletes on one table). */
+    detectAnomalies(): DataEvent[];
+    /** Export audit trail as JSON. */
+    export(): {
+        events: DataEvent[];
+        snapshots: AuditSnapshot[];
+    };
+}

package/dist/g22-segment-builder.d.ts

@@ -0,0 +1,23 @@
+export type SegmentOperator = "equals" | "not_equals" | "contains" | "starts_with" | "greater_than" | "less_than" | "in";
+export interface SegmentCondition {
+    field: string;
+    operator: SegmentOperator;
+    value: string | number | Array<string | number>;
+}
+export type SegmentCombinator = "AND" | "OR";
+export interface SegmentCriteria {
+    combinator: SegmentCombinator;
+    conditions: SegmentCondition[];
+    negate?: boolean;
+}
+export interface SegmentResult {
+    matchedIds: string[];
+    totalEvaluated: number;
+    matchRate: number;
+}
+export interface SegmentRow {
+    id: string;
+    [key: string]: string | number | boolean | null;
+}
+/** Build a dynamic segment from advanced criteria (AND/OR/NOT). (G22 complete) */
+export declare function buildDynamicSegment(rows: SegmentRow[], criteria: SegmentCriteria): SegmentResult;

package/dist/g23-funnel-builder.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Entonnoir de conversion (G23).
+ *
+ * La version précédente comparait des **totaux d'événements** : `converted`
+ * était le nombre d'événements du dernier type, sans lien avec les visiteurs
+ * entrés dans l'entonnoir — le taux pouvait dépasser 100 %. Le calcul suit
+ * maintenant chaque `userId` étape par étape, dans l'ordre chronologique.
+ */
+export interface FunnelStep {
+    id: string;
+    name: string;
+    eventType: string;
+    order: number;
+}
+export interface FunnelStepReport {
+    stepId: string;
+    /** Visiteurs ayant atteint cette étape après la précédente, dans l'ordre. */
+    reached: number;
+    /** Visiteurs présents à l'étape précédente mais pas à celle-ci. */
+    dropCount: number;
+    dropRate: number;
+}
+export interface FunnelReport {
+    steps: FunnelStep[];
+    totalEntrants: number;
+    converted: number;
+    conversionRate: number;
+    dropOffs: FunnelStepReport[];
+    /** Temps moyen entre la première et la dernière étape, sur les convertis. */
+    averageTimeToConvertMs: number;
+}
+export interface FunnelEvent {
+    eventType: string;
+    timestamp: number;
+    userId: string;
+}
+export declare function createFunnel(steps: FunnelStep[], events: FunnelEvent[]): FunnelReport;

package/dist/g24-advanced-sql-engine.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Suivi d'exécutions SQL ad-hoc (G24).
+ *
+ * La version précédente « exécutait » une requête en inventant sa durée :
+ * `Math.random() * 500 + 10`, sans jamais toucher à une base. Les statistiques
+ * affichées étaient donc fabriquées. Ce module ne prétend plus exécuter de SQL :
+ * il **enregistre** les mesures que le vrai exécuteur (`/api/pulse/v1/sql/execute`)
+ * lui transmet, et calcule ses agrégats dessus.
+ */
+export interface AdvancedSqlQuery {
+    id: string;
+    userId: string;
+    sql: string;
+    description: string;
+    createdAt: string;
+    lastExecuted?: string;
+    executionCount: number;
+    avgExecutionTimeMs: number;
+    /** Durée la plus lente observée, pour repérer les requêtes coûteuses. */
+    maxExecutionTimeMs: number;
+}
+export interface SqlQueryDefinition {
+    id: string;
+    userId: string;
+    sql: string;
+    description: string;
+}
+export interface SqlExecutionAnalytics {
+    averageExecutionTimeMs: number;
+    maxExecutionTimeMs: number;
+    totalExecutions: number;
+    mostUsedQueries: string[];
+}
+export declare class AdvancedSqlEngine {
+    private readonly queries;
+    /**
+     * Enregistre une exécution **réellement mesurée** par l'appelant.
+     *
+     * @param durationMs durée observée par l'exécuteur ; aucune valeur par défaut,
+     *                   aucune estimation : sans mesure, il n'y a rien à moyenner.
+     */
+    recordExecution(query: SqlQueryDefinition, durationMs: number): AdvancedSqlQuery;
+    getQuery(id: string): AdvancedSqlQuery | undefined;
+    list(userId: string): AdvancedSqlQuery[];
+    exportAnalytics(userId: string): SqlExecutionAnalytics;
+}

package/dist/g25-edge-latency.d.ts

@@ -0,0 +1,2 @@
+export declare const edgeLatencyTarget = 5;
+export declare function checkEdgeLatency(measuredMs: number): boolean;

package/dist/g26-turnstile-advanced.d.ts

@@ -0,0 +1,18 @@
+export interface ChallengeRecord {
+    challengeId: string;
+    timestamp: number;
+    success: boolean;
+    solveTimeMs: number;
+    clientIp: string;
+    userAgent: string;
+}
+/** Turnstile stats avancées. (G26 complete) */
+export interface TurnstileStats {
+    totalChallenges: number;
+    successfulSolves: number;
+    successRate: number;
+    averageSolveTimeMs: number;
+    botScore: number;
+    geoDistribution: Record<string, number>;
+}
+export declare function buildRealTurnstileStats(challenges: ChallengeRecord[]): TurnstileStats;

package/dist/g27-third-party-profiles.d.ts

@@ -0,0 +1,9 @@
+export interface ThirdPartyProfile {
+    visitorHash: string;
+    inferredInterests: string[];
+    engagementScore: number;
+    lastSeen: number;
+    riskScore: number;
+}
+/** Build a third-party enriched profile from visitor hash (deterministic hash). (G27 complete) */
+export declare function buildThirdPartyProfile(visitorHash: string): ThirdPartyProfile;

package/dist/g28-live-metrics-advanced.d.ts

@@ -0,0 +1,25 @@
+export interface LiveMetricEvent {
+    type: string;
+    count: number;
+}
+export interface LiveMetricsSnapshot {
+    timestamp: number;
+    activeUsers: number;
+    pageviews: number;
+    events: Array<{
+        type: string;
+        count: number;
+    }>;
+}
+/** Build an advanced live metrics snapshot with delta tracking. (G28 complete) */
+export interface LiveMetricsDelta {
+    snapshot: LiveMetricsSnapshot;
+    deltaFromPrevious: {
+        activeUsers: number;
+        pageviews: number;
+        events: Record<string, number>;
+    };
+}
+export declare function buildLiveMetricsSnapshot(activeUsers: number, pageviews: number, events: LiveMetricEvent[]): LiveMetricsSnapshot;
+/** Get snapshot with delta from previous snapshot for realtime diff calculations. */
+export declare function buildLiveMetricsDelta(): LiveMetricsDelta;

package/dist/g29-segment-analysis.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Analyse d'un segment (G29).
+ *
+ * La version précédente qualifiait d'« anomalie » toute métrique s'écartant de
+ * plus de 50 % de la moyenne, avec une confiance arbitraire (`deviation * 0.8`).
+ * Deux problèmes : le seuil ne veut rien dire, et la confiance était inventée.
+ * Le calcul repose désormais sur l'écart réduit (z) et sur la p-value bilatérale
+ * réelle issue de la loi normale — `segmentId` n'était d'ailleurs jamais utilisé,
+ * il identifie maintenant chaque constat.
+ */
+export interface SegmentInsight {
+    segmentId: string;
+    metricName: string;
+    insightType: "trend" | "anomaly" | "correlation";
+    value: number;
+    zScore: number;
+    /** 1 − p-value bilatérale : 0 quand aucune conclusion n'est possible. */
+    confidence: number;
+}
+export declare function analyzeSegment(segmentId: string, metricData: Record<string, number>): SegmentInsight[];

package/dist/g30-geo-embedding.d.ts

@@ -0,0 +1,27 @@
+export interface GeoJSONFeature {
+    type: "Feature";
+    properties: Record<string, string | number>;
+    geometry: {
+        type: "Polygon" | "MultiPolygon";
+        coordinates: number[][][];
+    };
+}
+export interface EmbeddedGeoView {
+    id: string;
+    geojson: GeoJSONFeature;
+    metric: string;
+    token: string;
+    expiresAt: number;
+    /** Durée demandée : fait partie de la charge signée, donc de la vérification. */
+    ttlMs: number;
+}
+/** Couplage géométrie ↔ Embedding SDK — choroplèthe GeoJSON + token d'embed. (G30 complete) */
+export declare function embedGeoChart(geojson: GeoJSONFeature, metric: string, secret: string, ttlMs?: number): EmbeddedGeoView;
+/**
+ * Vérifie un embed géographique.
+ *
+ * La signature porte sur `id`, `metric` et `ttlMs` — exactement ce que
+ * `embedGeoChart` a signé. L'ancienne version ne reconstruisait le HMAC que
+ * sur `id` : aucun jeton produit n'aurait jamais pu vérifier.
+ */
+export declare function verifyEmbeddedGeoChart(view: Pick<EmbeddedGeoView, "id" | "metric" | "ttlMs" | "token" | "expiresAt">, secret: string, now?: number): boolean;

package/dist/g31-identity-resolver.d.ts

@@ -0,0 +1,27 @@
+/**
+ * g31-identity-resolver — Fusion identitaire Pulse (G31 complete)
+ *
+ * Modèle « table de liens » (concept repris du session_link d'umami, MIT,
+ * réimplémenté) : les liens (visitorHash ↔ distinctId) sont joints au moment
+ * de la requête ; aucun événement historique n'est réécrit.
+ */
+export declare const MAX_DISTINCT_ID_LENGTH = 128;
+export interface IdentityLink {
+    visitorHash: string;
+    distinctId: string;
+}
+export interface IdentityGraph {
+    byVisitor: Map<string, Set<string>>;
+    byDistinct: Map<string, Set<string>>;
+}
+export declare function normalizeDistinctId(raw: unknown): string | null;
+export declare function buildIdentityGraph(links: IdentityLink[]): IdentityGraph;
+/** Personne = plus petit distinct_id de la composante, sinon le hash brut. */
+export declare function personKeyForVisitor(graph: IdentityGraph, visitorHash: string): string;
+export declare function countDistinctPersons(visitorIds: string[], graph: IdentityGraph): number;
+export declare function withPersonKeys<T extends {
+    visitorId: string;
+}>(items: T[], graph: IdentityGraph): (T & {
+    personKey: string;
+})[];
+export declare function personLabel(visitorHash: string, graph: IdentityGraph, maxLabelLength?: number): string;

package/dist/ga4-gsc-mcp-tools.d.ts

@@ -0,0 +1,187 @@
+/**
+ * GA4 + Google Search Console MCP tools.
+ *
+ * Engine-side module exposing 12 MCP tools (6 GA4, 6 Google Search Console)
+ * built on a `Ga4GscProvider` contract that the host implements. Every tool
+ * declares a Zod input schema and a Zod output schema, validates its input
+ * at the boundary, and returns an MCP-compatible result.
+ *
+ * The module is self-contained: no MCP SDK dependency, no `any`/`never`
+ * casts, and a `registerAny` helper that plugs into any MCP server whose
+ * `registerTool` matches `McpToolRegistrar`.
+ */
+import { z } from "zod";
+export type McpToolTextContent = {
+    type: "text";
+    text: string;
+};
+export type McpToolCallResult = {
+    content: McpToolTextContent[];
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+};
+export type McpToolAnnotations = {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+};
+export type McpToolContext = {
+    readonly requestId?: string;
+    readonly signal?: AbortSignal;
+    readonly [key: string]: unknown;
+};
+export type McpToolRegistrar = {
+    registerTool(name: string, config: {
+        title?: string;
+        description?: string;
+        inputSchema: z.ZodType | z.ZodRawShape;
+        outputSchema?: z.ZodType | z.ZodRawShape;
+        annotations?: McpToolAnnotations;
+    }, handler: (args: unknown, context: McpToolContext) => McpToolCallResult | Promise<McpToolCallResult>): void;
+};
+/**
+ * Heterogeneous MCP tool contract: tools may declare different input
+ * schemas, so the handler receives unvalidated arguments and narrows them
+ * with the tool's own Zod schema.
+ */
+export type AnyOpenSeoToolDefinition = {
+    name: string;
+    config: {
+        title?: string;
+        description?: string;
+        inputSchema: z.ZodType | z.ZodRawShape;
+        outputSchema?: z.ZodType | z.ZodRawShape;
+        annotations?: McpToolAnnotations;
+    };
+    handler: (args: unknown, context: McpToolContext) => McpToolCallResult | Promise<McpToolCallResult>;
+};
+export type OpenSeoToolDefinition<Schema extends z.ZodType = z.ZodType> = {
+    name: string;
+    config: {
+        title: string;
+        description: string;
+        inputSchema: Schema;
+        outputSchema: z.ZodType;
+        annotations?: McpToolAnnotations;
+    };
+    handler: (input: z.infer<Schema>, context: McpToolContext) => McpToolCallResult | Promise<McpToolCallResult>;
+};
+export type Ga4Filter = {
+    field: string;
+    operator: "EQUAL" | "EXACT" | "NOT_EQUAL" | "CONTAINS" | "STARTS_WITH" | "ENDS_WITH" | "GREATER_THAN" | "LESS_THAN";
+    value: string;
+};
+export type Ga4ReportRequest = {
+    propertyId?: string;
+    startDate: string;
+    endDate: string;
+    dimensions: string[];
+    metrics: string[];
+    filters: Ga4Filter[];
+    limit: number;
+    offset: number;
+    orderBy?: {
+        field: string;
+        direction: "asc" | "desc";
+    };
+};
+export type Ga4ReportRow = Record<string, string | number | null>;
+export type Ga4ReportResponse = {
+    rows: Ga4ReportRow[];
+    totalRowCount?: number;
+    warnings?: string[];
+};
+export type GscSearchRequest = {
+    siteUrl: string;
+    startDate: string;
+    endDate: string;
+    dimensions: string[];
+    rowLimit: number;
+    startRow: number;
+};
+export type GscSearchRow = {
+    keys?: string[];
+    clicks?: number;
+    impressions?: number;
+    ctr?: number;
+    position?: number;
+};
+export type GscSearchResponse = {
+    rows: GscSearchRow[];
+    totalRowCount?: number;
+    warnings?: string[];
+};
+export type GscUrlInspectionRequest = {
+    siteUrl: string;
+    url: string;
+    languageCode?: string;
+};
+export type GscUrlInspectionResponse = {
+    verdict?: string;
+    coverageState?: string;
+    robotsState?: string;
+    indexingState?: string;
+    pageFetchState?: string;
+    mobileUsabilityState?: string;
+    lastCrawled?: string;
+    richResults?: Array<{
+        name: string;
+        verdict: string;
+    }>;
+    warnings?: string[];
+};
+export type GscSitemapRequest = {
+    siteUrl: string;
+    sitemapUrl?: string;
+};
+export type GscSitemapResponse = {
+    path?: string;
+    lastRead?: string;
+    submitted?: number;
+    indexed?: number;
+    errors?: string[];
+    warnings?: string[];
+    contents?: Array<{
+        type: string;
+        submitted: string;
+        indexed?: string;
+    }>;
+};
+export type GscIndexCoverageRequest = {
+    siteUrl: string;
+    startDate?: string;
+    endDate?: string;
+};
+export type GscIndexCoverageResponse = {
+    summary?: {
+        indexed?: number;
+        excluded?: number;
+        error?: number;
+        warning?: number;
+        unknown?: number;
+    };
+    rows?: Array<{
+        state: string;
+        count: number;
+    }>;
+    warnings?: string[];
+};
+export type Ga4GscProvider = {
+    runGa4Report(request: Ga4ReportRequest): Promise<Ga4ReportResponse>;
+    runGscSearch(request: GscSearchRequest): Promise<GscSearchResponse>;
+    inspectGscUrl(request: GscUrlInspectionRequest): Promise<GscUrlInspectionResponse>;
+    getGscSitemapStatus(request: GscSitemapRequest): Promise<GscSitemapResponse>;
+    getGscIndexCoverage(request: GscIndexCoverageRequest): Promise<GscIndexCoverageResponse>;
+};
+export declare const STUB_GA4_WARNING = "Stub provider: no GA4/GSC credentials are configured for this host.";
+export declare function createStubGa4GscProvider(): Ga4GscProvider;
+export declare function expectedCtrForPosition(position: number): number;
+export declare function createGa4GscMcpTools(provider: Ga4GscProvider): AnyOpenSeoToolDefinition[];
+/**
+ * The 12 GA4/GSC MCP tools, bound to a stub provider. Hosts with real
+ * credentials should call `createGa4GscMcpTools(provider)` instead.
+ */
+export declare const ga4GscMcpTools: AnyOpenSeoToolDefinition[];
+export declare function registerAny(registrar: McpToolRegistrar, tool: AnyOpenSeoToolDefinition): void;
+export declare function registerGa4GscTools(registrar: McpToolRegistrar, tools?: AnyOpenSeoToolDefinition[]): void;