nehoid/dist/src/mods/monitoring.d.ts

Advanced unique ID generation utility with multi-layer encoding, collision detection, and context-aware features

import { Stats } from "../types";
/**
 * Monitoring and performance statistics management for NehoID.
 *
 * This module provides real-time tracking of ID generation performance, collision rates,
 * memory usage, and distribution quality. Statistics help optimize generation strategies
 * and monitor system health.
 *
 * @example
 * ```typescript
 * // Start monitoring
 * Monitor.startMonitoring();
 *
 * // Perform operations
 * for (let i = 0; i < 1000; i++) {
 *   NehoID.generate();
 * }
 *
 * // Get statistics
 * const stats = Monitor.getStats();
 * console.log(`Generated: ${stats.generated}`);
 * console.log(`Avg time: ${stats.averageGenerationTime}`);
 * console.log(`Memory: ${stats.memoryUsage}`);
 * ```
 */
export declare class Monitor {
    /** @private Whether monitoring is currently active */
    private static monitoringEnabled;
    /** @private Internal statistics storage */
    private static stats;
    /**
     * Starts collecting performance and usage statistics.
     *
     * Enables real-time monitoring of ID generation operations, including
     * timing, collision tracking, and memory usage analysis.
     *
     * @example
     * ```typescript
     * Monitor.startMonitoring();
     *
     * // All subsequent ID operations will be tracked
     * const ids = NehoID.batch({ count: 100 });
     *
     * const stats = Monitor.getStats();
     * console.log(`Generation time: ${stats.averageGenerationTime}`);
     * ```
     */
    static startMonitoring(): void;
    /**
     * Stops collecting performance statistics.
     *
     * Disables monitoring to reduce overhead when statistics are not needed.
     * Existing statistics are preserved and can still be retrieved.
     *
     * @example
     * ```typescript
     * // Stop monitoring after analysis
     * Monitor.stopMonitoring();
     *
     * // Statistics from previous operations remain available
     * const finalStats = Monitor.getStats();
     * ```
     */
    static stopMonitoring(): void;
    /**
     * Retrieves current monitoring statistics.
     *
     * Returns a snapshot of all collected performance metrics including
     * generation counts, collision rates, timing averages, and memory usage.
     *
     * @returns A complete statistics object with current metrics
     *
     * @example
     * ```typescript
     * const stats = Monitor.getStats();
     *
     * console.log(`Total IDs generated: ${stats.generated}`);
     * console.log(`Collision count: ${stats.collisions}`);
     * console.log(`Average generation time: ${stats.averageGenerationTime}`);
     * console.log(`Current memory usage: ${stats.memoryUsage}`);
     * console.log(`Distribution quality: ${stats.distributionScore}`);
     * ```
     */
    static getStats(): Stats;
    /**
     * Updates performance statistics after an ID generation operation.
     *
     * Tracks timing information and updates rolling averages. Only active
     * when monitoring is enabled. This method is called automatically
     * by generation methods and typically doesn't need manual invocation.
     *
     * @param startTime - The performance.now() timestamp when generation started
     *
     * @example
     * ```typescript
     * // Manual timing (normally done automatically)
     * const start = performance.now();
     * const id = someGenerationFunction();
     * Monitor.updateStats(start);
     * ```
     */
    static updateStats(startTime: number): void;
    /**
     * Increments the collision counter.
     *
     * Tracks instances where ID generation encountered collisions that required
     * regeneration. This helps monitor the effectiveness of collision strategies.
     *
     * @example
     * ```typescript
     * // Called automatically during collision resolution
     * try {
     *   await NehoID.safe(strategy);
     * } catch (error) {
     *   Monitor.incrementCollisions();
     *   throw error;
     * }
     * ```
     */
    static incrementCollisions(): void;
}
//# sourceMappingURL=monitoring.d.ts.map