/**
 * Defines the structure for configuring entity prefixes.
 * Keys are entity type names (e.g., "project", "task"), and values are their corresponding ID prefixes (e.g., "PROJ", "TASK").
 */
export interface EntityPrefixConfig {
    [key: string]: string;
}
/**
 * Defines options for customizing ID generation.
 */
export interface IdGenerationOptions {
    /** Character set to draw from when building the random part. Defaults to `A-Z0-9`. */
    charset?: string;
    /** Length of the random part of the ID. Defaults to `6`. */
    length?: number;
    /** String placed between the prefix and the random part. Defaults to `'_'`. */
    separator?: string;
}
/**
 * A generic ID Generator class for creating and managing unique, prefixed identifiers.
 * Allows defining custom prefixes, generating random strings, and validating/normalizing IDs.
 */
export declare class IdGenerator {
    /**
     * Default character set for the random part of the ID.
     * @private
     */
    private static DEFAULT_CHARSET;
    /**
     * Default separator character between prefix and random part.
     * @private
     */
    private static DEFAULT_SEPARATOR;
    /**
     * Default length for the random part of the ID.
     * @private
     */
    private static DEFAULT_LENGTH;
    /**
     * Stores the mapping of entity types to their prefixes.
     * @private
     */
    private entityPrefixes;
    /**
     * Stores a reverse mapping from prefixes (case-insensitive) to entity types.
     * @private
     */
    private prefixToEntityType;
    /**
     * Constructs an `IdGenerator` instance.
     * @param entityPrefixes - An initial map of entity types to their prefixes.
     */
    constructor(entityPrefixes?: EntityPrefixConfig);
    /**
     * Sets or updates the entity prefix configuration and rebuilds the internal reverse lookup map.
     * @param entityPrefixes - A map where keys are entity type names and values are their desired ID prefixes.
     */
    setEntityPrefixes(entityPrefixes: EntityPrefixConfig): void;
    /**
     * Retrieves a copy of the current entity prefix configuration.
     * @returns The current entity prefix configuration.
     */
    getEntityPrefixes(): EntityPrefixConfig;
    /**
     * Generates a cryptographically secure random string.
     * @param length - The desired length of the random string. Defaults to `IdGenerator.DEFAULT_LENGTH`.
     * @param charset - The character set to use. Defaults to `IdGenerator.DEFAULT_CHARSET`.
     * @returns The generated random string.
     */
    generateRandomString(length?: number, charset?: string): string;
    /**
     * Generates a unique ID, optionally prepended with a prefix.
     * @param prefix - An optional prefix for the ID.
     * @param options - Optional parameters for ID generation (length, separator, charset).
     * @returns A unique identifier string.
     */
    generate(prefix?: string, options?: IdGenerationOptions): string;
    /**
     * Generates a unique ID for a specified entity type, using its configured prefix.
     * @param entityType - The type of entity (must be registered).
     * @param options - Optional parameters for ID generation.
     * @returns A unique identifier string for the entity (e.g., "PROJ_A6B3J0").
     * @throws {McpError} If the `entityType` is not registered.
     */
    generateForEntity(entityType: string, options?: IdGenerationOptions): string;
    /**
     * Validates if an ID conforms to the expected format for a specific entity type.
     * @param id - The ID string to validate.
     * @param entityType - The expected entity type of the ID.
     * @param options - Optional parameters used during generation for validation consistency.
     *                  The `charset` from these options will be used for validation.
     * @returns `true` if the ID is valid, `false` otherwise.
     */
    isValid(id: string, entityType: string, options?: IdGenerationOptions): boolean;
    /**
     * Escapes special characters in a string for use in a regular expression.
     * @param str - The string to escape.
     * @returns The escaped string.
     * @private
     */
    private escapeRegex;
    /**
     * Strips the prefix and separator from an ID string, returning only the random part.
     * If the separator does not appear in the string, the original ID is returned unchanged.
     * Handles edge cases where the separator character appears in the random part by
     * rejoining all parts after the first split.
     *
     * @param id - The full ID string (e.g., `"PROJ_A6B3J0"`).
     * @param separator - The separator character used in the ID. Defaults to `'_'`.
     * @returns The random part of the ID without the prefix (e.g., `"A6B3J0"`), or the
     *   original string if the separator is not present.
     *
     * @example
     * ```ts
     * idGenerator.stripPrefix('PROJ_A6B3J0');         // → 'A6B3J0'
     * idGenerator.stripPrefix('PROJ-A6B3J0', '-');    // → 'A6B3J0'
     * idGenerator.stripPrefix('NOPREFIXID');           // → 'NOPREFIXID'
     * ```
     */
    stripPrefix(id: string, separator?: string): string;
    /**
     * Determines the entity type from an ID string by its prefix (case-insensitive).
     * @param id - The ID string (e.g., "PROJ_A6B3J0").
     * @param separator - The separator used in the ID. Defaults to `IdGenerator.DEFAULT_SEPARATOR`.
     * @returns The determined entity type.
     * @throws {McpError} If ID format is invalid or prefix is unknown.
     */
    getEntityType(id: string, separator?: string): string;
    /**
     * Normalizes an entity ID so that the prefix matches its registered casing and the random
     * part is uppercased. Delegates to {@link getEntityType} to resolve the canonical prefix.
     *
     * Note: Uppercasing the random part is correct for the default `A-Z0-9` charset. For custom
     * charsets that include lowercase or non-alphabetic characters, `toUpperCase()` may produce
     * unexpected results.
     *
     * @param id - The ID to normalize (e.g., `"proj_a6b3j0"`).
     * @param separator - The separator used in the ID. Defaults to `'_'`.
     * @returns The normalized ID with canonical prefix casing and uppercase random part
     *   (e.g., `"PROJ_A6B3J0"`).
     * @throws {McpError} With {@link JsonRpcErrorCode.ValidationError} if the entity type
     *   cannot be determined from the ID's prefix.
     *
     * @example
     * ```ts
     * idGenerator.setEntityPrefixes({ project: 'PROJ' });
     * idGenerator.normalize('proj_a6b3j0'); // → 'PROJ_A6B3J0'
     * idGenerator.normalize('PROJ_a6b3j0'); // → 'PROJ_A6B3J0'
     * ```
     */
    normalize(id: string, separator?: string): string;
}
/**
 * Default singleton instance of {@link IdGenerator}, initialized with no entity prefixes.
 * Call `idGenerator.setEntityPrefixes({ ... })` during application startup to register prefixes
 * before calling `generateForEntity` or `getEntityType`.
 */
export declare const idGenerator: IdGenerator;
/**
 * Generates a standard Version 4 UUID using the Web Crypto API (`crypto.randomUUID()`).
 * Cross-runtime: works in Node.js 19+, Cloudflare Workers, and browsers.
 *
 * @returns A new UUID v4 string (e.g., `"110e8400-e29b-41d4-a716-446655440000"`).
 *
 * @example
 * ```ts
 * const id = generateUUID(); // → '110e8400-e29b-41d4-a716-446655440000'
 * ```
 */
export declare const generateUUID: () => string;
/**
 * Generates a short, human-readable request context ID in the format `XXXXX-XXXXX`
 * (two 5-character alphanumeric segments joined by a hyphen, e.g., `"A3K9Z-BQ72M"`).
 *
 * This function is self-contained — it does not call `IdGenerator` or any other module-level
 * export — specifically to avoid circular dependencies with `requestContextService`, which
 * itself calls this function during initialization.
 *
 * Uses rejection sampling against the Web Crypto API for uniform, bias-free character selection.
 *
 * @returns A 11-character string in `XXXXX-XXXXX` format suitable for request tracing.
 *
 * @example
 * ```ts
 * const reqId = generateRequestContextId(); // → 'A3K9Z-BQ72M'
 * ```
 */
export declare const generateRequestContextId: () => string;
//# sourceMappingURL=idGenerator.d.ts.map