/**
 * Hash mapping from CDK bundle.
 */
export interface HashMapping {
    /** Hash key to handler name mapping */
    readonly hashToNameMap: Record<string, string>;
    /** Hash key to service name mapping */
    readonly hashToServiceNameMap: Record<string, string>;
    /** Microservice name */
    readonly microserviceName: string;
    /** Build time of the bundle */
    readonly buildTime?: number;
    /** Hash algorithm used */
    readonly hashAlgorithm: string;
}
/**
 * Result of loading hash mappings.
 */
export interface HashMapLoadResult {
    /** Loaded hash mappings by microservice name */
    readonly mappings: Record<string, HashMapping>;
    /** Source paths of loaded bundles */
    readonly sourcePaths: Record<string, string>;
    /** Errors encountered during loading */
    readonly errors: Array<{
        microserviceName: string;
        error: string;
    }>;
}
/**
 * Configuration for HashMapLoader.
 */
export interface HashMapLoaderConfig {
    /** Project root directory */
    readonly projectRoot: string;
    /** Deployment stage */
    readonly stage: string;
    /** Microservice names to load */
    readonly microserviceNames: string[];
    /** Enable verbose logging */
    readonly verbose?: boolean;
}
/**
 * Hash Map Loader for Awake Lambda Development.
 *
 * Loads hashToNameMap from CDK-built Lambda Layer bundles located in
 * `cdk.out/microservice-bundles/{microserviceName}-layer-{stage}/nodejs/bundle.js`.
 *
 * This enables the Live Dev CLI to:
 * 1. Receive a request with `handlerHashKey` from Lambda
 * 2. Translate `hashKey → lambdaId` using the CDK bundle's mapping
 * 3. Execute the LOCAL handler code by `lambdaId`
 *
 * @example
 * ```typescript
 * const loader = new HashMapLoader({
 *   projectRoot: process.cwd(),
 *   stage: 'dev',
 *   microserviceNames: ['payments', 'users'],
 * });
 *
 * const result = await loader.load();
 * const lambdaId = result.mappings['payments'].hashToNameMap['brTkPfELKivMWFhMFBsn3vOQ1XXA-NNI'];
 * // lambdaId = 'get'
 * ```
 */
export declare class HashMapLoader {
    private readonly config;
    constructor(config: HashMapLoaderConfig);
    /**
     * Load hash mappings from CDK bundles.
     *
     * @returns Loaded hash mappings
     */
    load(): Promise<HashMapLoadResult>;
    /**
     * Get the path to the CDK bundle for a microservice.
     *
     * @param microserviceName - Name of the microservice
     * @returns Path to the bundle file
     */
    private getBundlePath;
    /**
     * Extract hash mapping from a loaded bundle.
     *
     * @param microserviceName - Name of the microservice
     * @param bundle - Loaded bundle module
     * @returns Hash mapping or null if extraction failed
     */
    private extractHashMapping;
    /**
     * Clear require cache for a module.
     *
     * @param modulePath - Path to the module
     */
    private clearRequireCache;
    /**
     * Log message if verbose mode is enabled.
     */
    private log;
}
/**
 * Load hash mappings from CDK bundles.
 *
 * Convenience function for loading hash mappings without creating a loader instance.
 *
 * @param projectRoot - Project root directory
 * @param stage - Deployment stage
 * @param microserviceNames - Microservice names to load
 * @param verbose - Enable verbose logging
 * @returns Loaded hash mappings
 */
export declare function loadHashMappings(projectRoot: string, stage: string, microserviceNames: string[], verbose?: boolean): Promise<HashMapLoadResult>;
/**
 * Translate a hash key to a lambda ID using loaded mappings.
 *
 * @param hashKey - Hash key from Lambda request
 * @param microserviceName - Name of the microservice
 * @param mappings - Loaded hash mappings
 * @returns Lambda ID or null if not found
 */
export declare function translateHashKeyToLambdaId(hashKey: string, microserviceName: string, mappings: Record<string, HashMapping>): string | null;
