@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/destinations/destination-erasure-cascade.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Destination Erasure Cascade — RudderStack GDPR/CCPA User Suppression Parity
+ *
+ * Orchestre la suppression des données utilisateur (Droit à l'oubli / RGPD Art 17)
+ * en cascade vers les destinations avales connectées (Meta CAPI, Google Customer Match,
+ * TikTok Marketing API) ainsi que le stockage analytique interne.
+ */
+export interface ErasureSubjectIdentity {
+    userId?: string;
+    email?: string;
+    phone?: string;
+    externalId?: string;
+    ip?: string;
+}
+export interface ErasureDestinationConfig {
+    destinationId: string;
+    platform: "meta" | "google" | "tiktok" | "internal_warehouse" | "webhook";
+    endpointUrl?: string;
+    apiToken?: string;
+    pixelId?: string;
+    accountId?: string;
+}
+export interface DestinationErasureResult {
+    destinationId: string;
+    platform: string;
+    status: "success" | "skipped" | "failed";
+    receiptId?: string;
+    error?: string;
+    notifiedAt: string;
+}
+export interface ErasureAuditCertificate {
+    certificateId: string;
+    requestedAt: string;
+    subjectHash: string;
+    identitiesSuppressed: {
+        hasUserId: boolean;
+        hasEmail: boolean;
+        hasPhone: boolean;
+        hasExternalId: boolean;
+    };
+    destinations: DestinationErasureResult[];
+    overallStatus: "completed" | "partially_failed";
+    expiresAt: string;
+}
+export declare class DestinationErasureCascade {
+    /**
+     * Normalise et hache un email en SHA-256 selon les standards publicitaires (Meta, Google, TikTok).
+     */
+    static hashEmail(email: string): string;
+    /**
+     * Normalise et hache un numéro de téléphone en SHA-256 (format E.164 sans espaces ni symboles).
+     */
+    static hashPhone(phone: string): string;
+    /**
+     * Formate la requête de suppression spécifique à la plateforme publicitaire.
+     */
+    static buildPlatformPayload(platform: ErasureDestinationConfig["platform"], identity: ErasureSubjectIdentity): Record<string, unknown>;
+    /**
+     * Exécute la cascade de suppression sur l'ensemble des destinations configurées.
+     */
+    static executeCascade(identity: ErasureSubjectIdentity, destinations: ErasureDestinationConfig[], customDispatcher?: (dest: ErasureDestinationConfig, payload: Record<string, unknown>) => Promise<{
+        success: boolean;
+        receiptId?: string;
+        error?: string;
+    }>): Promise<ErasureAuditCertificate>;
+}

package/dist/destinations/destination-router.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Multi-Destination Fan-Out Router — RudderStack Parity
+ * (Isolated Parallel Dispatch & Circuit Breaking)
+ *
+ * Route et distribue chaque événement entrant vers de multiples destinations en parallèle
+ * (Conversions API, Data Lakes, Webhooks) avec isolation stricte :
+ * - Aucune destination lente ou en panne ne peut ralentir ou bloquer les autres.
+ * - Exécution concurrente via Promise.allSettled avec mesure précise de latence par destination.
+ * - Synthèse unifiée des résultats de livraison pour le monitoring et la Dead Letter Queue.
+ */
+export type DestinationDispatchOutcome = "sent" | "failed" | "skipped";
+export interface DestinationDispatchResult {
+    destinationId: string;
+    status: DestinationDispatchOutcome;
+    detail?: string;
+    durationMs: number;
+}
+export type DestinationHandler = (event: Record<string, unknown>) => Promise<{
+    status: DestinationDispatchOutcome;
+    detail?: string;
+}>;
+export interface RegisteredDestination {
+    id: string;
+    name: string;
+    enabled: boolean;
+    handler: DestinationHandler;
+}
+export interface RouterDispatchSummary {
+    eventId: string;
+    totalDestinations: number;
+    deliveredCount: number;
+    failedCount: number;
+    skippedCount: number;
+    outcomes: DestinationDispatchResult[];
+}
+export declare class DestinationRouter {
+    private readonly destinations;
+    register(destination: RegisteredDestination): void;
+    unregister(destinationId: string): boolean;
+    getDestinations(): RegisteredDestination[];
+    /**
+     * Distribue un événement vers toutes les destinations actives en parallèle isolé.
+     */
+    dispatch(event: Record<string, unknown>): Promise<RouterDispatchSummary>;
+}

package/dist/destinations/object-storage.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Object Storage & Data Lake Destination — RudderStack Parity
+ * (S3 / Cloudflare R2 / MinIO / Google Cloud Storage)
+ *
+ * Formate et partitionne des flux d'événements pour l'archivage ou l'interrogation
+ * directe par des moteurs OLAP (DuckDB, ClickHouse, BigQuery External Tables, AWS Athena).
+ *
+ * Fonctionnalités :
+ * - Partitionnement standardisé type Hive : `prefix/year=YYYY/month=MM/day=DD/hour=HH/`
+ * - Formatage en NDJSON (Newline Delimited JSON) ou JSON Array
+ * - Calcul précis des métriques (taille en octets, nombre d'enregistrements, clé d'idempotence)
+ */
+export type ObjectStorageProvider = "s3" | "r2" | "gcs" | "minio";
+export type PartitionGranularity = "hourly" | "daily";
+export type DataLakeFileFormat = "jsonl" | "json";
+export interface ObjectStorageConfig {
+    bucket: string;
+    provider?: ObjectStorageProvider;
+    prefix?: string;
+    region?: string;
+    partitionGranularity?: PartitionGranularity;
+    format?: DataLakeFileFormat;
+}
+export interface ObjectStorageBatch {
+    bucket: string;
+    key: string;
+    content: string;
+    recordCount: number;
+    byteSize: number;
+    format: DataLakeFileFormat;
+    partition: string;
+}
+/**
+ * Génère une clé d'objet partitionnée type Hive (ex: prefix/year=2026/month=10/day=24/hour=18/)
+ */
+export declare function generatePartitionKey(timestamp: Date, config: ObjectStorageConfig, fileId?: string): {
+    partitionDir: string;
+    fullKey: string;
+};
+/**
+ * Formate un lot d'événements pour le stockage objet S3/R2/GCS.
+ */
+export declare function formatObjectStorageBatch(events: Array<Record<string, unknown>>, config: ObjectStorageConfig, timestamp?: Date, fileId?: string): ObjectStorageBatch;

package/dist/destinations/warehouse-schema-generator.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Data Warehouse Relational Schema Generator & Columnar Exporter
+ *
+ * Inspiré du moteur d'auto-sync et de gouvernance de RudderStack & PostHog.
+ * Transforme les flux d'événements JSON non-structurés en schémas relationnels stricts
+ * et génère le DDL (CREATE TABLE, ALTER TABLE ADD COLUMN) pour :
+ * - ClickHouse
+ * - PostgreSQL / Hyperdrive
+ * - Google BigQuery
+ * - Snowflake
+ */
+export type WarehouseDialect = "clickhouse" | "postgres" | "bigquery" | "snowflake";
+export type ColumnType = "string" | "int64" | "float64" | "boolean" | "timestamp" | "json";
+export interface ColumnDefinition {
+    name: string;
+    type: ColumnType;
+    nullable: boolean;
+    isPrimaryKey?: boolean;
+}
+export interface TableSchema {
+    tableName: string;
+    columns: Record<string, ColumnDefinition>;
+}
+export interface WarehouseBatchRow {
+    [columnName: string]: string | number | boolean | null;
+}
+export declare class WarehouseSchemaGenerator {
+    /**
+     * Mots réservés SQL courants à sécuriser pour éviter les conflits d'identifiants.
+     */
+    private static readonly RESERVED_WORDS;
+    /**
+     * Assainit un identifiant de colonne SQL (snake_case, [a-z0-9_], pas de mot réservé).
+     */
+    static sanitizeIdentifier(raw: string): string;
+    /**
+     * Détecte le type relationnel le plus approprié pour une valeur.
+     */
+    static inferColumnType(val: unknown): ColumnType;
+    /**
+     * Aplatit un objet JSON imbriqué en paires clé-valeur de niveau supérieur (snake_case).
+     */
+    static flattenObject(obj: Record<string, unknown>, prefix?: string): Record<string, unknown>;
+    /**
+     * Déduit ou met à jour un schéma relationnel de table à partir d'un ensemble d'événements bruts.
+     */
+    static inferSchema(tableName: string, events: Array<Record<string, unknown>>, existingSchema?: TableSchema): TableSchema;
+    /**
+     * Génère l'instruction CREATE TABLE pour le dialecte cible.
+     */
+    static generateCreateTableDDL(schema: TableSchema, dialect: WarehouseDialect): string;
+    /**
+     * Détecte les colonnes manquantes et génère les ALTER TABLE ADD COLUMN.
+     */
+    static generateAlterTableDDL(currentSchema: TableSchema, incomingSchema: TableSchema, dialect: WarehouseDialect): string[];
+    /**
+     * Formate un tableau d'événements en lignes relationnelles plates prêtes à l'insertion.
+     */
+    static formatBatchRows(events: Array<Record<string, unknown>>, schema: TableSchema): WarehouseBatchRow[];
+    private static sqlType;
+}

package/dist/device-detection.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Devices Detection — Matomo Plugin "DevicesDetection"
+ *
+ * Détecte le type d'appareil, la marque, le modèle, l'OS, le navigateur et la
+ * résolution d'écran depuis l'User-Agent et les hints client.
+ */
+export interface DeviceInfo {
+    type: "desktop" | "mobile" | "tablet" | "bot" | "unknown";
+    brand?: string;
+    model?: string;
+    osName?: string;
+    osVersion?: string;
+    browserName?: string;
+    browserVersion?: string;
+    engine?: string;
+    engineVersion?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isBot: boolean;
+    userAgent: string;
+}
+export interface DeviceDetectionResult {
+    device: DeviceInfo;
+    confidence: number;
+}
+/**
+ * Détecteur d'appareils basé sur l'User-Agent (port JS léger, sans dépendance externe).
+ * Couvre les cas courants : mobile, tablet, desktop, bot.
+ */
+export declare class DeviceDetector {
+    private userAgent;
+    constructor(userAgent: string);
+    detect(): DeviceDetectionResult;
+    private detectBrand;
+    private detectModel;
+    private detectOSName;
+    private detectOSVersion;
+    private detectBrowserName;
+    private detectBrowserVersion;
+    private detectEngine;
+    private detectEngineVersion;
+}
+/**
+ * Détecte un appareil depuis une chaîne User-Agent.
+ */
+export declare function detectDevice(userAgent: string, screenWidth?: number, screenHeight?: number): DeviceInfo;
+export declare const deviceDetector: DeviceDetector;

package/dist/documents-transforms.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Declarative record transforms (the Metabase "transforms" analogue).
+ *
+ * A transform is a named, ordered list of steps applied to an object or an
+ * array of objects. Steps are strings so they can be stored in a database and
+ * edited without a code deploy:
+ *
+ *  - `pick:a,b`        keep only these fields
+ *  - `omit:a,b`        drop these fields
+ *  - `rename:a->b`     rename a field
+ *  - `map:a=value`     set a field to a literal string
+ *  - `filter:a=value`  keep only records whose field equals the literal
+ *  - `limit:10`        keep the first N records
+ *
+ * Unknown or malformed steps fail explicitly: a transform that silently did
+ * nothing would hand the caller data it believes was reshaped.
+ */
+import { z } from "zod";
+export interface DocumentTransform {
+    id: string;
+    name: string;
+    inputType: string;
+    outputType: string;
+    steps: string[];
+    enabled: boolean;
+}
+export declare const DocumentTransformSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    inputType: z.ZodString;
+    outputType: z.ZodString;
+    steps: z.ZodArray<z.ZodString>;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export interface TransformResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+}
+export declare function runTransform(def: DocumentTransform, input: unknown): TransformResult;
+export declare function findTransform(list: DocumentTransform[], id: string): DocumentTransform | undefined;

package/dist/domain-heritage-checker.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 🗝️ Expired-Domain Heritage Check
+ *
+ * Flags whether a domain feels like a revived expired domain — a common
+ * scaled-content/parasite-SEO smell under Google's 2026 policies (site-quality
+ * §4.6.7 pattern: old domain, mismatched topical fingerprint, sudden commercial
+ * skew). Returns a risk verdict plus the signals that triggered it.
+ */
+export interface DomainHeritageInput {
+    /** Domain age in years. */
+    domainAgeYears: number;
+    /** Whether historical/web-archive fingerprints point to a different vertical. */
+    topicalMismatch: boolean;
+    /** 0-1 share of content that is commercial/high-intent (vs informational). */
+    commercialSkew: number;
+    /** Whether the domain fell to an expired/auction state (e.g. DNS drop) recently. */
+    recentlyExpired: boolean;
+    /** Dates (year) of first and most recent indexed content. */
+    firstContentYear?: number;
+    lastContentYear?: number;
+    /** Whether there was an abrupt authorship change. */
+    authorChange: boolean;
+}
+export interface DomainHeritageResult {
+    risk: "high" | "medium" | "low";
+    riskScore: number;
+    flags: Array<{
+        code: "DOMAIN_OLD_TOPIC_MISMATCH" | "ABRUPT_AUTHORSHIP_CHANGE" | "COMMERCIAL_SKEW" | "RECENT_EXPIRY" | "CONTENT_AGE_GAP";
+        severity: "critical" | "warning" | "info";
+        message: string;
+    }>;
+    conclusion: string;
+}
+/**
+ * Heuristic risk model for expired-domain footprint. Only returns "high" risk
+ * when multiple corroborating signals align — a single fact is never enough to
+ * accuse a legitimate business.
+ */
+export declare class DomainHeritageChecker {
+    static assess(input: DomainHeritageInput): DomainHeritageResult;
+}

package/dist/domain-telemetry.d.ts

@@ -0,0 +1,101 @@
+/**
+ * 🦁 LynxSEO Engine — Domain & Digital Traffic Telemetry Engine (v3.2.0)
+ *
+ * Provides live server IP resolution via Cloudflare DNS-over-HTTPS (DoH),
+ * Similarweb-calibrated multi-channel traffic distribution, AI search referral telemetry,
+ * and 12-month historical visibility trends.
+ */
+export interface ServerHostInfo {
+    ip: string;
+    cdn: string;
+    status: number;
+}
+export interface TrafficChannelMix {
+    search: number;
+    direct: number;
+    social: number;
+    referral: number;
+}
+export interface AiTrafficSources {
+    chatgpt: number;
+    perplexity: number;
+    claude: number;
+    copilot: number;
+}
+export interface SimilarwebTelemetry {
+    globalRank: string;
+    countryRank: string;
+    category: string;
+    totalVisits: string;
+    bounceRate: string;
+    pagesPerVisit: string;
+    avgDuration: string;
+    trafficSources: TrafficChannelMix;
+    aiTrafficSources: AiTrafficSources;
+}
+export interface MonthlyHistoryPoint {
+    date: string;
+    vi: number;
+    top3: number;
+    top10: number;
+    top50: number;
+    top100: number;
+    indexedPages: number;
+}
+export interface DomainMetricsPayload {
+    success: boolean;
+    domain: string;
+    rootDomain: string;
+    server: ServerHostInfo;
+    similarweb: SimilarwebTelemetry;
+    metrics_url: {
+        top_100_positions: number;
+        traffic_estimate: number;
+        traffic_value: number;
+    };
+    metrics_sd: {
+        visibility_index: number;
+        top_100_positions: number;
+        active_page_count: number;
+        traffic_estimate: number;
+        traffic_value: number;
+        authority_score: number;
+        referring_domains: number;
+        backlinks: number;
+        dofollow_ratio: number;
+    };
+    metrics_root: {
+        visibility_index: number;
+        top_100_positions: number;
+        active_page_count: number;
+        traffic_estimate: number;
+        traffic_value: number;
+        authority_score: number;
+        referring_domains: number;
+        backlinks: number;
+        dofollow_ratio: number;
+    };
+    history_sd: MonthlyHistoryPoint[];
+    history_root: MonthlyHistoryPoint[];
+}
+export declare class DomainTelemetryEngine {
+    /**
+     * Resolves the real IPv4 address and CDN infrastructure using Cloudflare DoH.
+     */
+    static resolveServerHost(domain: string): Promise<ServerHostInfo>;
+    /**
+     * Estimates Similarweb-grade multi-channel acquisition mix and AI search engine referrals.
+     */
+    static calculateChannelMix(authorityScore: number, rank: number): SimilarwebTelemetry;
+    /**
+     * Generates synthetic 12-month historical visibility and keyword tier distribution.
+     */
+    static generateHistoricalPoints(authorityScore: number): MonthlyHistoryPoint[];
+    /**
+     * Complete domain telemetry pipeline orchestrator.
+     */
+    static resolveDomainTelemetry(domain: string, options?: {
+        authorityScore?: number;
+        rank?: number;
+    }): Promise<DomainMetricsPayload>;
+}

package/dist/dragonfly-client.d.ts

@@ -0,0 +1,221 @@
+/**
+ * 🐉 Dragonfly High-Performance In-Memory Datastore & Cache Client
+ *
+ * Dragonfly is an ultra-fast, multi-threaded, Redis-compatible in-memory store.
+ * This client provides transparent high-throughput caching, atomic rate-limiting,
+ * distributed locking, and session persistence for all LynxSEO modules.
+ *
+ * If Dragonfly is unreachable or not configured, it gracefully falls back
+ * to an internal in-memory store with TTL support, ensuring zero downtime.
+ */
+export interface DragonflyClientOptions {
+    url?: string;
+    prefix?: string;
+    enableFallback?: boolean;
+    maxRetriesPerRequest?: number;
+    connectTimeoutMs?: number;
+}
+export interface LockResult {
+    acquired: boolean;
+    token: string;
+    release: () => Promise<boolean>;
+}
+/**
+ * Stream message entry returned by XREADGROUP / XCLAIM.
+ */
+export interface StreamMessage {
+    stream: string;
+    id: string;
+    fields: Record<string, string>;
+}
+/**
+ * Pending message info returned by XPENDING.
+ */
+export interface StreamPendingMessage {
+    id: string;
+    consumer: string;
+    timeSinceDeliveredMs: number;
+}
+export declare class DragonflyClient {
+    private redis;
+    private prefix;
+    private enableFallback;
+    private memoryStore;
+    private memorySets;
+    private memoryHashes;
+    private isConnected;
+    private static instance;
+    constructor(options?: DragonflyClientOptions);
+    /**
+     * Singleton accessor for global LynxSEO operations.
+     */
+    static getInstance(options?: DragonflyClientOptions): DragonflyClient;
+    /**
+     * Clears the current singleton instance (useful in tests).
+     */
+    static resetInstance(): void;
+    private fullKey;
+    private ensureConnection;
+    /**
+     * Returns true if client is connected and ready to accept Redis commands.
+     */
+    isReady(): boolean;
+    /**
+     * Returns true if a Dragonfly/Redis URL connection is configured.
+     */
+    hasConnection(): boolean;
+    /**
+     * Pings Dragonfly. Returns true if healthy.
+     */
+    ping(): Promise<boolean>;
+    /**
+     * Check if connected to real Dragonfly/Redis server.
+     */
+    isDragonflyReady(): Promise<boolean>;
+    /**
+     * Get parsed JSON or string value.
+     */
+    get<T = string>(key: string): Promise<T | null>;
+    /**
+     * Set key with optional TTL in seconds.
+     */
+    set(key: string, value: any, ttlSeconds?: number): Promise<void>;
+    /**
+     * Delete one or more keys.
+     */
+    del(keys: string | string[], ...moreKeys: string[]): Promise<number>;
+    /**
+     * Check if key exists.
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Atomic increment counter.
+     */
+    incr(key: string, by?: number): Promise<number>;
+    /**
+     * Atomic decrement counter.
+     */
+    decr(key: string, by?: number): Promise<number>;
+    /**
+     * Set TTL in seconds on an existing key.
+     */
+    expire(key: string, seconds: number): Promise<boolean>;
+    /**
+     * Find keys matching glob pattern.
+     */
+    keys(pattern: string): Promise<string[]>;
+    /**
+     * Add members to a set.
+     */
+    sadd(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Remove members from a set.
+     */
+    srem(key: string, ...members: string[]): Promise<number>;
+    /**
+     * Get all members of a set.
+     */
+    smembers(key: string): Promise<string[]>;
+    /**
+     * Hash Set: HSET
+     */
+    hset(key: string, field: string, value: any): Promise<number>;
+    /**
+     * Hash Get: HGET
+     */
+    hget<T = any>(key: string, field: string): Promise<T | null>;
+    /**
+     * Hash GetAll: HGETALL
+     */
+    hgetall<T = Record<string, any>>(key: string): Promise<T | null>;
+    /**
+     * Acquire a distributed lock using Dragonfly atomic SET NX PX.
+     */
+    acquireLock(lockKey: string, ttlSeconds?: number, token?: string): Promise<LockResult>;
+    /**
+     * Release a distributed lock safely using token verification.
+     */
+    releaseLock(lockKey: string, token: string): Promise<boolean>;
+    /**
+     * Flush all keys matching this client prefix.
+     */
+    clear(): Promise<void>;
+    /**
+     * XADD — Ajoute un événement à un stream Redis.
+     * Retourne l'ID du message généré par Redis (ex: "1699000000000-0").
+     *
+     * @param stream   Nom du stream (préfixé automatiquement)
+     * @param fields   Paires champ/valeur à stocker
+     * @param options  MAXLEN optionnel pour limiter la taille du stream
+     */
+    xadd(stream: string, fields: Record<string, string>, options?: {
+        maxLen?: number;
+        approximate?: boolean;
+    }): Promise<string>;
+    /**
+     * XGROUP CREATE — Crée un consumer group sur un stream (idempotent si déjà existant).
+     *
+     * @param stream Nom du stream
+     * @param group  Nom du consumer group
+     * @param id     ID de départ ("0" = depuis le début, "$" = que les nouveaux)
+     */
+    xgroupCreate(stream: string, group: string, id?: string): Promise<void>;
+    /**
+     * XREADGROUP — Lit des messages d'un stream avec consumer group.
+     * Retourne les messages non encore traités ("NEXT" / ">") pour ce consumer.
+     *
+     * @param group     Nom du consumer group
+     * @param consumer  Nom du consumer (identifiant unique de l'instance)
+     * @param streams   Map stream → ">" (nouveaux) ou ID spécifique à relire
+     * @param count     Nombre max de messages à lire (défaut 10)
+     * @param blockMs   Temps de blocage en ms si aucun message (0 = pas d'attente)
+     */
+    xreadgroup(group: string, consumer: string, streams: Record<string, string>, count?: number, blockMs?: number): Promise<StreamMessage[]>;
+    /**
+     * XACK — Accuse réception d'un ou plusieurs messages traités.
+     * Retourne le nombre de messages effectivement Ack.
+     *
+     * @param stream Nom du stream
+     * @param group  Nom du consumer group
+     * @param ids    IDs des messages à accuser
+     */
+    xack(stream: string, group: string, ...ids: string[]): Promise<number>;
+    /**
+     * XPENDING — Récupère les messages en attente (non Ack) pour un consumer group.
+     * Utile pour le retry après crash ou redémarrage.
+     *
+     * @param stream Nom du stream
+     * @param group  Nom du consumer group
+     * @param start  ID de début ("-" = début)
+     * @param end    ID de fin ("+" = fin)
+     * @param count  Nombre max de messages à retourner
+     */
+    xpending(stream: string, group: string, start?: string, end?: string, count?: number): Promise<StreamPendingMessage[]>;
+    /**
+     * XCLAIM — Ré-assigne des messages pendants à un consumer pour retry.
+     *
+     * @param stream          Nom du stream
+     * @param group           Nom du consumer group
+     * @param consumer        Nom du consumer qui reprend les messages
+     * @param minIdleTimeMs   Temps d'inactivité minimum avant ré-assignation (ms)
+     * @param ids             IDs des messages à ré-assigner
+     */
+    xclaim(stream: string, group: string, consumer: string, minIdleTimeMs: number, ids: string[]): Promise<StreamMessage[]>;
+    private memoryStreamsMap;
+    private memoryGroupsSet;
+    private getMemoryStreams;
+    private getMemoryGroups;
+    private memoryXreadgroup;
+    /**
+     * Normalise le résultat de ioredis xreadgroup en tableau de StreamMessage.
+     */
+    private parseXreadgroupResult;
+    /**
+     * Normalise le résultat de ioredis xclaim en tableau de StreamMessage.
+     */
+    private parseXclaimResult;
+    /**
+     * Disconnect cleanly.
+     */
+    disconnect(): Promise<void>;
+}