import type { CheckDefinition } from './types.js';
export declare class CheckRegistry {
    private checks;
    /**
     * Register a health check. Throws if a check with the same ID is already
     * registered.
     */
    register(check: CheckDefinition): void;
    /** Return all registered checks (insertion order). */
    getChecks(): CheckDefinition[];
    /** Return a registered check by ID, or `undefined` if not found. */
    getCheck(id: string): CheckDefinition | undefined;
    /**
     * Resolve which checks to run and return them in dependency (topological)
     * order.
     *
     * - When `check` is specified, only those checks (and their transitive
     *   dependencies) are included.
     * - When `skip` is specified, those checks are excluded from the result.
     * - Throws on unknown check names in either list.
     * - Throws on circular dependencies.
     */
    resolve(options?: {
        check?: string[];
        skip?: string[];
    }): CheckDefinition[];
    /** Throw if any IDs in the list are not registered. */
    private validateIds;
    /**
     * Starting from a set of check IDs, expand to include all transitive
     * dependencies.
     */
    private expandDependencies;
    /**
     * Validate that every dependency referenced by candidates exists within the
     * candidate set. This catches the case where a skipped check is a
     * dependency of an included check.
     */
    private validateDependencies;
    /**
     * Kahn's algorithm for topological sort. Detects cycles and throws if one
     * is found.
     *
     * Only considers checks within the `candidates` set.
     */
    private topologicalSort;
}
//# sourceMappingURL=registry.d.ts.map