import { DecoratorType } from './DecoratorType.js';
import { Constructor } from '@cratis/fundamentals';
type GlobFunction = (pattern: string | string[], options?: {
    ignore: string[];
}) => Promise<string[]>;
type FileImporter = (filePath: string) => Promise<unknown>;
/** Identifies models whose event mappings live on their properties rather than on @fromEvent. */
export declare function hasModelBoundProperties(type: Function): boolean;
/**
 * Encapsulates discovery and registry operations for decorator-based artifacts.
 */
export declare class TypeDiscoverer {
    /** Shared default discoverer instance. */
    static readonly default: TypeDiscoverer;
    private static readonly _registeredTypes;
    private static readonly _propertyOnlyModels;
    private readonly _glob;
    private readonly _importFile;
    /**
     * Initializes a new instance of the {@link TypeDiscoverer} class.
     * @param glob - Optional glob function used to resolve file paths.
     * @param importFile - Optional importer used to load discovered files.
     */
    constructor(glob?: GlobFunction, importFile?: FileImporter);
    /**
     * Discovers and imports all files matching one or more glob patterns.
     * @param pattern - One or more file glob patterns.
     */
    discover(pattern: string | string[]): Promise<void>;
    /** Collects property-bound models without registering child names as root model identifiers. */
    trackModelBoundProperty(type: Constructor): void;
    /** Returns models with property mappings for artifact registration-time root filtering. */
    getPropertyOnlyModels(): Constructor[];
    /**
     * Registers a discoverable type for a decorator category.
     * @param decoratorType - The decorator category to register for.
     * @param type - The type constructor to register.
     * @param name - Optional explicit discovery name for the type.
     */
    register(decoratorType: DecoratorType, type: Constructor, name?: string): void;
    /**
     * Gets all registered types for a decorator category.
     * @param decoratorType - The decorator category to retrieve types for.
     * @returns The registered types.
     */
    getTypesByDecoratorType(decoratorType: DecoratorType): Constructor[];
    /**
     * Gets a registered type by decorator category and name.
     * @param decoratorType - The decorator category to resolve.
     * @param name - The registered name of the type.
     * @returns The matching type, if any.
     */
    getTypeByDecoratorTypeAndName(decoratorType: DecoratorType, name: string): Constructor | undefined;
    /**
     * Clears all registered types.
     * Primarily intended for test isolation.
     */
    clear(): void;
    private static resolveWithGlobPackage;
    private static importDiscoveredFile;
}
export {};
//# sourceMappingURL=TypeDiscoverer.d.ts.map