import { Container } from '@omnitron-dev/titan/nexus';
import { IModule, Provider, ProviderDefinition, Constructor, InjectionToken, RegistrationOptions } from '@omnitron-dev/titan/nexus';
export interface MockConfig<T = any> {
    token: InjectionToken<T>;
    mock: Partial<T> | T;
    spy?: boolean;
}
export interface TestContainerOptions {
    modules?: IModule[];
    providers?: Array<[InjectionToken<any>, ProviderDefinition<any>]>;
    mocks?: MockConfig[];
    autoMock?: boolean;
    isolate?: boolean;
    detectLeaks?: boolean;
    trackMemory?: boolean;
}
export interface Interaction {
    method: string;
    args: any[];
    result?: any;
    error?: Error;
    timestamp?: number;
}
export interface SpyExpectation {
    verify(spy: any): boolean;
    getMessage(): string;
}
export declare class CallCountExpectation implements SpyExpectation {
    private expectedCount;
    private comparison;
    constructor(expectedCount: number, comparison?: 'exact' | 'atleast' | 'atmost');
    verify(spy: any): boolean;
    getMessage(): string;
}
export declare class CallArgumentsExpectation implements SpyExpectation {
    private expectedArgs;
    private callIndex;
    constructor(expectedArgs: any[], callIndex?: number);
    verify(spy: any): boolean;
    getMessage(): string;
}
export declare class NeverCalledExpectation implements SpyExpectation {
    verify(spy: any): boolean;
    getMessage(): string;
}
export declare class TestContainer extends Container {
    private mocks;
    private spies;
    private interactions;
    private snapshots;
    private expectations;
    private autoMock;
    private originalContainer?;
    private detectLeaks;
    private trackMemory;
    private resolvedTokens;
    private registeredTokens;
    private initialObjectCount;
    constructor(options?: TestContainerOptions);
    mock<T>(token: InjectionToken<T>, mockValue: Partial<T> | T, spy?: boolean): this;
    private createMock;
    private wrapWithInteractionRecording;
    private setupSpies;
    spy<T>(token: InjectionToken<T>, method: keyof T): any;
    stub<T>(token: InjectionToken<T>, stub: Partial<T> | T): this;
    override<T>(token: InjectionToken<T>): {
        useValue: (value: T) => TestContainer;
        useClass: (cls: Constructor<T>) => TestContainer;
        useFactory: (factory: (...args: any[]) => T) => TestContainer;
    };
    getMock<T>(token: InjectionToken<T>): T;
    getSpy<T>(token: InjectionToken<T>, method: keyof T): any;
    recordInteraction(token: InjectionToken<any>, interaction: Interaction): void;
    getInteractions(token: InjectionToken<any>): Interaction[];
    clearInteractions(token?: InjectionToken<any>): void;
    snapshot(name?: string): void;
    restore(name?: string): void;
    resetMocks(): void;
    clearMocks(): void;
    expect<T>(token: InjectionToken<T>, method: keyof T): {
        toBeCalledTimes: (count: number) => void;
        toBeCalledWith: (...args: any[]) => void;
        toBeCalledAtLeast: (count: number) => void;
        toBeCalledAtMost: (count: number) => void;
        neverBeCalled: () => void;
    };
    private addExpectation;
    private getExpectations;
    clearExpectations(token?: InjectionToken<any>): void;
    verifyNoUnexpectedCalls(): void;
    register<T>(tokenOrProvider: InjectionToken<T> | Provider<T> | Constructor<T>, providerOrOptions?: ProviderDefinition<T> | RegistrationOptions, optionsArg?: RegistrationOptions): this;
    resolve<T>(token: InjectionToken<T>): T;
    private createAutoMock;
    static from(container: Container): TestContainer;
    private getObjectCount;
    getMemoryUsage(): {
        heapUsed: number;
        heapTotal: number;
        objectCount: number;
    };
    partialStub<T>(token: InjectionToken<T>, stubs: Partial<T>): this;
    getLeakedTokens(): InjectionToken<any>[];
    getTestMetadata(): {
        registeredTokens: Set<InjectionToken<any>>;
        resolvedTokens: Set<InjectionToken<any>>;
        mocks: Map<InjectionToken<any>, any>;
        spies: Map<InjectionToken<any>, Map<string, any>>;
    };
}
export declare function createTestContainer(moduleOrOptions?: IModule | TestContainerOptions): TestContainer;
export declare function createIsolatedTestContainer(options?: TestContainerOptions): TestContainer;
export declare class TestModuleBuilder {
    private providers;
    private imports;
    private mocks;
    withProvider<T>(token: InjectionToken<T>, provider: ProviderDefinition<T>): this;
    withMock<T>(token: InjectionToken<T>, mock: Partial<T> | T): this;
    withModule(module: IModule): this;
    build(): TestContainer;
}