import { ReactElement } from 'react';
import { render, RenderOptions } from '@testing-library/react-native';
import type { DragConfig } from '../../types';
/**
 * Custom render options with context configuration
 */
interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
    dragConfig?: Partial<DragConfig>;
    entryAnimationTimeout?: number;
    layoutAnimationDuration?: number;
}
/**
 * Custom render function that wraps components with all necessary providers
 */
declare const customRender: (ui: ReactElement, options?: CustomRenderOptions) => Promise<ReturnType<typeof render>>;
export * from '@testing-library/react-native';
export { customRender as render };
/**
 * Create a mock list item with required id field
 */
export interface MockListItem {
    id: string;
    title?: string;
    [key: string]: unknown;
}
/**
 * Factory function to create a single mock item
 */
export declare const createMockItem: (id: string, overrides?: Partial<MockListItem>) => MockListItem;
/**
 * Factory function to create multiple mock items
 */
export declare const createMockItems: (count: number) => MockListItem[];
/**
 * Create a mock SharedValue-like object for testing
 */
export declare const createMockSharedValue: <T>(initialValue: T) => {
    value: T;
    addListener: jest.Mock<any, any, any>;
    removeListener: jest.Mock<any, any, any>;
    modify: jest.Mock<T, [modifier: (val: T) => T], any>;
};
/**
 * Create a mock animated ref for testing
 */
export declare const createMockAnimatedRef: <T>(current?: T | null) => {
    current: T | null;
};
/**
 * Wait for animations to complete (mock version)
 */
export declare const waitForAnimations: (ms?: number) => Promise<void>;
/**
 * Mock gesture event data for testing drag operations
 */
export declare const createMockGestureEvent: (overrides?: Record<string, unknown>) => {
    translationX: number;
    translationY: number;
    velocityX: number;
    velocityY: number;
    absoluteX: number;
    absoluteY: number;
    x: number;
    y: number;
    numberOfPointers: number;
    state: number;
};
/**
 * Mock FlashList ref for testing
 */
export declare const createMockFlashListRef: () => {
    scrollToOffset: jest.Mock<any, any, any>;
    scrollToIndex: jest.Mock<any, any, any>;
    scrollToItem: jest.Mock<any, any, any>;
    scrollToEnd: jest.Mock<any, any, any>;
    getScrollOffset: jest.Mock<number, [], any>;
    getScrollableNode: jest.Mock<null, [], any>;
    recordInteraction: jest.Mock<any, any, any>;
    flashScrollIndicators: jest.Mock<any, any, any>;
    prepareForLayoutAnimationRender: jest.Mock<any, any, any>;
};
/**
 * Drag simulation parameters
 */
interface DragSimulationParams {
    from: {
        x: number;
        y: number;
    };
    to: {
        x: number;
        y: number;
    };
    duration?: number;
    steps?: number;
}
/**
 * Create a sequence of gesture events to simulate a drag operation.
 * Returns an array of gesture event objects that can be used to test drag behavior.
 *
 * @param params - Drag simulation parameters
 * @returns Array of gesture events representing the drag sequence
 */
export declare const simulateDrag: (params: DragSimulationParams) => {
    translationX: number;
    translationY: number;
    velocityX: number;
    velocityY: number;
    absoluteX: number;
    absoluteY: number;
    x: number;
    y: number;
    numberOfPointers: number;
    state: number;
}[];
/**
 * Generate a large list of mock items for performance testing.
 *
 * @param count - Number of items to generate
 * @returns Array of mock list items
 */
export declare const generateLargeList: (count: number) => MockListItem[];
/**
 * Animation timing helper - waits for a specific SharedValue to reach target.
 * Useful for testing animation completion.
 *
 * @param sharedValue - The SharedValue to observe
 * @param targetValue - The target value to wait for
 * @param timeout - Maximum wait time in ms (default: 1000)
 * @returns Promise that resolves when target is reached or rejects on timeout
 */
export declare const waitForSharedValue: <T>(sharedValue: {
    value: T;
}, targetValue: T, timeout?: number) => Promise<T>;
/**
 * Performance measurement helper for tests.
 * Wraps an async function and returns execution time.
 *
 * @param fn - Async function to measure
 * @returns Tuple of [result, executionTimeMs]
 */
export declare const measurePerformance: <T>(fn: () => Promise<T>) => Promise<[T, number]>;
//# sourceMappingURL=test-utils.d.ts.map