nehoid/dist/src/index.d.ts

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

import { EncodingPipeline } from "./core/pipeline.js";
import { createMiddleware } from "./integrations/middleware.js";
import { mongooseField, sequelizeField, typeormDecorator } from "./integrations/database.js";
import { IdGeneratorOptions, CollisionStrategy, ContextOptions, SemanticOptions, BatchOptions, ValidationOptions, HealthScore, Stats, MigrationOptions, CompatibilityOptions } from "./types";
import { NehoIDV2 } from "./exports/v2.export.js";
/**
 * @author NEHONIX
 * @since  20/05/2025
 * @see lab.nehonix.space
 * NehoId is an advanced unique ID generation utility with multi-layer encoding, collision detection, and context-aware features
 * -------------------------------------------------------------------------------------------
 * @example
 * ```js
 * const id = NehoID.generate({ prefix: "usr" });
   console.log(id); // "6a617977416b714d-7938716a56515a52-79764d5a50775555"

   const customStrategy: CollisionStrategy = {
  name: "database-check",
  maxAttempts: 3,
  backoffType: "exponential",
  checkFunction: async (id) => {
    return !(await myDatabase.findById(id));
  },
};
 * ```
 *
 */
export declare class NehoID extends NehoIDV2 {
    private static monitoringEnabled;
    private static stats;
    static middleware(...p: Parameters<typeof createMiddleware>): (req: any, res: any, next: Function) => void;
    static generate(options?: Partial<IdGeneratorOptions>): string;
    static safe(options: CollisionStrategy): Promise<string>;
    static uuid(): string;
    static nanoid(length?: number): string;
    static short(length?: number): string;
    static hex(length?: number): string;
    /**
     * Generates a hierarchical ID with parent-child relationships
     * @param options Hierarchical ID options
     * @returns A hierarchical ID
     */
    static hierarchical(options?: {}): string;
    /**
     * Generates a time-ordered ID for chronological sorting
     * @param options Temporal ID options
     * @returns A temporal ID with timestamp
     */
    static temporal(options?: {}): string;
    /**
     * Generates a sequential ID suitable for database use
     * @param options Sequential ID options
     * @returns A sequential ID
     */
    static sequential(options: {
        prefix?: string;
        counter: number;
        padLength?: number;
        suffix?: boolean;
    }): string;
    static batch(options: BatchOptions): string[];
    static validate(id: string, options?: ValidationOptions): boolean;
    static validateBatch(ids: string[], options?: ValidationOptions): {
        valid: string[];
        invalid: string[];
        duplicates: string[];
    };
    static healthCheck(id: string): HealthScore;
    static startMonitoring(): void;
    static stopMonitoring(): void;
    static getStats(): Stats;
    /**
     * Hashes geographic coordinates for privacy
     * @param latitude Latitude coordinate
     * @param longitude Longitude coordinate
     * @returns A hashed string representation of the coordinates
     */
    private static hashCoordinates;
    private static updateStats;
    /**
     * Generates a context-aware ID that incorporates environmental information
     * @param options Context options for ID generation
     * @returns A context-aware unique ID
     */
    static contextual(options: ContextOptions): string;
    /**
     * Generates a semantic ID that incorporates meaningful information
     * @param options Semantic options for ID generation
     * @returns A semantic unique ID
     */
    static semantic(options: SemanticOptions): string;
    /**
     * Migrates IDs from one format to another
     * @param options Migration options
     * @returns Promise resolving to an array of migrated IDs
     */
    static migrate(options: MigrationOptions): Promise<string[]>;
    /**
     * Generates an ID that is compatible with specified platforms
     * @param options Compatibility options
     * @returns A compatible ID
     */
    static compatible(options: CompatibilityOptions): string;
}
export type { IdGeneratorOptions, CollisionStrategy, ContextOptions, SemanticOptions, BatchOptions, ValidationOptions, HealthScore, Stats, MigrationOptions, CompatibilityOptions, };
export declare const NehoIDMiddleware: typeof createMiddleware;
export declare const database: {
    mongoose: typeof mongooseField;
    sequelize: typeof sequelizeField;
    typeorm: typeof typeormDecorator;
};
export { EncodingPipeline };
export { Encoder } from "./core/encoder.js";
//# sourceMappingURL=index.d.ts.map