@dbs-portal/tool-mock/dist/integration/zustand.d.ts

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * Zustand integration for mock state management
 */
import type { ZustandIntegrationConfig } from './types';
/**
 * Mock store configuration
 */
export interface MockStoreConfig<T = any> {
    /** Store name */
    name: string;
    /** Initial state */
    initialState: T;
    /** Mock data to populate */
    mockData?: Partial<T>;
    /** Actions to mock */
    actions?: Record<string, (...args: any[]) => any>;
    /** Whether to persist state */
    persist?: boolean;
    /** Storage key for persistence */
    storageKey?: string;
}
/**
 * Create mock-aware Zustand store
 */
export declare function createMockStore<T extends Record<string, any>>(config: MockStoreConfig<T>): any;
/**
 * Mock store manager
 */
export declare class MockStoreManager {
    private stores;
    constructor(_config?: ZustandIntegrationConfig);
    /**
     * Register a mock store
     */
    registerStore<T extends Record<string, any>>(name: string, storeConfig: MockStoreConfig<T>): any;
    /**
     * Get registered store
     */
    getStore(name: string): any;
    /**
     * Update store state
     */
    updateStore<T>(name: string, update: Partial<T>): void;
    /**
     * Reset store to initial state
     */
    resetStore(name: string): void;
    /**
     * Clear all stores
     */
    clearAllStores(): void;
    /**
     * Get all store names
     */
    getStoreNames(): string[];
    /**
     * Apply global mock state
     */
    applyGlobalMockState(globalState: any): void;
}
/**
 * Create mock store hooks for React
 */
export declare function createMockStoreHooks<T>(store: any): {
    /**
     * Use store hook
     */
    useStore: <K extends keyof T>(selector?: (state: T) => K) => any;
    /**
     * Use store actions
     */
    useStoreActions: () => any;
};
/**
 * Mock data providers for common store patterns
 */
export declare const mockStoreProviders: {
    /**
     * User store mock data
     */
    userStore: {
        initialState: {
            currentUser: null;
            isAuthenticated: boolean;
            loading: boolean;
            error: null;
        };
        mockData: {
            currentUser: {
                id: string;
                email: string;
                firstName: string;
                lastName: string;
                roles: string[];
            };
            isAuthenticated: boolean;
        };
        actions: {
            login: (credentials: any) => {
                currentUser: {
                    id: string;
                    email: any;
                    firstName: string;
                    lastName: string;
                };
                isAuthenticated: boolean;
                loading: boolean;
                error: null;
            };
            logout: () => {
                currentUser: null;
                isAuthenticated: boolean;
                loading: boolean;
                error: null;
            };
        };
    };
    /**
     * UI store mock data
     */
    uiStore: {
        initialState: {
            sidebarOpen: boolean;
            theme: string;
            notifications: never[];
            loading: boolean;
        };
        mockData: {
            notifications: {
                id: string;
                type: string;
                message: string;
                timestamp: string;
            }[];
        };
        actions: {
            toggleSidebar: () => (state: any) => {
                sidebarOpen: boolean;
            };
            setTheme: (theme: string) => {
                theme: string;
            };
            addNotification: (notification: any) => (state: any) => {
                notifications: any[];
            };
        };
    };
    /**
     * Data store mock data
     */
    dataStore: {
        initialState: {
            items: never[];
            loading: boolean;
            error: null;
            pagination: {
                page: number;
                pageSize: number;
                total: number;
            };
        };
        mockData: {
            items: {
                id: string;
                name: string;
                description: string;
                createdAt: string;
            }[];
            pagination: {
                page: number;
                pageSize: number;
                total: number;
            };
        };
        actions: {
            setItems: (items: any[]) => {
                items: any[];
            };
            addItem: (item: any) => (state: any) => {
                items: any[];
            };
            removeItem: (id: string) => (state: any) => {
                items: any;
            };
            setLoading: (loading: boolean) => {
                loading: boolean;
            };
            setError: (error: any) => {
                error: any;
            };
        };
    };
};
/**
 * Setup mock stores for development
 */
export declare function setupMockStores(storeConfigs?: Record<string, MockStoreConfig>): MockStoreManager;
/**
 * Integration with existing Zustand stores
 */
export declare function integrateMockWithZustand(existingStore: any, mockData: any, options?: {
    override?: boolean;
    merge?: boolean;
}): any;
/**
 * Mock store devtools integration
 */
export declare function setupMockStoreDevtools(stores: Record<string, any>): void;
//# sourceMappingURL=zustand.d.ts.map