import { QueryClient } from '@tanstack/react-query';
import { ReactElement, ReactNode } from 'react';
import { FeatureAccess, FeatureConfig, FeatureRegistryEntry } from '../types';
import { FeatureDIContainer } from '../featureDI';
import { Mock } from 'vitest';
/**
 * Simple render result type
 */
export interface RenderResult {
    element: ReactElement;
    queryClient: QueryClient;
    diContainer: FeatureDIContainer;
}
/**
 * Create a test query client with sensible defaults
 */
export declare function createTestQueryClient(options?: {
    defaultOptions?: {
        queries?: {
            retry?: number | boolean;
            gcTime?: number;
            staleTime?: number;
        };
        mutations?: {
            retry?: number | boolean;
        };
    };
}): QueryClient;
/**
 * Props for FeatureTestWrapper
 */
export interface FeatureTestWrapperProps {
    children: ReactNode;
    queryClient?: QueryClient;
    diContainer?: FeatureDIContainer;
    initialRouterEntries?: string[];
}
/**
 * Comprehensive test wrapper for feature testing
 */
export declare function FeatureTestWrapper({ children, queryClient, diContainer, }: FeatureTestWrapperProps): ReactElement;
/**
 * Create a custom render function for a feature
 */
export declare function createFeatureRenderer(defaultOptions?: Partial<FeatureTestWrapperProps>): (ui: ReactElement, options?: Partial<FeatureTestWrapperProps>) => RenderResult;
/**
 * Options for creating a mock feature
 */
export interface MockFeatureOptions {
    id?: string;
    name?: string;
    description?: string;
    category?: string;
    order?: number;
    access?: Partial<FeatureAccess>;
    config?: Partial<FeatureConfig>;
}
/**
 * Create a mock feature for testing
 */
export declare function createMockFeature(overrides?: MockFeatureOptions): FeatureRegistryEntry;
/**
 * Create multiple mock features
 */
export declare function createMockFeatures(count: number, baseOptions?: MockFeatureOptions): FeatureRegistryEntry[];
/**
 * Base entity interface for mocking
 */
export interface MockEntityBase {
    id: string;
    createdAt: string;
    updatedAt: string;
}
/**
 * Create a mock entity with common fields
 */
export declare function createMockEntity<T extends Partial<MockEntityBase>>(overrides?: T & {
    id?: string;
}): MockEntityBase & T;
/**
 * Create multiple mock entities
 */
export declare function createMockEntities<T extends Partial<MockEntityBase>>(count: number, factory: (index: number) => T): Array<MockEntityBase & T>;
/**
 * Mock API response wrapper
 */
export interface MockApiResponse<T> {
    data: T;
    status: number;
    headers?: Record<string, string>;
}
/**
 * Create a mock API response
 */
export declare function createMockApiResponse<T>(data: T, options?: {
    status?: number;
    headers?: Record<string, string>;
}): MockApiResponse<T>;
/**
 * Mock service method type
 */
type MockFn = Mock | ((...args: unknown[]) => unknown);
/**
 * Create a mock service with typed methods
 */
export declare function createMockService<T extends Record<string, (...args: unknown[]) => unknown>>(implementations: Partial<{
    [K in keyof T]: MockFn;
}>): {
    [K in keyof T]: Mock;
};
/**
 * Create mock query data for testing
 */
export declare function createMockQueryData<T>(data: T, options?: {
    isLoading?: boolean;
    isFetching?: boolean;
    error?: Error | null;
    isError?: boolean;
    isSuccess?: boolean;
}): {
    data: T | undefined;
    isLoading: boolean;
    isFetching: boolean;
    error: Error | null;
    isError: boolean;
    isSuccess: boolean;
    refetch: Mock;
};
/**
 * Create mock mutation result
 */
export declare function createMockMutationResult<TData, _TVariables>(options?: {
    isLoading?: boolean;
    isSuccess?: boolean;
    isError?: boolean;
    error?: Error | null;
    data?: TData;
}): {
    mutate: Mock;
    mutateAsync: Mock;
    isLoading: boolean;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    error: Error | null;
    data: TData | undefined;
    reset: Mock;
};
/**
 * Test fixture for feature integration tests
 */
export interface FeatureTestFixture<TData> {
    featureId: string;
    initialData: TData;
    mockApi: Record<string, Mock>;
    queryClient: QueryClient;
    diContainer: FeatureDIContainer;
}
/**
 * Create a complete test fixture for a feature
 */
export declare function createFeatureTestFixture<TData>(featureId: string, options: {
    initialData: TData;
    apiMethods?: string[];
}): FeatureTestFixture<TData>;
/**
 * Seed query cache with initial data
 */
export declare function seedQueryCache<T>(queryClient: QueryClient, queryKey: readonly unknown[], data: T): void;
/**
 * Assert query cache contains expected data
 */
export declare function assertQueryCache<T>(queryClient: QueryClient, queryKey: readonly unknown[], expectedData: T): void;
/**
 * Clear specific query from cache
 */
export declare function clearQueryCache(queryClient: QueryClient, queryKey: readonly unknown[]): void;
/**
 * Wait for queries to settle
 */
export declare function waitForQueries(queryClient: QueryClient): Promise<void>;
/**
 * Create a serializable snapshot of feature state
 */
export declare function createFeatureSnapshot(queryClient: QueryClient, queryKeys: readonly (readonly unknown[])[]): Record<string, unknown>;
/**
 * Compare two feature snapshots
 */
export declare function compareSnapshots(snapshot1: Record<string, unknown>, snapshot2: Record<string, unknown>): {
    added: string[];
    removed: string[];
    changed: string[];
};
/**
 * Wait for a condition to be true
 */
export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
    timeout?: number;
    interval?: number;
}): Promise<void>;
/**
 * Delay execution for testing async behavior
 */
export declare function delay(ms: number): Promise<void>;
/**
 * Generate a random ID
 */
export declare function generateId(prefix?: string): string;
/**
 * Generate a random date within a range
 */
export declare function generateDate(options?: {
    min?: Date;
    max?: Date;
}): string;
/**
 * Generate test data with faker-like utilities
 */
export declare const testData: {
    id: typeof generateId;
    date: typeof generateDate;
    string: (length?: number) => string;
    number: (min?: number, max?: number) => number;
    boolean: () => boolean;
    email: () => string;
    name: () => string;
    pick: <T>(array: T[]) => T;
    array: <T>(length: number, factory: (index: number) => T) => T[];
};
export {};