import { TestContainer } from './test-container.js';
import { Container } from '@omnitron-dev/titan/nexus';
import { Scope, IModule, Provider, ProviderDefinition, Constructor, InjectionToken, InjectionToken as Token, RegistrationOptions } from '@omnitron-dev/titan/nexus';
export interface TestMockConfig {
    [key: string]: any;
}
export interface TestProvider<T = any> {
    provide: Token<T>;
    useValue?: T;
    useClass?: Constructor<T>;
    useFactory?: (...args: any[]) => T;
    useToken?: Token<T>;
    inject?: Token<any>[];
}
export interface TestModuleConfig {
    name: string;
    providers?: (Provider<any> | TestProvider<any>)[];
    mocks?: (Provider<any> | TestProvider<any>)[];
    imports?: IModule[];
    exports?: Token<any>[];
}
export interface TestHarnessConfig {
    component?: Constructor<any>;
    providers?: Array<[InjectionToken<any>, ProviderDefinition<any>] | TestProvider<any>>;
    zone?: {
        onEnter?: () => void;
        onLeave?: () => void;
        onError?: (error: Error) => void;
    };
}
export interface TestContainerOptionsExtended {
    autoMock?: boolean;
    detectLeaks?: boolean;
    trackMemory?: boolean;
}
export interface MemoryUsage {
    heapUsed: number;
    heapTotal: number;
    objectCount: number;
}
export declare class SnapshotContainer extends Container {
    private snapshots;
    private snapshotCounter;
    private snapshotStack;
    snapshot(): string;
    restore(snapshotId: string): void;
    withSnapshot<T>(callback: () => T): T;
    register<T>(tokenOrProvider: InjectionToken<T> | Provider<T> | Constructor<T>, providerOrOptions?: ProviderDefinition<T> | RegistrationOptions, optionsArg?: RegistrationOptions): this;
}
export declare class IsolatedContainer extends Container {
    constructor();
    static withImports(source: Container, tokens: Token<any>[]): IsolatedContainer;
}
export declare class TestModule implements IModule {
    readonly name: string;
    readonly providers: Provider<any>[];
    readonly imports: IModule[];
    readonly exports: Token<any>[];
    constructor(name: string, providers?: Provider<any>[], imports?: IModule[], exports?: Token<any>[]);
    static override(original: IModule, overrides: {
        providers?: Array<Provider<any> | [InjectionToken<any>, Provider<any>]>;
    }): TestModule;
}
export declare class TestHarness {
    private config;
    private container;
    private zone?;
    private initialized;
    constructor(config: TestHarnessConfig);
    initialize(): Promise<void>;
    get<T>(token: Token<T>): T;
    detectChanges(): Promise<void>;
    runInZone<T>(callback: () => Promise<T>): Promise<T>;
    cleanup(): Promise<void>;
}
export interface ResolutionExpectation<T> {
    toResolve(): ResolutionExpectation<T>;
    withValue(expected: T): ResolutionExpectation<T>;
    inTime(maxMs: number): Promise<void>;
}
export interface RejectionExpectation {
    toThrow(message?: string): RejectionExpectation;
    withErrorType(errorType: Constructor<Error>): Promise<void>;
}
export interface DependencyExpectation {
    toHaveDependency(token: Token<any>): DependencyExpectation;
    withCardinality(count: number): void;
}
export interface LifecycleExpectation {
    toCallOnInit(): LifecycleExpectation;
    toCallOnDestroy(): Promise<void>;
}
export declare function waitFor(condition: () => boolean | Promise<boolean>, timeout?: number, interval?: number): Promise<void>;
export declare function createDeferred<T>(): {
    promise: Promise<T>;
    resolve: (value: T) => void;
    reject: (error: Error) => void;
};
export declare function createTestProvider<T>(value: T, options?: {
    scope?: Scope;
    tags?: string[];
}): ProviderDefinition<T>;
export declare function createTestFactoryProvider<T>(factory: (...args: any[]) => T, options?: {
    inject?: Token<any>[];
    scope?: Scope;
    tags?: string[];
}): ProviderDefinition<T>;
export declare function createTestClassProvider<T>(cls: new (...args: any[]) => T, options?: {
    inject?: Token<any>[];
    scope?: Scope;
    tags?: string[];
}): ProviderDefinition<T>;
export declare function assertThrows<E extends Error>(fn: () => any | Promise<any>, errorType?: new (...args: any[]) => E, message?: string | RegExp): Promise<E>;
export declare function createTestToken<T>(name: string, metadata?: Record<string, any>): Token<T>;
export declare function verifyContainerState(container: TestContainer, expectations: {
    registeredTokens?: Token<any>[];
    resolvedTokens?: Token<any>[];
    mocks?: Token<any>[];
    spies?: Array<{
        token: Token<any>;
        method: string;
    }>;
}): void;
export declare function cleanupTest(container: TestContainer): void;
export declare function createTestSuite(name: string, setup: () => TestContainer | Promise<TestContainer>): {
    container: TestContainer;
    beforeEach: () => Promise<void>;
    afterEach: () => void;
};
export declare function createTestModule(config: TestModuleConfig): TestModule;
export declare function createTestHarness(config: TestHarnessConfig): TestHarness;
export declare function expectResolution<T>(container: Container, token: Token<T>): ResolutionExpectation<T>;
export declare function expectRejection(container: Container, token: Token<any>): RejectionExpectation;
export declare function expectDependency(container: Container, token: Token<any>): DependencyExpectation;
export declare function expectLifecycle(container: Container, token: Token<any>): LifecycleExpectation;