import { default as React, ReactElement, PropsWithChildren } from 'react';
import { RenderOptions, RenderResult, RenderHookResult, RenderHookOptions } from '@testing-library/react';
import { Mock } from 'vitest';
/**
 * Custom render options extending RTL options
 */
interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
    /** Initial authentication state */
    authenticated?: boolean;
    /** Initial store state overrides */
    initialState?: Record<string, unknown>;
    /** Custom wrapper component */
    wrapper?: React.ComponentType<PropsWithChildren>;
}
/**
 * Custom render function with providers
 *
 * @example
 * ```tsx
 * const { getByRole } = customRender(<MyComponent />, {
 *   authenticated: true,
 *   initialState: { theme: 'dark' }
 * });
 * ```
 */
export declare function customRender(ui: ReactElement, options?: CustomRenderOptions): RenderResult;
/**
 * Custom render hook function with providers
 *
 * @example
 * ```tsx
 * const { result } = customRenderHook(() => useMyHook(), {
 *   authenticated: true
 * });
 * expect(result.current.value).toBe('expected');
 * ```
 */
export declare function customRenderHook<TResult, TProps>(hook: (props: TProps) => TResult, options?: Omit<RenderHookOptions<TProps>, 'wrapper'> & CustomRenderOptions): RenderHookResult<TResult, TProps>;
/**
 * Create a mock user object
 */
export declare function createMockUser(overrides?: Partial<MockUser>): MockUser;
/**
 * Mock user interface
 */
export interface MockUser {
    id: string;
    email: string;
    firstName: string;
    lastName: string;
    displayName: string;
    roles: string[];
    permissions: string[];
    avatar?: string;
    createdAt: string;
    updatedAt: string;
}
/**
 * Create mock auth tokens
 */
export declare function createMockAuthTokens(overrides?: Partial<MockAuthTokens>): MockAuthTokens;
/**
 * Mock auth tokens interface
 */
export interface MockAuthTokens {
    accessToken: string;
    refreshToken: string;
    expiresAt: number;
}
/**
 * Create a mock API response
 */
export declare function createMockApiResponse<T>(data: T, overrides?: Partial<MockApiResponse<T>>): MockApiResponse<T>;
/**
 * Mock API response interface
 */
export interface MockApiResponse<T> {
    data: T;
    status: number;
    statusText: string;
    headers: Record<string, string>;
}
/**
 * Create a mock API error
 */
export declare function createMockApiError(overrides?: Partial<MockApiError>): MockApiError;
/**
 * Mock API error interface
 */
export interface MockApiError {
    status: number;
    code: string;
    message: string;
    category: string;
    severity: string;
    retryable: boolean;
    timestamp: number;
    fieldErrors?: Array<{
        field: string;
        message: string;
    }>;
}
/**
 * Create mock store state
 */
export declare function createMockStoreState(overrides?: Partial<MockStoreState>): MockStoreState;
/**
 * Mock store state interface
 */
export interface MockStoreState {
    sidebarOpen: boolean;
    sidebarCollapsed: boolean;
    layoutDensity: string;
    animationsEnabled: boolean;
    globalLoading: boolean;
    activeModal: string | null;
    toasts: unknown[];
    isAuthenticated: boolean;
    user: MockUser | null;
    sessionStartedAt: number | null;
    lastActivity: number | null;
    locale: string;
    timezone: string;
    theme: string;
    notificationsEnabled: boolean;
    reducedMotion: boolean;
    _hasHydrated: boolean;
}
/**
 * Wait for all pending promises to resolve
 */
export declare function flushPromises(): Promise<void>;
/**
 * Wait for a specific amount of time
 */
export declare function delay(ms: number): Promise<void>;
/**
 * Create a deferred promise for controlling async flow in tests
 */
export declare function createDeferred<T>(): Deferred<T>;
/**
 * Deferred promise interface
 */
export interface Deferred<T> {
    promise: Promise<T>;
    resolve: (value: T) => void;
    reject: (reason?: unknown) => void;
}
/**
 * Create a spy that tracks calls and can be resolved/rejected
 */
export declare function createAsyncSpy<T>(defaultResponse?: T): AsyncSpy<T>;
/**
 * Async spy interface
 */
export interface AsyncSpy<T> extends Mock {
    resolveWith: (value: T) => void;
    rejectWith: (error: Error) => void;
    resolveOnce: (value: T) => void;
    rejectOnce: (error: Error) => void;
}
/**
 * Create a mock event
 */
export declare function createMockEvent<T extends Event>(type: string, props?: Partial<T>): T;
/**
 * Create a mock keyboard event
 */
export declare function createMockKeyboardEvent(key: string, options?: Partial<KeyboardEventInit>): KeyboardEvent;
/**
 * Create a mock storage implementation
 */
export declare function createMockStorage(): MockStorage;
/**
 * Mock storage interface
 */
export interface MockStorage {
    getItem: Mock;
    setItem: Mock;
    removeItem: Mock;
    clear: Mock;
    key: Mock;
    length: number;
    _store: Map<string, string>;
}
/**
 * Create a mock secure storage implementation
 */
export declare function createMockSecureStorage(): MockSecureStorage;
/**
 * Mock secure storage interface
 */
export interface MockSecureStorage {
    getItem: Mock;
    setItem: Mock;
    removeItem: Mock;
    clear: Mock;
    _store: Map<string, unknown>;
}
/**
 * Create a mock fetch function
 */
export declare function createMockFetch(): MockFetch;
/**
 * Mock fetch interface
 */
export interface MockFetch extends Mock {
    mockResponse: (data: unknown, status?: number) => void;
    mockError: (status: number, message: string) => void;
    mockNetworkError: () => void;
}
export { screen, within, waitFor, fireEvent } from '@testing-library/react';
export { default as userEvent } from '@testing-library/user-event';
export { act } from 'react';
export { customRender as render, customRenderHook as renderHook };