import { HttpMethod, MockHandler, MockRequest, MockResponse, MockRoute, MockServerConfig, QueryParams } from './types';
/**
 * Request log entry
 */
export interface MockRequestLog {
    timestamp: number;
    method: HttpMethod;
    url: string;
    pathParams: Record<string, string>;
    queryParams: QueryParams;
    body: unknown;
    response: MockResponse;
    duration: number;
}
/**
 * Mock API server for intercepting and handling fetch requests
 */
export declare class MockServer {
    private routes;
    private config;
    private originalFetch;
    private isActive;
    private requestLog;
    private dataStore;
    constructor(config?: MockServerConfig);
    /**
     * Register a GET route
     */
    get<TResponse = unknown>(path: string, handler: MockHandler<never, TResponse>, options?: Partial<MockRoute>): this;
    /**
     * Register a POST route
     */
    post<TRequest = unknown, TResponse = unknown>(path: string, handler: MockHandler<TRequest, TResponse>, options?: Partial<MockRoute>): this;
    /**
     * Register a PUT route
     */
    put<TRequest = unknown, TResponse = unknown>(path: string, handler: MockHandler<TRequest, TResponse>, options?: Partial<MockRoute>): this;
    /**
     * Register a PATCH route
     */
    patch<TRequest = unknown, TResponse = unknown>(path: string, handler: MockHandler<TRequest, TResponse>, options?: Partial<MockRoute>): this;
    /**
     * Register a DELETE route
     */
    delete<TResponse = unknown>(path: string, handler: MockHandler<never, TResponse>, options?: Partial<MockRoute>): this;
    /**
     * Register a route with any method
     */
    route<TRequest = unknown, TResponse = unknown>(method: HttpMethod, path: string, handler: MockHandler<TRequest, TResponse>, options?: Partial<MockRoute>): this;
    /**
     * Register multiple routes at once
     */
    register(routes: MockRoute[]): this;
    /**
     * Remove a route
     */
    removeRoute(method: HttpMethod, path: string): this;
    /**
     * Clear all routes
     */
    clearRoutes(): this;
    /**
     * Start the mock server (intercept fetch)
     */
    start(): this;
    /**
     * Stop the mock server (restore fetch)
     */
    stop(): this;
    /**
     * Check if server is active
     */
    isRunning(): boolean;
    /**
     * Set data in the mock store
     */
    setData<T>(key: string, data: T): this;
    /**
     * Get data from the mock store
     */
    getData<T>(key: string): T | undefined;
    /**
     * Delete data from the mock store
     */
    deleteData(key: string): boolean;
    /**
     * Clear all data from the mock store
     */
    clearData(): this;
    /**
     * Initialize data store with seed data
     */
    seedData(data: Record<string, unknown>): this;
    /**
     * Get request log
     */
    getRequestLog(): MockRequestLog[];
    /**
     * Clear request log
     */
    clearRequestLog(): this;
    /**
     * Get last request
     */
    getLastRequest(): MockRequestLog | undefined;
    /**
     * Get requests by method
     */
    getRequestsByMethod(method: HttpMethod): MockRequestLog[];
    /**
     * Get requests by path pattern
     */
    getRequestsByPath(pathPattern: string | RegExp): MockRequestLog[];
    /**
     * Intercept and handle fetch requests
     */
    private interceptFetch;
    /**
     * Check if URL should be mocked
     */
    private shouldMock;
    /**
     * Match a route by method and path
     */
    private matchRoute;
    /**
     * Match path pattern and extract params
     */
    private matchPath;
    /**
     * Parse request headers
     */
    private parseHeaders;
    /**
     * Calculate delay from range
     */
    private calculateDelay;
    /**
     * Create Response object from mock response
     */
    private createResponse;
    /**
     * Get default status text for status code
     */
    private getStatusText;
    /**
     * Log request to history
     */
    private logRequest;
    /**
     * Sleep utility
     */
    private sleep;
}
/**
 * Create a new mock server instance
 *
 * @example
 * ```typescript
 * const server = createMockServer({
 *   baseUrl: 'http://localhost:3000/api',
 *   logging: true,
 *   defaultDelay: [50, 150],
 * });
 * ```
 */
export declare function createMockServer(config?: MockServerConfig): MockServer;
/**
 * Create a success response handler
 *
 * @example
 * ```typescript
 * server.get('/users', mockHandlers.success([
 *   { id: '1', name: 'John' },
 *   { id: '2', name: 'Jane' },
 * ]));
 * ```
 */
export declare const mockHandlers: {
    /**
     * Create success response
     */
    success: <T>(data: T, options?: {
        status?: number;
        headers?: Record<string, string>;
    }) => () => MockResponse<T>;
    /**
     * Create created response (201)
     */
    created: <T>(data: T) => () => MockResponse<T>;
    /**
     * Create no content response (204)
     */
    noContent: () => () => MockResponse<void>;
    /**
     * Create error response
     */
    error: (status: number, message: string, options?: {
        code?: string;
        details?: unknown;
    }) => () => MockResponse;
    /**
     * Create validation error response
     */
    validationError: (errors: Array<{
        field: string;
        message: string;
    }>) => () => MockResponse;
    /**
     * Create not found response
     */
    notFound: (message?: string) => () => MockResponse;
    /**
     * Create unauthorized response
     */
    unauthorized: (message?: string) => () => MockResponse;
    /**
     * Create forbidden response
     */
    forbidden: (message?: string) => () => MockResponse;
    /**
     * Create rate limited response
     */
    rateLimited: (retryAfter?: number) => () => MockResponse;
    /**
     * Create network error simulation
     */
    networkError: () => () => MockResponse;
    /**
     * Create timeout simulation
     */
    timeout: () => () => MockResponse;
    /**
     * Create delayed response
     */
    delayed: <T>(data: T, delayMs: number) => () => MockResponse<T>;
    /**
     * Create paginated response
     */
    paginated: <T>(items: T[], meta: {
        page: number;
        pageSize: number;
        total: number;
    }) => () => MockResponse;
    /**
     * Create conditional response based on request
     */
    conditional: <TRequest = unknown, TResponse = unknown>(conditions: Array<{
        when: (req: MockRequest<TRequest>) => boolean;
        then: MockResponse<TResponse>;
    }>, defaultResponse: MockResponse<TResponse>) => (req: MockRequest<TRequest>) => MockResponse<TResponse>;
};
/**
 * Generate mock data utilities
 */
export declare const mockData: {
    /**
     * Generate a unique ID
     */
    id: () => string;
    /**
     * Generate a UUID v4
     */
    uuid: () => string;
    /**
     * Generate a random integer
     */
    int: (min: number, max: number) => number;
    /**
     * Generate a random boolean
     */
    bool: (probability?: number) => boolean;
    /**
     * Pick a random item from array
     */
    pick: <T>(items: T[]) => T;
    /**
     * Pick multiple random items from array
     */
    pickMany: <T>(items: T[], count: number) => T[];
    /**
     * Generate a random date within range
     */
    date: (start: Date, end: Date) => Date;
    /**
     * Generate a random email
     */
    email: (domain?: string) => string;
    /**
     * Generate a random name
     */
    name: () => string;
    /**
     * Generate array of items
     */
    array: <T>(generator: (index: number) => T, count: number) => T[];
    /**
     * Generate ISO timestamp
     */
    timestamp: () => string;
    /**
     * Generate past timestamp
     */
    pastTimestamp: (daysAgo: number) => string;
};
/**
 * Create a complete CRUD handler set for a resource
 *
 * @example
 * ```typescript
 * const { routes, data } = createCrudHandlers<User>({
 *   basePath: '/users',
 *   initialData: [
 *     { id: '1', name: 'John', email: 'john@example.com' },
 *   ],
 *   generateId: () => mockData.uuid(),
 *   validate: (user) => {
 *     if (!user.name) return { field: 'name', message: 'Name is required' };
 *     return null;
 *   },
 * });
 *
 * server.register(routes);
 * ```
 */
export declare function createCrudHandlers<T extends {
    id: string;
}>(config: {
    basePath: string;
    initialData?: T[];
    generateId?: () => string;
    validate?: (data: Partial<T>) => {
        field: string;
        message: string;
    } | null;
    searchFields?: (keyof T)[];
}): {
    routes: MockRoute[];
    getData: () => T[];
    setData: (data: T[]) => void;
    findById: (id: string) => T | undefined;
};
/**
 * Default mock server instance
 */
export declare const mockServer: MockServer;