@testing-library/react-hooks

const act: Act;

addCleanup: (callback: import('./types').CleanupCallback) => () => void;

cleanup: () => Promise<void>;

removeCleanup: (callback: import('./types').CleanupCallback) => void;

renderHook: <TProps, TResult>(
    callback: (props: TProps) => TResult,
    options?: RenderHookOptions<TProps>
) => RenderHookResult<TProps, TResult, Renderer<TProps>>;

suppressErrorOutput: () => () => void;

type Act = {
    (callback: () => Promise<void | undefined>): Promise<undefined>;
    (callback: () => void | undefined): void;
};

type AsyncUtils = {
    waitFor: WaitFor;
    waitForValueToChange: WaitForValueToChange;
    waitForNextUpdate: WaitForNextUpdate;
};

type CleanupCallback = () => Promise<void> | void;

type CreateRenderer<
    TProps,
    TResult,
    TRendererOptions extends object,
    TRenderer extends Renderer<TProps>
> = (props: RendererProps<TProps, TResult>, options: TRendererOptions) => TRenderer;

type ReactHooksRenderer = {
    renderHook: <TProps, TResult>(
        callback: (props: TProps) => TResult,
        options?: RenderHookOptions<TProps>
    ) => RenderHookResult<TProps, TResult>;
    act: Act;
    cleanup: () => Promise<void>;
    addCleanup: (callback: CleanupCallback) => () => void;
    removeCleanup: (callback: CleanupCallback) => void;
    suppressErrorOutput: () => () => void;
};

type ReactHooksServerRenderer = Omit<ReactHooksRenderer, 'renderHook'> & {
    renderHook: <TProps, TResult>(
        callback: (props: TProps) => TResult,
        options?: RenderHookOptions<TProps>
    ) => ServerRenderHookResult<TProps, TResult>;
};

type Renderer<TProps> = {
    render: (props?: TProps) => void;
    rerender: (props?: TProps) => void;
    unmount: () => void;
    act: Act;
};

type RendererOptions<TProps> = {
    wrapper?: WrapperComponent<TProps>;
};

type RendererProps<TProps, TResult> = {
    callback: (props: TProps) => TResult;
    setError: (error: Error) => void;
    setValue: (value: TResult) => void;
};

type RenderHookOptions<TProps> = BaseRenderHookOptions<TProps> & {
    wrapper?: WrapperComponent<TProps>;
};

type RenderHookResult<
    TProps,
    TValue,
    TRenderer extends Renderer<TProps> = Renderer<TProps>
> = ResultContainer<TValue> &
    Omit<Renderer<TProps>, 'render' | 'act'> &
    Omit<TRenderer, keyof Renderer<TProps>> &
    AsyncUtils;

type RenderResult<TValue> = {
    readonly all: Array<TValue | Error>;
    readonly current: TValue;
    readonly error?: Error;
};

type ResultContainer<TValue> = {
    result: RenderResult<TValue>;
};

type ServerRenderer<TProps> = Renderer<TProps> & {
    hydrate: () => void;
};

type ServerRenderHookResult<
    TProps,
    TValue,
    TRenderer extends ServerRenderer<TProps> = ServerRenderer<TProps>
> = RenderHookResult<TProps, TValue, TRenderer>;

type WaitFor = (
    callback: () => boolean | void,
    options?: WaitForOptions
) => Promise<void>;

type WaitForNextUpdate = (options?: WaitForNextUpdateOptions) => Promise<void>;

type WaitForNextUpdateOptions = Pick<WaitOptions, 'timeout'>;

type WaitForOptions = WaitOptions;

type WaitForValueToChange = (
    selector: () => unknown,
    options?: WaitForValueToChangeOptions
) => Promise<void>;

type WaitForValueToChangeOptions = WaitOptions;

type WaitOptions = {
    interval?: number | false;
    timeout?: number | false;
};

type WrapperComponent<TProps> = ComponentType<TProps>;