import 'reflect-metadata';
import { DIContainer, InjectionToken } from '../core/di/container.js';
import { ExecutionContext, Logger, LogMeta } from '../core/types.js';
type ClassConstructor<T = unknown> = new (...args: unknown[]) => T;
/**
 * Testing utilities for NitroStack
 */
/**
 * Log entry for mock logger
 */
interface LogEntry {
    level: string;
    message: string;
    meta?: LogMeta;
}
/**
 * Mock logger for testing
 */
export declare class MockLogger implements Logger {
    logs: LogEntry[];
    debug(message: string, meta?: LogMeta): void;
    info(message: string, meta?: LogMeta): void;
    warn(message: string, meta?: LogMeta): void;
    error(message: string, meta?: LogMeta): void;
    clear(): void;
    hasLog(level: string, message: string): boolean;
}
/**
 * Create a mock execution context for testing
 */
export declare function createMockContext(overrides?: Partial<ExecutionContext>): ExecutionContext;
/**
 * Testing module builder
 */
export declare class TestingModule {
    private container;
    private providers;
    private mocks;
    private constructor();
    /**
     * Create a testing module
     */
    static create(): TestingModule;
    /**
     * Add a provider to the module
     */
    addProvider<T>(token: InjectionToken<T>, provider?: ClassConstructor<T>): this;
    /**
     * Add a mock to the module
     */
    addMock<T>(token: InjectionToken<T>, mock: T): this;
    /**
     * Compile the testing module
     */
    compile(): CompiledTestingModule;
}
/**
 * Compiled testing module
 */
export declare class CompiledTestingModule {
    private container;
    constructor(container: DIContainer);
    /**
     * Get an instance from the container
     */
    get<T>(token: InjectionToken<T>): T;
    /**
     * Cleanup the module
     */
    cleanup(): void;
}
/**
 * Mock function interface
 */
interface MockFn<TArgs extends unknown[] = unknown[], TReturn = unknown> {
    (...args: TArgs): TReturn;
    calls: TArgs[];
    mockReturnValue: TReturn | undefined;
    mockResolvedValue: (value: unknown) => MockFn<TArgs, Promise<unknown>>;
    mockRejectedValue: (error: unknown) => MockFn<TArgs, Promise<unknown>>;
}
/**
 * Create a mock function (compatible with Jest)
 */
export declare function createMockFn<TArgs extends unknown[] = unknown[], TReturn = unknown>(): MockFn<TArgs, TReturn>;
/**
 * Wait for async operations to complete
 */
export declare function flushPromises(): Promise<void>;
/**
 * Spy interface
 */
interface Spy<TArgs extends unknown[] = unknown[], TReturn = unknown> {
    (...args: TArgs): TReturn;
    calls: TArgs[];
    restore: () => void;
}
/**
 * Spy on a method
 */
export declare function spyOn<T extends object, K extends keyof T>(obj: T, method: K): Spy;
export {};
//# sourceMappingURL=index.d.ts.map