@devilsdev/rag-pipeline-utils 2.4.4 → 2.5.0

package/dist/types/ai/multimodal-processing.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Process multimodal content and store with embedding
+ * @param {string} tenantId - Tenant identifier
+ * @param {object} content - Content object with type and data
+ * @returns {Promise<object>} Processed content record with ID, modalities, metadata
+ */
+export function processContent(tenantId: string, content: object): Promise<object>;
+/**
+ * Generate description for content by ID
+ * @param {string} contentId - Content ID
+ * @returns {Promise<object>} Object with modality-specific descriptions and unified description
+ */
+export function describeContent(contentId: string): Promise<object>;
+/**
+ * Search multimodal content using query object
+ * @param {string} tenantId - Tenant identifier
+ * @param {object} queryObj - Query object
+ * @param {object} options - Search options
+ * @returns {Promise<object>} Object with results array and metadata
+ */
+export function search(tenantId: string, queryObj: object, options?: object): Promise<object>;
+/**
+ * Find similar content to given ID
+ * @param {string} contentId - Source content ID
+ * @param {object} options - Options with threshold
+ * @returns {Promise<Array>} Array of similar items with id and score
+ */
+export function findSimilar(contentId: string, options?: object): Promise<any[]>;
+/**
+ * Clear all stored content (for testing)
+ */
+export function clear(): void;

package/dist/types/ai/multimodal.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MultiModalProcessor class
+ * Processes and integrates multiple content modalities
+ */
+export class MultiModalProcessor {
+    supportedTypes: Set<string>;
+    processors: Map<any, any>;
+    embeddings: Map<any, any>;
+    /**
+     * Process multimodal content
+     * @param {string} tenantId - Tenant identifier
+     * @param {Array} content - Array of content objects with type and data
+     * @param {object} options - Processing options
+     * @returns {Promise<object>} Processing results
+     */
+    processContent(tenantId: string, content: any[], options?: object): Promise<object>;
+    /**
+     * Generate embeddings for multimodal content
+     * @param {string} tenantId - Tenant identifier
+     * @param {object} content - Content to embed
+     * @returns {Promise<Array>} Generated embeddings
+     */
+    generateEmbeddings(tenantId: string, content: object): Promise<any[]>;
+    /**
+     * Align embeddings across modalities
+     * @param {string} tenantId - Tenant identifier
+     * @param {Array} embeddings - Multi-modal embeddings
+     * @returns {Promise<Array>} Aligned embeddings
+     */
+    alignEmbeddings(tenantId: string, embeddings: any[]): Promise<any[]>;
+    /**
+     * Perform cross-modal search
+     * @param {string} tenantId - Tenant identifier
+     * @param {object} query - Query object with modality
+     * @param {object} options - Search options
+     * @returns {Promise<Array>} Search results
+     */
+    crossModalSearch(tenantId: string, query: object, options?: object): Promise<any[]>;
+}

package/dist/types/ai/retrieval-engine.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AdaptiveRetrievalEngine class
+ * Manages intelligent document retrieval with performance optimization
+ */
+export class AdaptiveRetrievalEngine {
+    algorithms: Map<any, any>;
+    performanceMetrics: Map<any, any>;
+    adaptationThreshold: number;
+    /**
+     * Process retrieval query with adaptive algorithms
+     * @param {string} tenantId - Tenant identifier
+     * @param {string} query - Search query
+     * @param {object} options - Retrieval options
+     * @returns {Promise<object>} Retrieval results
+     */
+    retrieveDocuments(tenantId: string, query: string, options?: object): Promise<object>;
+    /**
+     * Optimize retrieval algorithm based on performance data
+     * @param {string} tenantId - Tenant identifier
+     * @param {object} performanceData - Performance metrics
+     * @returns {Promise<object>} Optimization results
+     */
+    optimizeRetrieval(tenantId: string, performanceData: object): Promise<object>;
+    /**
+     * Get current algorithm configuration
+     * @param {string} tenantId - Tenant identifier
+     * @returns {Promise<object>} Current algorithm configuration
+     */
+    getAlgorithmConfig(tenantId: string): Promise<object>;
+    /**
+     * Update retrieval strategy
+     * @param {string} tenantId - Tenant identifier
+     * @param {string} strategy - New retrieval strategy
+     * @returns {Promise<boolean>} Success status
+     */
+    updateStrategy(tenantId: string, strategy: string): Promise<boolean>;
+}

package/dist/types/ai/training/model-training-orchestrator.d.ts

@@ -0,0 +1,31 @@
+export class ModelTrainingOrchestrator extends EventEmitter<[never]> {
+    constructor(options?: {});
+    config: {
+        batchSize: any;
+        learningRate: any;
+        epochs: any;
+    };
+    trainingJobs: Map<any, any>;
+    deployments: Map<any, any>;
+    optimizations: Map<any, any>;
+    createTrainingJob(tenantId: any, config?: {}): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+    startTraining(jobId: any, data?: any, config?: {}): Promise<{
+        jobId: any;
+        status: string;
+    }>;
+    getTrainingStatus(jobId: any): any;
+    stopTraining(jobId: any): Promise<boolean>;
+    deployModel(jobId: any, deploymentConfig?: {}): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+    getDeploymentStatus(deploymentId: any): Promise<any>;
+    optimizeHyperparameters(tenantId: any, optimizationConfig: any): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+    getOptimizationResults(optimizationId: any): Promise<{
+        id: any;
+        status: any;
+        bestConfiguration: any;
+        bestScore: any;
+        trials: any;
+        startedAt: any;
+        completedAt: any;
+    }>;
+}
+import { EventEmitter } from "events";

package/dist/types/chunking/chunking-engine.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ChunkingEngine orchestrates text chunking using pluggable strategies.
+ * Extends EventEmitter to emit 'chunk' events after each chunking operation.
+ *
+ * @extends EventEmitter
+ */
+export class ChunkingEngine extends EventEmitter<[never]> {
+    /**
+     * Create a ChunkingEngine instance.
+     *
+     * @param {object} [options={}] - Configuration options merged with DEFAULT_CONFIG.
+     * @param {string} [options.strategy='recursive'] - Default strategy name.
+     * @param {number} [options.chunkSize=512] - Default chunk size.
+     * @param {number} [options.chunkOverlap=50] - Default chunk overlap.
+     * @param {number} [options.minChunkSize=50] - Default minimum chunk size.
+     * @param {string[]} [options.separators] - Default separators for recursive strategy.
+     * @param {number} [options.similarityThreshold=0.3] - Default similarity threshold for semantic strategy.
+     */
+    constructor(options?: {
+        strategy?: string;
+        chunkSize?: number;
+        chunkOverlap?: number;
+        minChunkSize?: number;
+        separators?: string[];
+        similarityThreshold?: number;
+    });
+    _config: any;
+    _strategies: Map<any, any>;
+    /**
+     * Chunk text using the configured or specified strategy.
+     *
+     * @param {string} text - The input text to chunk. Must be a non-empty string.
+     * @param {object} [options={}] - Per-call options that override the engine config.
+     * @param {string} [options.strategy] - Strategy name to use for this call.
+     * @returns {string[]} Array of text chunks.
+     * @throws {Error} If text is not a non-empty string.
+     * @throws {Error} If the specified strategy is not registered.
+     * @fires ChunkingEngine#chunk
+     */
+    chunk(text: string, options?: {
+        strategy?: string;
+    }): string[];
+    /**
+     * Register a custom chunking strategy.
+     *
+     * @param {string} name - Strategy name (used to select it via options.strategy).
+     * @param {function} fn - Strategy function with signature (text, options) => string[].
+     * @throws {Error} If name is not a non-empty string.
+     * @throws {Error} If fn is not a function.
+     */
+    registerStrategy(name: string, fn: Function): void;
+    /**
+     * List all registered strategy names.
+     *
+     * @returns {string[]} Array of strategy names.
+     */
+    listStrategies(): string[];
+    /**
+     * Get the current engine configuration.
+     *
+     * @returns {object} A copy of the current configuration.
+     */
+    getConfig(): object;
+}
+/**
+ * Default configuration for the chunking engine.
+ * @type {object}
+ */
+export const DEFAULT_CONFIG: object;
+import { EventEmitter } from "events";

package/dist/types/chunking/strategies/fixed-size.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fixed-size chunking strategy.
+ * Splits text by character count with configurable overlap.
+ * Attempts to break at word boundaries by looking back up to 20 characters.
+ *
+ * @param {string} text - The input text to chunk.
+ * @param {object} [options={}] - Chunking options.
+ * @param {number} [options.chunkSize=512] - Target chunk size in characters.
+ * @param {number} [options.chunkOverlap=50] - Number of overlapping characters between chunks.
+ * @param {number} [options.minChunkSize=50] - Minimum chunk size; smaller chunks are filtered out.
+ * @returns {string[]} Array of text chunks.
+ */
+export function fixedSizeChunk(text: string, options?: {
+    chunkSize?: number;
+    chunkOverlap?: number;
+    minChunkSize?: number;
+}): string[];

package/dist/types/chunking/strategies/recursive.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Recursive text chunking strategy.
+ * Splits text using a hierarchy of separators, merging consecutive pieces
+ * into chunks up to chunkSize. Pieces exceeding chunkSize are recursively
+ * split with the next separator in the hierarchy.
+ *
+ * @param {string} text - The input text to chunk.
+ * @param {object} [options={}] - Chunking options.
+ * @param {number} [options.chunkSize=512] - Maximum chunk size in characters.
+ * @param {number} [options.chunkOverlap=50] - Number of overlapping characters between chunks.
+ * @param {string[]} [options.separators] - Separator hierarchy for splitting.
+ * @param {number} [options.minChunkSize=50] - Minimum chunk size; smaller chunks are filtered out.
+ * @returns {string[]} Array of text chunks.
+ */
+export function recursiveChunk(text: string, options?: {
+    chunkSize?: number;
+    chunkOverlap?: number;
+    separators?: string[];
+    minChunkSize?: number;
+}): string[];

package/dist/types/chunking/strategies/semantic.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Semantic chunking strategy using topic-boundary detection.
+ * Splits text into sentences, computes Jaccard token overlap between
+ * consecutive sentence pairs, and inserts chunk boundaries where
+ * similarity drops below the threshold. Oversized segments fall back
+ * to recursive splitting.
+ *
+ * @param {string} text - The input text to chunk.
+ * @param {object} [options={}] - Chunking options.
+ * @param {number} [options.chunkSize=512] - Maximum chunk size in characters.
+ * @param {number} [options.similarityThreshold=0.3] - Minimum similarity to keep sentences in the same chunk.
+ * @param {number} [options.minChunkSize=50] - Minimum chunk size; smaller chunks are filtered out.
+ * @returns {string[]} Array of text chunks.
+ */
+export function semanticChunk(text: string, options?: {
+    chunkSize?: number;
+    similarityThreshold?: number;
+    minChunkSize?: number;
+}): string[];

package/dist/types/chunking/strategies/sentence.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sentence-based chunking strategy.
+ * Extracted from MarkdownLoader._chunkText for backward compatibility.
+ * Splits text on sentence boundaries and merges into chunks up to maxLen.
+ *
+ * @param {string} text - The input text to chunk.
+ * @param {object} [options={}] - Chunking options.
+ * @param {number} [options.maxLen=500] - Maximum character length per chunk.
+ * @returns {string[]} Array of text chunks.
+ */
+export function sentenceChunk(text: string, options?: {
+    maxLen?: number;
+}): string[];

package/dist/types/chunking/strategies/structure-aware.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Structure-aware chunking strategy.
+ * Detects document format (Markdown, HTML, or plain) and respects
+ * structural boundaries. For Markdown, splits on headers and preserves
+ * code blocks. For HTML, splits on heading/section tags. Oversized
+ * sections are further split via the recursive strategy.
+ *
+ * @param {string} text - The input text to chunk.
+ * @param {object} [options={}] - Chunking options.
+ * @param {number} [options.chunkSize=512] - Maximum chunk size in characters.
+ * @param {number} [options.chunkOverlap=50] - Number of overlapping characters between chunks.
+ * @param {string} [options.format] - Document format: 'markdown', 'html', 'plain', or auto-detect.
+ * @returns {string[]} Array of text chunks.
+ */
+export function structureAwareChunk(text: string, options?: {
+    chunkSize?: number;
+    chunkOverlap?: number;
+    format?: string;
+}): string[];

package/dist/types/citation/citation-tracker.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Tracks citations between an LLM-generated answer and retrieved source documents.
+ * Emits a 'tracked' event when citation analysis completes.
+ *
+ * @extends EventEmitter
+ */
+export class CitationTracker extends EventEmitter<[never]> {
+    /**
+     * @param {object} [options] - Override default configuration
+     * @param {number} [options.similarityThreshold=0.5] - Minimum similarity for a citation match
+     * @param {number} [options.maxCitationsPerSentence=3] - Max citations per sentence
+     * @param {boolean} [options.useIDFWeighting=true] - Whether to apply IDF weighting
+     */
+    constructor(options?: {
+        similarityThreshold?: number;
+        maxCitationsPerSentence?: number;
+        useIDFWeighting?: boolean;
+    });
+    config: any;
+    /**
+     * Normalize a document object to ensure it has a usable text content string.
+     * Looks for .content, .text, or .chunk fields. If .chunk is a function, calls it and joins the result.
+     * @param {object} doc
+     * @returns {object} Normalized doc with .content field
+     * @private
+     */
+    private _normalizeDoc;
+    /**
+     * Track citations for an answer against retrieved documents.
+     *
+     * @param {string} answer - The LLM-generated answer text
+     * @param {Array<object>} retrievedDocs - Array of source documents (each should have .content, .text, or .chunk)
+     * @returns {{
+     *   citations: Array<{sentence: string, sources: Array<{docId: string|undefined, docIndex: number, score: number}>}>,
+     *   groundednessScore: number,
+     *   hallucinationReport: object,
+     *   metadata: {sentenceCount: number, docCount: number, config: object}
+     * }}
+     * @fires CitationTracker#tracked
+     */
+    track(answer: string, retrievedDocs: Array<object>): {
+        citations: Array<{
+            sentence: string;
+            sources: Array<{
+                docId: string | undefined;
+                docIndex: number;
+                score: number;
+            }>;
+        }>;
+        groundednessScore: number;
+        hallucinationReport: object;
+        metadata: {
+            sentenceCount: number;
+            docCount: number;
+            config: object;
+        };
+    };
+}
+/**
+ * Default configuration for the CitationTracker.
+ * @type {object}
+ */
+export const DEFAULT_CONFIG: object;
+import { EventEmitter } from "events";

package/dist/types/citation/hallucination-detector.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Detect hallucinations by analyzing citation results and classifying each sentence.
+ *
+ * Classification:
+ * - 'definite_hallucination': bestScore === 0 (no overlap with any source)
+ * - 'likely_hallucination': bestScore > 0 but below threshold
+ * - 'grounded': bestScore >= threshold
+ *
+ * @param {Array<{sentence: string, sources: Array<{docId: string|undefined, docIndex: number, score: number}>}>} citationResults
+ * @param {object} [options]
+ * @param {number} [options.threshold=0.5] - Score threshold for grounded classification
+ * @returns {{
+ *   hallucinationRate: number,
+ *   sentences: Array<{text: string, classification: string, bestScore: number, bestSource: object|null}>,
+ *   summary: {grounded: number, likely_hallucination: number, definite_hallucination: number}
+ * }}
+ */
+export function detectHallucinations(citationResults: Array<{
+    sentence: string;
+    sources: Array<{
+        docId: string | undefined;
+        docIndex: number;
+        score: number;
+    }>;
+}>, options?: {
+    threshold?: number;
+}): {
+    hallucinationRate: number;
+    sentences: Array<{
+        text: string;
+        classification: string;
+        bestScore: number;
+        bestSource: object | null;
+    }>;
+    summary: {
+        grounded: number;
+        likely_hallucination: number;
+        definite_hallucination: number;
+    };
+};

package/dist/types/citation/source-mapper.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Map a sentence to its most relevant source documents by how much of the
+ * sentence each document supports (see computeSupportScore).
+ * @param {string} sentence - The sentence to map
+ * @param {Array<{content?: string, text?: string, id?: string}>} docs - Source documents
+ * @param {object} [options] - Configuration options
+ * @param {number} [options.maxCitations=3] - Maximum number of citations to return
+ * @param {number} [options.threshold=0.5] - Minimum similarity threshold
+ * @param {Map<string, number>|null} [options.idfWeights=null] - Optional IDF weights for weighted similarity
+ * @returns {Array<{docIndex: number, docId: string|undefined, score: number, matchedTokens: string[]}>}
+ */
+export function mapSentenceToSources(sentence: string, docs: Array<{
+    content?: string;
+    text?: string;
+    id?: string;
+}>, options?: {
+    maxCitations?: number;
+    threshold?: number;
+    idfWeights?: Map<string, number> | null;
+}): Array<{
+    docIndex: number;
+    docId: string | undefined;
+    score: number;
+    matchedTokens: string[];
+}>;
+/**
+ * Build IDF (Inverse Document Frequency) weights from a collection of documents.
+ * IDF = log(1 + totalDocs / docsContainingToken). The +1 keeps weights
+ * positive, so tokens found in every document (and every token when only one
+ * document was retrieved) still count instead of weighing zero.
+ * @param {Array<{content?: string, text?: string}>} docs - Array of document objects
+ * @returns {Map<string, number>} Map of token to IDF weight
+ */
+export function buildIDFWeights(docs: Array<{
+    content?: string;
+    text?: string;
+}>): Map<string, number>;

package/dist/types/connectors/anthropic-connector.d.ts

@@ -0,0 +1,92 @@
+/**
+ * LLM connector for the Anthropic Claude API.
+ * Uses axios for HTTP calls and supports streaming via SSE.
+ *
+ * @extends BaseConnector
+ */
+export class AnthropicConnector extends BaseConnector {
+    /**
+     * @param {Object} [options]
+     * @param {string} [options.model='claude-3-5-sonnet-20241022'] - Claude model to use
+     * @param {string} [options.apiKey] - Anthropic API key (defaults to ANTHROPIC_API_KEY at construction)
+     * @param {string} [options.baseURL='https://api.anthropic.com'] - API base URL
+     * @param {string} [options.apiVersion='2023-06-01'] - API version header
+     * @param {number} [options.maxTokens=4096] - Max tokens in response
+     * @param {number} [options.temperature=0.7] - Sampling temperature
+     * @param {number} [options.maxRetries=3] - Retries for transient failures
+     * @param {number} [options.retryDelay=1000] - Base backoff delay in ms
+     * @param {string} [options.systemPrompt] - System prompt used when RAG context is supplied
+     */
+    constructor(options?: {
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+        apiVersion?: string;
+        maxTokens?: number;
+        temperature?: number;
+        maxRetries?: number;
+        retryDelay?: number;
+        systemPrompt?: string;
+    });
+    config: any;
+    client: axios.AxiosInstance;
+    /**
+     * @throws {Error} code MISSING_API_KEY when no key is configured
+     * @private
+     */
+    private _requireApiKey;
+    /**
+     * Build the Messages API request body. Retrieved context goes into the
+     * user message as delimited, untrusted reference data; the system prompt
+     * only carries instructions.
+     * @private
+     */
+    private _buildBody;
+    /**
+     * Generate a response from Claude using the provided query and optional RAG context.
+     *
+     * @param {string} query - The user query / prompt
+     * @param {Array<Object|string>} [context=[]] - Retrieved documents for RAG
+     * @param {Object} [options={}] - Override model, temperature, maxTokens per-call
+     * @param {AbortSignal} [options.signal] - Cancels the request
+     * @returns {Promise<string>} The generated text
+     */
+    generate(query: string, context?: Array<any | string>, options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /**
+     * Stream a response from Claude token-by-token via SSE.
+     *
+     * @param {string} query - The user query / prompt
+     * @param {Array<Object|string>} [context=[]] - Retrieved documents for RAG
+     * @param {Object} [options={}] - Override model, temperature, maxTokens per-call
+     * @param {AbortSignal} [options.signal] - Cancels the stream
+     * @yields {{ token: string, done: boolean }}
+     */
+    generateStream(query: string, context?: Array<any | string>, options?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<{
+        token: any;
+        done: boolean;
+    }, void, unknown>;
+    /**
+     * Build a single prompt string that includes RAG context when available.
+     * Kept for backward compatibility; the context is delimited and labelled
+     * as untrusted reference data.
+     *
+     * @param {string} query - User query
+     * @param {Array<Object|string>} context - RAG context documents
+     * @returns {string} Combined prompt
+     * @private
+     */
+    private _buildPrompt;
+}
+/**
+ * Default configuration for the Anthropic connector.
+ * `apiKey` is a getter so the environment is read when a connector is
+ * constructed, not when this module is first required.
+ * @type {Object}
+ */
+export const DEFAULT_CONFIG: any;
+import { BaseConnector } from "./base-connector";
+import axios = require("axios");

package/dist/types/connectors/base-connector.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Abstract base class for all connectors.
+ * Provides connection lifecycle, health checking, and retry logic.
+ * @extends EventEmitter
+ */
+export class BaseConnector extends EventEmitter<[never]> {
+    /**
+     * @param {Object} options
+     * @param {string} [options.name] - Connector display name
+     */
+    constructor(options?: {
+        name?: string;
+    });
+    options: {
+        name?: string;
+    };
+    connected: boolean;
+    name: string;
+    /**
+     * Establish the connection.
+     * Override in subclass for custom connection logic.
+     * @returns {Promise<void>}
+     */
+    connect(): Promise<void>;
+    /**
+     * Tear down the connection.
+     * Override in subclass for custom disconnection logic.
+     * @returns {Promise<void>}
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check whether the connector is healthy and operational.
+     * Override in subclass for custom health checks.
+     * @returns {Promise<boolean>}
+     */
+    isHealthy(): Promise<boolean>;
+    /**
+     * Retry wrapper for transient failures.
+     *
+     * Only retryable errors are retried: network errors and HTTP
+     * 408/409/425/429/5xx (see {@link isRetryableError}). Other errors
+     * (400, 401, 403, 404, aborts, errors with no status or network code) are
+     * thrown immediately. Backoff is exponential with full jitter, starting at
+     * `delay` and capped at `opts.maxDelay`; a Retry-After header on the error
+     * is honoured (capped at `opts.maxDelay`). Emits a 'retry' event before
+     * each retry.
+     *
+     * @param {Function} fn - Async function to execute; receives the attempt number
+     * @param {number} [retries=3] - Maximum number of retry attempts
+     * @param {number} [delay=1000] - Base backoff delay in ms
+     * @param {object} [opts]
+     * @param {AbortSignal} [opts.signal] - Aborts the call and any pending backoff
+     * @param {number} [opts.maxDelay=30000] - Upper bound for a single backoff delay
+     * @param {(err: *) => boolean} [opts.shouldRetry] - Override retry classification
+     * @returns {Promise<*>} Result of the function
+     * @throws {Error} The first non-retryable error, or the last error once retries are exhausted
+     */
+    withRetry(fn: Function, retries?: number, delay?: number, opts?: {
+        signal?: AbortSignal;
+        maxDelay?: number;
+        shouldRetry?: (err: any) => boolean;
+    }): Promise<any>;
+    /**
+     * Wait between retries. Overridable in tests.
+     * @param {number} ms
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<void>}
+     * @protected
+     */
+    protected _sleep(ms: number, signal?: AbortSignal): Promise<void>;
+    /**
+     * Jitter source for retry backoff. Overridable in tests.
+     * @returns {number} Value in [0, 1)
+     * @protected
+     */
+    protected _random(): number;
+    /**
+     * Return basic information about the connector.
+     * @returns {{ name: string, connected: boolean, type: string }}
+     */
+    getInfo(): {
+        name: string;
+        connected: boolean;
+        type: string;
+    };
+}
+import { EventEmitter } from "events";