export type AllArgsMatcher<Y extends any[]> = ((args: Y, equals: jest.MatcherUtils['equals']) => boolean) & {
    _isAllArgsFunctionMatcher?: true;
    _isFunctionMatcher?: true;
};
type IsAny<T> = 0 extends (1 & T) ? true : false;
type IsUnknown<T> = IsAny<T> extends true ? false : [unknown] extends [T] ? ([T] extends [unknown] ? true : false) : false;
type NormalizeReturn<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? any : T;
type NormalizeArgs<TArgs extends any[]> = number extends TArgs['length'] ? IsAny<TArgs[number]> extends true ? any[] : IsUnknown<TArgs[number]> extends true ? any[] : TArgs : {
    [K in keyof TArgs]: IsAny<TArgs[K]> extends true ? any : IsUnknown<TArgs[K]> extends true ? any : TArgs[K];
};
type ResolvedValue<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? unknown : T extends PromiseLike<infer U> ? U | T : T;
type RejectedValue<T> = IsAny<T> extends true ? any : IsUnknown<T> extends true ? unknown : T extends PromiseLike<any> ? any : never;
export type ArgumentOrMatcher<ArgTypes extends any[]> = {
    [Index in keyof ArgTypes]: ArgTypes[Index] | jest.AsymmetricMatcher | WhenMock<boolean, [ArgTypes[Index]]>;
};
export interface WhenMockWithMatchers<T = any, Y extends any[] = any[]> {
    mockReturnValue(value: T): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockReturnValueOnce(value: T): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockResolvedValue(value: ResolvedValue<T>): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockResolvedValueOnce(value: ResolvedValue<T>): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockRejectedValue(value: RejectedValue<T>): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockRejectedValueOnce(value: RejectedValue<T>): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockImplementation(fn: (...args: Y) => T): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockImplementationOnce(fn?: (...args: Y) => T): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    defaultImplementation(fn: (...args: Y) => T): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    defaultReturnValue(value: T): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    defaultResolvedValue(value: ResolvedValue<T>): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    defaultRejectedValue(value: RejectedValue<T>): WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
    mockReset(): WhenMock<T, Y>;
}
type WhenMockChain<T = any, Y extends any[] = any[]> = WhenMockWithMatchers<T, Y> & WhenMock<T, Y>;
/**
 * The main WhenMock class that provides jest-when functionality. Not used directly by users.
 * Users should use the `when()` function to create WhenMock instances.
 *
 * @example
 * ```typescript
 * const mock = jest.fn();
 * const whenMock = when(mock); // This line creates a WhenMock instance
 *
 * whenMock
 *   .calledWith('hello')
 *   .mockReturnValue('world')
 *   .calledWith('goodbye')
 *   .mockReturnValue('cruel world');
 *
 * mock('hello'); // Returns: "world"
 * mock('goodbye'); // Returns: "cruel world"
 * ```
 *
 * @template TReturn The return type of the mocked function
 */
export declare class WhenMock<TReturn = any, TArgs extends any[] = any[]> {
    /**
     * Specify the arguments that should trigger this mock behavior
     * @param matchers The argument matchers (literals, objects, Jest matchers, or function matchers)
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo', 42).mockReturnValue('matched');
     *
     * fn('foo', 42); // Returns: "matched"
     * fn('bar', 42); // Returns: undefined
     * ```
     */
    calledWith: {
        (allArgsMatcher: AllArgsMatcher<TArgs>): WhenMockWithMatchers<TReturn, TArgs>;
        (...matchers: ArgumentOrMatcher<TArgs>): WhenMockWithMatchers<TReturn, TArgs>;
    };
    /**
     * Specify the arguments that should trigger this mock behavior and assert they are called
     * @param matchers The argument matchers (literals, objects, Jest matchers, or function matchers)
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).expectCalledWith('foo').mockReturnValue('success');
     *
     * fn('foo'); // Returns: "success" ✅
     * fn('bar'); // Throws assertion error ❌
     * ```
     */
    expectCalledWith: {
        (allArgsMatcher: AllArgsMatcher<TArgs>): WhenMockWithMatchers<TReturn, TArgs>;
        (...matchers: ArgumentOrMatcher<TArgs>): WhenMockWithMatchers<TReturn, TArgs>;
    };
    /**
     * Set a default implementation for the mock (fallback when no specific matchers match)
     * @param implementation The function to call
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockReturnValue('special').defaultImplementation(() => 'default');
     *
     * fn('foo'); // Returns: "special"
     * fn('bar'); // Returns: "default"
     * ```
     */
    defaultImplementation: (mockImplementation: (...args: TArgs) => TReturn) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a default return value for the mock (fallback when no specific matchers match)
     * @param returnValue The value to return
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockReturnValue('special').defaultReturnValue('default');
     *
     * fn('foo'); // Returns: "special"
     * fn('bar'); // Returns: "default"
     * ```
     */
    defaultReturnValue: (returnValue: TReturn) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a default resolved Promise value for the mock (fallback when no specific matchers match)
     * @param returnValue The value to resolve with
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockResolvedValue('special').defaultResolvedValue('default');
     *
     * await fn('foo'); // Returns: Promise that resolves to "special"
     * await fn('bar'); // Returns: Promise that resolves to "default"
     * ```
     */
    defaultResolvedValue: (returnValue: ResolvedValue<TReturn>) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a default rejected Promise value for the mock (fallback when no specific matchers match)
     * @param err The error to reject with
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockResolvedValue('special').defaultRejectedValue(new Error('default error'));
     *
     * await fn('foo'); // Returns: Promise that resolves to "special"
     * await fn('bar'); // Returns: Promise that rejects with Error('default error')
     * ```
     */
    defaultRejectedValue: (err: RejectedValue<TReturn>) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a return value for the mock when called with the specified arguments
     * @param returnValue The value to return
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockReturnValue('success');
     *
     * fn('foo'); // Returns: "success"
     * ```
     */
    mockReturnValue: (returnValue: TReturn) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a return value for the mock when called with the specified arguments (one-time only)
     * @param returnValue The value to return
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockReturnValueOnce('first').mockReturnValue('default');
     *
     * fn('foo'); // Returns: "first"
     * fn('foo'); // Returns: "default"
     * ```
     */
    mockReturnValueOnce: (returnValue: TReturn) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a resolved Promise value for the mock when called with the specified arguments
     * @param returnValue The value to resolve with
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockResolvedValue('async success');
     *
     * await fn('foo'); // Returns: Promise that resolves to "async success"
     * ```
     */
    mockResolvedValue: (returnValue: ResolvedValue<TReturn>) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a resolved Promise value for the mock when called with the specified arguments (one-time only)
     * @param returnValue The value to resolve with
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockResolvedValueOnce('first async');
     *
     * await fn('foo'); // Returns: Promise that resolves to "first async"
     * await fn('foo'); // Returns: Promise that resolves to undefined
     * ```
     */
    mockResolvedValueOnce: (returnValue: ResolvedValue<TReturn>) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a rejected Promise value for the mock when called with the specified arguments
     * @param err The error to reject with
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockRejectedValue(new Error('async error'));
     *
     * await fn('foo'); // Returns: Promise that rejects with Error('async error')
     * ```
     */
    mockRejectedValue: (err: RejectedValue<TReturn>) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a rejected Promise value for the mock when called with the specified arguments (one-time only)
     * @param err The error to reject with
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockRejectedValueOnce(new Error('first error'));
     *
     * await fn('foo'); // Returns: Promise that rejects with Error('first error')
     * await fn('foo'); // Returns: Promise that resolves to undefined
     * ```
     */
    mockRejectedValueOnce: (err: RejectedValue<TReturn>) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a custom implementation for the mock when called with the specified arguments
     * @param implementation The function to call
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockImplementation((arg) => `processed: ${arg}`);
     *
     * fn('foo'); // Returns: "processed: foo"
     * ```
     */
    mockImplementation: (implementation: (...args: TArgs) => TReturn) => WhenMockChain<TReturn, TArgs>;
    /**
     * Set a custom implementation for the mock when called with the specified arguments (one-time only)
     * @param implementation The function to call
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockImplementationOnce((arg) => `first: ${arg}`);
     *
     * fn('foo'); // Returns: "first: foo"
     * fn('foo'); // Returns: undefined
     * ```
     */
    mockImplementationOnce: (implementation?: (...args: TArgs) => TReturn) => WhenMockChain<TReturn, TArgs>;
    /**
     * Reset all when mocks for this function
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockReturnValue('bar');
     * when(fn).calledWith('baz').mockReturnValue('qux');
     *
     * fn.resetWhenMocks();
     * fn('foo'); // Returns: undefined
     * fn('baz'); // Returns: undefined
     * ```
     */
    resetWhenMocks: () => void;
    /**
     * Reset the mock for the specified arguments
     * @returns The WhenMock instance for chaining
     * @example
     * ```typescript
     * const fn = jest.fn();
     * when(fn).calledWith('foo').mockReturnValue('bar');
     *
     * fn('foo'); // Returns: "bar"
     *
     * when(fn).calledWith('foo').mockReset();
     * fn('foo'); // Returns: undefined
     * ```
     */
    mockReset: () => WhenMock<TReturn, TArgs>;
    /**
     * Create a new WhenMock instance
     * @param fn The Jest mock or spy function to wrap
     */
    constructor(fn: jest.Mock<TReturn, TArgs> | jest.SpyInstance<TReturn, TArgs>);
}
type ExtractFunction<T> = Exclude<T, undefined> extends (...args: any[]) => any ? Exclude<T, undefined> : never;
type FunctionFromMockLike<T> = T extends {
    mockImplementation(fn?: infer TImplementation): any;
} ? ExtractFunction<TImplementation> : never;
type SafeReturnType<T> = T extends (...args: any) => any ? ReturnType<T> : never;
type Whenified<T> = [FunctionFromMockLike<T>] extends [never] ? T extends (...args: infer TArgs) => any ? WhenMock<NormalizeReturn<SafeReturnType<T>>, NormalizeArgs<TArgs>> : never : FunctionFromMockLike<T> extends (...args: infer TArgs) => any ? WhenMock<NormalizeReturn<SafeReturnType<FunctionFromMockLike<T>>>, NormalizeArgs<TArgs>> : never;
/**
 * The main jest-when function for creating mocks
 *
 * Can also be used to create function matchers (see below)
 *
 * @example
 * ```typescript
 * // Create a mock
 * const mock = jest.fn();
 * when(mock).calledWith('hello').mockReturnValue('world');
 * mock('hello'); // Returns: "world"
 * ```
 *
 * @example
 * ```typescript
 * // Create a function matcher
 * const isEven = when((n: number) => n % 2 === 0);
 * when(mock).calledWith(isEven).mockReturnValue('even number');
 * mock(4); // Returns: "even number"
 * ```
 */
export declare function when<T>(fn: T): Whenified<T>;
export declare namespace when {
    var allArgs: <Y extends any[]>(fn: (args: Y, equals: jest.MatcherUtils["equals"]) => boolean) => AllArgsMatcher<Y>;
}
/**
 * Reset all when mocks across all functions, restoring their original implementations
 *
 * @example
 * ```typescript
 * const mock1 = jest.fn();
 * const mock2 = jest.fn();
 *
 * when(mock1).calledWith('hello').mockReturnValue('world');
 * when(mock2).calledWith('goodbye').mockReturnValue('cruel world');
 *
 * resetAllWhenMocks();
 * mock1('hello'); // Returns: undefined (back to original behavior)
 * mock2('goodbye'); // Returns: undefined (back to original behavior)
 * ```
 */
export declare const resetAllWhenMocks: () => void;
/**
 * Verify that all when mocks have been called, throwing an error if any were not called
 *
 * @example
 * ```typescript
 * const mock = jest.fn();
 * when(mock).expectCalledWith('hello').mockReturnValue('world');
 *
 * mock('hello'); // Returns: "world" (this mock was called)
 *
 * verifyAllWhenMocksCalled(); // ✅ Passes - all mocks were called
 * ```
 *
 * @throws Error if any when mocks were not called, with details about which mocks were missed
 */
export declare const verifyAllWhenMocksCalled: () => void;
declare const _default: {
    when: typeof when;
    resetAllWhenMocks: () => void;
    verifyAllWhenMocksCalled: () => void;
    WhenMock: typeof WhenMock;
};
export default _default;
//# sourceMappingURL=when.d.ts.map