export = ExportHandlerRegistry;
/**
 * @template {Object} T
 * @typedef {import('./export-hook-descriptor')<T>} ExportHookDescriptor
 */
/**
 * @template {Object} T
 * @typedef {import('./export-hook-descriptor').Handler<T>} Handler
 */
/**
 * @template {Object} T
 * @typedef {Object} HandlerData
 * @property {Handler<T>[]} handlers
 * @property {PackageFinder.Metadata} metadata
 */
declare class ExportHandlerRegistry {
    /**
     * @param {Object} core
     * @param {import('pino').Logger} core.logger
     * @param {import('@contrast/common').Messages} core.messages
     * @param {import('@contrast/common').AppInfo} core.appInfo
     */
    constructor({ logger, messages, appInfo }: {
        logger: import("pino").Logger;
        messages: import("@contrast/common").Messages;
        appInfo: import("@contrast/common").AppInfo;
    });
    /** @type {import('pino').Logger} */
    logger: import("pino").Logger;
    /** @type {import('@contrast/common').Messages} */
    messages: import("@contrast/common").Messages;
    /** @type {string} */
    nodeModulesDir: string;
    /**
     * Contains all registered hooks that have been added by `.update()`
     * Keyed by `shortname`.
     * @type {Record<string, ExportHookDescriptor<any>[]>}
     */
    registered: Record<string, ExportHookDescriptor<any>[]>;
    /**
     * Contains all modules that have been resolved and are in require cache
     * Keyed by absolute filename.
     * @type {Record<string, HandlerData<any>>}
     */
    resolved: Record<string, HandlerData<any>>;
    /**
     * Keep track of package versions targeted by registered hooks.
     * This is used to help to detect when unsupported package versions are loaded.
     * ```
     * Map(1) { '@some/lib' => Set(3) { '2', '3', '>=5 <9' } }
     * ```
     * @type {Map<string, Set<string>>}
     */
    hookedLibVersions: Map<string, Set<string>>;
    /**
     * Keep track of which unspported libs we've logged/reported.
     * ```
     * Set(2) { 'mongodb@45.67.89', 'express@0.0.1' }
     * ```
     * @type {Set<string>}
     */
    unsupportedLibsDetected: Set<string>;
    /**
     * Update the registry with the handler info for the given module name.
     * This gets called when an agent registers a handler for a given module.
     * @template {Object} T
     * @param {ExportHookDescriptor<T>} info
     * @returns {ExportHookDescriptor<T>[]}
     */
    update<T extends Object>(info: ExportHookDescriptor<T>): ExportHookDescriptor<T>[];
    /**
     * Defined as a class method to allow easy stubbing in tests.
     * @param {string} request the string passed to require()
     * @param {Module} parent the module executing require()
     * @param {boolean} isMain indicates whether the module executing require() is the entry point
     * @returns {string} fully resolved filename of the required module
     */
    resolveFilename(request: string, parent: Module, isMain: boolean): string;
    /**
     * Defined as a class method to allow easy stubbing in tests.
     * @param {string} filename fully resolved filename of the required module
     * @returns {PackageFinder.Metadata?}
     */
    resolveMetadata(filename: string): PackageFinder.Metadata | null;
    /**
     * Iterates all descriptors pertaining to the currently-loading export. It
     * builds into the set of resolved paths the metadata and handlers for each
     * handler that is applicable to the export.
     * @template {Object} T
     * @param {PackageFinder.Metadata} metadata module metadata
     * @param {ExportHookDescriptor<T>[]} registered list of registered hooks
     */
    buildFromRegistry<T extends Object>(metadata: PackageFinder.Metadata, registered: ExportHookDescriptor<T>[]): void;
    /**
     * Returns registered handlers and the module metadata for a module that has
     * registration for the version that is being required.
     * @template {Object} T
     * @param {PackageFinder.Metadata} metadata module metadata
     * @return {HandlerData<T>=}
     */
    findModuleHandlerData<T extends Object>(metadata: PackageFinder.Metadata): HandlerData<T> | undefined;
    /**
     * When an export is returned from a `require`, we want to resolve the name
     * used as the param, e.g. "http" in `require('http')`, to a set of
     * metadata and handlers that have been registered for exports by that name.
     * @template {Object} T
     * @param {string} request the string passed to require()
     * @param {Module} parent the module executing require()
     * @param {boolean} isMain indicates whether the module executing require() is the entry point
     * @return {HandlerData<T>=}
     */
    query<T extends Object>(request: string, parent: Module, isMain: boolean): HandlerData<T> | undefined;
}
declare namespace ExportHandlerRegistry {
    export { ExportHookDescriptor, Handler, HandlerData };
}
import Module = require("module");
import PackageFinder = require("./package-finder");
type ExportHookDescriptor<T extends Object> = import("./export-hook-descriptor")<T>;
type Handler<T extends Object> = import("./export-hook-descriptor").Handler<T>;
type HandlerData<T extends Object> = {
    handlers: Handler<T>[];
    metadata: PackageFinder.Metadata;
};
//# sourceMappingURL=export-handler-registry.d.ts.map