ezux 1.0.0

package/dist/shared/hooks/useBaseComponent.d.ts

@@ -0,0 +1,60 @@
+import { ServiceRegistry } from '../services/ServiceRegistry';
+import { ComponentEventCallbacks } from '../types/common';
+/**
+ * Common properties for all core components.
+ * @group Properties
+ */
+export interface BaseComponentProps extends ComponentEventCallbacks {
+    /**
+     * The shared service registry instance.
+     * @group Services
+     */
+    serviceRegistry?: ServiceRegistry;
+    [key: string]: any;
+}
+export type BaseComponentConfig = BaseComponentProps;
+/**
+ * Base internal state for core components.
+ * @group State
+ */
+export interface BaseComponentState {
+    /** Whether the component is processing an async action. @group State */
+    isLoading: boolean;
+    /** Current error state. @group State */
+    error: Error | null;
+    /** Whether the component has mounted on the client. @group State */
+    isHydrated: boolean;
+}
+/**
+ * Foundation API shared by all core components.
+ * @group Methods
+ */
+export interface BaseComponentAPI {
+    /** Shows the global component spinner. @group Methods */
+    showSpinner: () => void;
+    /** Hides the global component spinner. @group Methods */
+    hideSpinner: () => void;
+}
+/**
+ * A foundational hook that provides shared infrastructure for all core components.
+ *
+ * Handles service registry resolution, basic lifecycle events, and common loading/error state.
+ *
+ * @param props The component's props.
+ * @group Hooks
+ */
+export declare const useBaseComponent: (props: BaseComponentProps) => {
+    /** The resolved service registry for this component. @group Services */
+    serviceRegistry: ServiceRegistry;
+    /** Current base state (loading, error, hydrated). @group State */
+    state: BaseComponentState;
+    /** Functional setter for loading state. @group Methods */
+    setIsLoading: (isLoading: boolean) => void;
+    /** Functional setter for error state. @group Methods */
+    setError: (error: Error | null) => void;
+    /** Base API (spinner controls). @group Methods */
+    api: {
+        showSpinner: () => void;
+        hideSpinner: () => void;
+    };
+};

package/dist/shared/hooks/useComponentImperativeAPI.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'react';
+export interface ImperativeAPIOptions {
+    validateField?: (data: any) => boolean;
+    validateEditForm?: () => boolean;
+    [key: string]: any;
+}
+/**
+ * Generic imperative API hook for all EzUX components
+ * Standardizes imperative API pattern across components
+ */
+export declare const useComponentImperativeAPI: <T extends Record<string, any>>(ref: Ref<T> | undefined, api: T, options?: ImperativeAPIOptions) => void;

package/dist/shared/hooks/useComponentState.d.ts

@@ -0,0 +1,39 @@
+import { IService } from '../services/ServiceRegistry';
+/**
+ * Configuration for the useComponentState hook.
+ * @group Properties
+ */
+export interface StateConfig<T> {
+    /** Initial state value. @group Data */
+    initialState: T;
+    /** Optional service for state synchronization. @group Services */
+    service?: IService;
+    /** LocalStorage key for state persistence. @group Properties */
+    persistenceKey?: string;
+    /** Delay in milliseconds for state update debouncing. @group Properties */
+    debounceMs?: number;
+    /** Callback triggered when state changes. @group Events */
+    onChange?: (state: T) => void;
+}
+/**
+ * A robust state management hook with support for debouncing, persistence, and service integration.
+ *
+ * @param config Configuration for the state management.
+ * @group Hooks
+ */
+export declare function useComponentState<T>(config: StateConfig<T>): {
+    /** The current state object. @group State */
+    state: T;
+    /** Updates the state (with optional debouncing). @group Methods */
+    setState: (updater: T | ((prev: T) => T)) => void;
+    /** Updates the state immediately, bypassing debouncing. @group Methods */
+    setImmediateState: (newState: T) => void;
+    /** Whether a state-related async operation is in progress. @group State */
+    loading: boolean;
+    /** Functional setter for loading state. @group Methods */
+    setLoading: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    /** Current error state. @group State */
+    error: Error | null;
+    /** Functional setter for error state. @group Methods */
+    setError: import('react').Dispatch<import('react').SetStateAction<Error | null>>;
+};

package/dist/shared/hooks/useCurrentTime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared hook for centralized timekeeping.
+ * Updates every minute and provides a stable Date object.
+ * Useful for "Current Time" indicators in calendars/schedulers.
+ */
+export declare function useCurrentTime(refreshInterval?: number): Date;

package/dist/shared/hooks/useDataChangeEvents.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Data change event callbacks shared across components.
+ */
+export interface DataChangeCallbacks<TData = any> {
+    onDataChangeStart?: (args: {
+        action: 'add' | 'edit' | 'delete';
+        data: TData | TData[];
+    }) => void;
+    onDataChangeComplete?: (args: {
+        action: 'add' | 'edit' | 'delete';
+        data: TData | TData[];
+    }) => void;
+    onDataChangeCancel?: (args: {
+        action: 'add' | 'edit' | 'delete';
+        row?: any;
+    }) => void;
+    onDataChangeRequest?: (args: {
+        action: 'add' | 'edit' | 'delete';
+        data: TData;
+    }) => void;
+    onRowAddStart?: (args: {
+        data: Partial<TData>;
+    }) => void;
+    onRowEditStart?: (args: {
+        row: any;
+        data: TData;
+    }) => void;
+}
+/**
+ * Shared hook for data change lifecycle events.
+ * Used by EzTable, EzScheduler, EzTreeView to emit consistent data mutation events.
+ *
+ * @example
+ * const { emitDataChangeStart, emitDataChangeComplete, withDataChange } = useDataChangeEvents(props);
+ *
+ * // Wrap a mutation
+ * withDataChange('add', newRecord, () => {
+ *   addRecordToState(newRecord);
+ * });
+ */
+export declare const useDataChangeEvents: <TData = any>(callbacks: DataChangeCallbacks<TData>) => {
+    emitDataChangeStart: (action: "add" | "edit" | "delete", data: TData | TData[]) => void;
+    emitDataChangeComplete: (action: "add" | "edit" | "delete", data: TData | TData[]) => void;
+    emitDataChangeCancel: (action: "add" | "edit" | "delete", row?: any) => void;
+    emitDataChangeRequest: (action: "add" | "edit" | "delete", data: TData) => void;
+    emitRowAddStart: (data: Partial<TData>) => void;
+    emitRowEditStart: (row: any, data: TData) => void;
+    withDataChange: <R>(action: "add" | "edit" | "delete", data: TData | TData[], mutation: () => R) => R;
+    pendingAction: {
+        action: "add" | "edit" | "delete";
+        data: TData | TData[];
+    } | null;
+};

package/dist/shared/hooks/useDebounce.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook for debouncing a value
+ * Useful for search inputs and expensive operations
+ */
+export declare function useDebounce<T>(value: T, delay?: number): T;
+/**
+ * Hook for throttling a callback function
+ * Useful for scroll, resize, and zoom events
+ */
+export declare function useThrottle<T extends (...args: any[]) => any>(callback: T, delay?: number): T;

package/dist/shared/hooks/useDeleteConfirmation.d.ts

@@ -0,0 +1,9 @@
+export declare const useDeleteConfirmation: () => {
+    isOpen: boolean;
+    idToDelete: string | null;
+    title: string;
+    message: string;
+    requestDelete: (id: string, customTitle?: string, customMessage?: string) => void;
+    close: () => void;
+    setIsOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+};

package/dist/shared/hooks/useDialogState.d.ts

@@ -0,0 +1,21 @@
+export type DialogMode = 'create' | 'edit' | 'view';
+export interface DialogStateHelperConfig<T> {
+    initialMode?: DialogMode;
+    initialData?: T;
+    defaultData?: T;
+}
+/**
+ * Shared hook for managing dialog/modal state.
+ * Simplifies handling of open/close state, data passing, and operation modes.
+ */
+export declare function useDialogState<T = any>(config?: DialogStateHelperConfig<T>): {
+    isOpen: boolean;
+    mode: DialogMode;
+    data: T;
+    meta: any;
+    open: (mode: DialogMode, data?: T, meta?: any) => void;
+    close: () => void;
+    toggle: () => void;
+    setData: import('react').Dispatch<import('react').SetStateAction<T>>;
+    setMode: import('react').Dispatch<import('react').SetStateAction<DialogMode>>;
+};

package/dist/shared/hooks/useDndHandlers.d.ts

@@ -0,0 +1,17 @@
+import { CollisionDetection, DragEndEvent } from '@dnd-kit/core';
+interface UseDndHandlersOptions {
+    onDragEnd: (event: DragEndEvent) => void;
+    collisionDetection?: CollisionDetection;
+    distance?: number;
+}
+/**
+ * A shared hook to consolidate dnd-kit sensor setup and handlers.
+ *
+ * @param options DnD options including onDragEnd, collisionDetection, and distance constraint.
+ */
+export declare const useDndHandlers: (options: UseDndHandlersOptions) => {
+    sensors: import('@dnd-kit/core').SensorDescriptor<import('@dnd-kit/core').SensorOptions>[];
+    onDragEnd: (event: DragEndEvent) => void;
+    collisionDetection: CollisionDetection | undefined;
+};
+export {};

package/dist/shared/hooks/useEditing.d.ts

@@ -0,0 +1,107 @@
+import { EditMode, ValidationResult } from '../types/common';
+/**
+ * Configuration for the useEditing hook.
+ * @group Properties
+ */
+export interface EditConfig<TData = any> {
+    /** Edit interaction mode (inline, dialog, or batch). @group Properties */
+    mode?: EditMode;
+    /** Whether adding new records is allowed. @group Properties */
+    allowAdding?: boolean;
+    /** Whether editing existing records is allowed. @group Properties */
+    allowEditing?: boolean;
+    /** Whether deleting records is allowed. @group Properties */
+    allowDeleting?: boolean;
+    /** Whether to prompt for confirmation before deletion. @group Properties */
+    showDeleteConfirm?: boolean;
+    /** Callback to validate an entire row before saving. @group Events */
+    validateRow?: (data: TData) => ValidationResult;
+    /** Callback to validate a single field value. @group Events */
+    validateField?: (fieldName: string, value: any, data: TData) => boolean | string;
+    /** Callback triggered when a row enters edit mode. @group Events */
+    onRowEdit?: (data: TData, index: number) => void;
+    /** Callback triggered when a new row is being added. @group Events */
+    onRowAdd?: (data: TData) => void;
+    /** Callback triggered when a row is deleted. @group Events */
+    onRowDelete?: (id: string | number) => void;
+    /** Callback triggered when changes to a row are saved. @group Events */
+    onRowSave?: (data: TData, index: number) => void;
+    /** Callback triggered when editing of a row is cancelled. @group Events */
+    onRowCancel?: (index: number) => void;
+}
+/**
+ * Internal editing state.
+ * @group State
+ */
+export interface EditState<TData = any> {
+    /** Map of row indices to their current pending edits. @group State */
+    editingRows: Map<number, TData>;
+    /** Current state for a row being added (null if none). @group State */
+    addingRow: TData | null;
+    /** Set of IDs currently marked for deletion. @group State */
+    deletingIds: Set<string | number>;
+    /** Map of row indices to their current validation errors. @group State */
+    validationErrors: Map<number, Record<string, string>>;
+}
+/**
+ * Public API for editing management.
+ * @group Methods
+ */
+export interface EditAPI<TData = any> {
+    /** Starts editing a specific row. @group Methods */
+    startEditing: (index: number, data: TData) => void;
+    /** Stops editing a specific row without saving. @group Methods */
+    stopEditing: (index: number) => void;
+    /** Checks if a row is currently in edit mode. @group Methods */
+    isEditing: (index: number) => boolean;
+    /** Returns the current pending data for an edited row. @group Methods */
+    getEditingData: (index: number) => TData | undefined;
+    /** Updates the pending data for an edited row. @group Methods */
+    updateEditingData: (index: number, data: Partial<TData>) => void;
+    /** Starts the process of adding a new row. @group Methods */
+    startAdding: (initialData?: Partial<TData>) => void;
+    /** Stops the add process without saving. @group Methods */
+    stopAdding: () => void;
+    /** Checks if a return is currently in add mode. @group Methods */
+    isAdding: () => boolean;
+    /** Returns the current data for the row being added. @group Methods */
+    getAddingData: () => TData | null;
+    /** Updates the data for the row being added. @group Methods */
+    updateAddingData: (data: Partial<TData>) => void;
+    /** Saves changes to a specific row. @group Methods */
+    saveRow: (index: number) => Promise<boolean>;
+    /** Saves the row currently being added. @group Methods */
+    saveNewRow: () => Promise<boolean>;
+    /** Cancels editing and reverts changes for a row. @group Methods */
+    cancelEdit: (index: number) => void;
+    /** Cancels the add process. @group Methods */
+    cancelAdd: () => void;
+    /** Marks a row for deletion or triggers immediate delete. @group Methods */
+    deleteRow: (id: string | number) => void;
+    /** Checks if a specific ID is marked for deletion. @group State */
+    isDeleting: (id: string | number) => boolean;
+    /** Validates a specific row and returns results. @group Methods */
+    validateRow: (index: number) => ValidationResult;
+    /** Validates a specific field within a row. @group Methods */
+    validateField: (index: number, fieldName: string, value: any) => boolean | string;
+    /** Returns current validation errors for a row. @group Methods */
+    getValidationErrors: (index: number) => Record<string, string> | undefined;
+    /** Checks if there are any pending edits or additions. @group Methods */
+    hasChanges: () => boolean;
+    /** Returns all rows that have pending changes. @group Methods */
+    getChangedRows: () => Map<number, TData>;
+    /** Saves all pending changes across all edited rows. @group Methods */
+    saveAllChanges: () => Promise<boolean>;
+    /** Discards all pending edits and additions. @group Methods */
+    cancelAllChanges: () => void;
+}
+/**
+ * Shared hook for implementing robust editing features in components.
+ *
+ * Manages complex state transitions for inline, batch, and dialog-based editing,
+ * including validation logic, pending changes tracking, and transactional saving.
+ *
+ * @param config Configuration for editing behavior and callbacks.
+ * @group Hooks
+ */
+export declare const useEditing: <TData extends Record<string, any> = any>(config?: EditConfig<TData>) => EditAPI<TData>;

package/dist/shared/hooks/useEventHandlers.d.ts

@@ -0,0 +1,61 @@
+import { DragEndEvent, DragStartEvent, DragOverEvent } from '@dnd-kit/core';
+/**
+ * Configuration for component event handlers.
+ * @group Properties
+ */
+export interface EventHandlerConfig {
+    /** Triggered when a drag operation starts. @group Events */
+    onDragStart?: (event: DragStartEvent) => void;
+    /** Triggered while an item is being dragged over. @group Events */
+    onDragOver?: (event: DragOverEvent) => void;
+    /** Triggered when a drag operation completes. @group Events */
+    onDragEnd?: (event: DragEndEvent) => void;
+    /** Triggered on key press. @group Events */
+    onKeyPress?: (event: React.KeyboardEvent) => void;
+    /** Triggered on key down. @group Events */
+    onKeyDown?: (event: React.KeyboardEvent) => void;
+    /** Triggered on key up. @group Events */
+    onKeyUp?: (event: React.KeyboardEvent) => void;
+    /** Triggered on mouse click. @group Events */
+    onClick?: (event: React.MouseEvent) => void;
+    /** Triggered on mouse double-click. @group Events */
+    onDoubleClick?: (event: React.MouseEvent) => void;
+    /** Triggered when focus state changes. @group Events */
+    onFocusChange?: (focused: boolean) => void;
+    /** Triggered on pointer down (touch/mouse). @group Events */
+    onPointerDown?: (event: React.PointerEvent) => void;
+    /** Triggered on pointer move (touch/mouse). @group Events */
+    onPointerMove?: (event: React.PointerEvent) => void;
+    /** Triggered on pointer up (touch/mouse). @group Events */
+    onPointerUp?: (event: React.PointerEvent) => void;
+    /** Triggered when pointer leaves element. @group Events */
+    onPointerLeave?: (event: React.PointerEvent) => void;
+    /** Triggered when pointer enters element. @group Events */
+    onPointerEnter?: (event: React.PointerEvent) => void;
+}
+/**
+ * An enhanced hook that standardizes event processing across all EzUX components.
+ *
+ * Provides pre-bound, memoized handlers for DND, keyboard, mouse, and pointer events,
+ * ensuring consistent behavior and high performance.
+ *
+ * @param config Configuration of desired event callbacks.
+ * @group Hooks
+ */
+export declare function useEventHandlers(config: EventHandlerConfig): {
+    handleDragStart: (event: DragStartEvent) => void;
+    handleDragOver: (event: DragOverEvent) => void;
+    handleDragEnd: (event: DragEndEvent) => void;
+    handleKeyPress: (event: React.KeyboardEvent) => void;
+    handleKeyDown: (event: React.KeyboardEvent) => void;
+    handleKeyUp: (event: React.KeyboardEvent) => void;
+    handleClick: (event: React.MouseEvent) => void;
+    handleDoubleClick: (event: React.MouseEvent) => void;
+    handlePointerDown: (event: React.PointerEvent) => void;
+    handlePointerMove: (event: React.PointerEvent) => void;
+    handlePointerUp: (event: React.PointerEvent) => void;
+    handlePointerLeave: (event: React.PointerEvent) => void;
+    handlePointerEnter: (event: React.PointerEvent) => void;
+    handleFocus: () => void;
+    handleBlur: () => void;
+};

package/dist/shared/hooks/useEzTheme.d.ts

@@ -0,0 +1,22 @@
+import { ThemeMode, ThemeColor } from '../services/ThemeService';
+/**
+ * Hook for accessing and controlling the library's theme state.
+ *
+ * Provides current theme mode (light/dark/system), primary colors, and UI radius settings.
+ * Automatically synchronizes with the global `ThemeService`.
+ *
+ * @group Hooks
+ */
+export declare const useEzTheme: () => {
+    /** Sets the theme mode (light, dark, or system). @group Methods */
+    setMode: (mode: ThemeMode) => void;
+    /** Toggles between light and dark modes. @group Methods */
+    toggleMode: () => void;
+    /** Updates the primary theme color. @group Methods */
+    setThemeColor: (color: ThemeColor) => void;
+    /** Updates the global border radius setting. @group Methods */
+    setRadius: (radius: number) => void;
+    mode: ThemeMode;
+    themeColor: ThemeColor;
+    radius: number;
+};

package/dist/shared/hooks/useFieldValidation.d.ts

@@ -0,0 +1,24 @@
+export interface ValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+export interface ValidationParams<T = any> {
+    fieldName: string;
+    value: any;
+    data: T;
+}
+export interface FieldValidationProps<T = any> {
+    validateField?: (params: ValidationParams<T>) => boolean | string;
+    editSettings?: {
+        requiredFields?: string[];
+        validationRules?: Record<string, (value: any, data: T) => boolean | string>;
+    };
+}
+/**
+ * Shared hook for field validation logic.
+ * Consolidates validation patterns and reduces duplication.
+ */
+export declare const useFieldValidation: <T = any>(props: FieldValidationProps<T>) => {
+    validate: (fieldName: string, value: any, data: T) => ValidationResult;
+    validateForm: (data: T, fieldsToValidate: string[]) => Record<string, ValidationResult>;
+};

package/dist/shared/hooks/useHistory.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hook for managing Undo/Redo state history
+ */
+export declare const useHistory: <T>(initialPresent: T, limit?: number) => {
+    state: T;
+    undo: () => void;
+    redo: () => void;
+    pushState: (newPresent: T) => void;
+    clear: (newInitialState?: T) => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    historyCount: number;
+};

package/dist/shared/hooks/useI18n.d.ts

@@ -0,0 +1,9 @@
+import { I18nService } from '../services/I18nService';
+/**
+ * Hook for accessing the internationalization service.
+ *
+ * Provides access to the `I18nService` for translation, localization, and language management.
+ *
+ * @group Hooks
+ */
+export declare const useI18n: () => I18nService;

package/dist/shared/hooks/useImperativeAPI.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'react';
+/**
+ * A shared hook to consolidate the imperative API pattern using useImperativeHandle.
+ *
+ * @param ref The ref object from the forwardRef or parent component.
+ * @param api An object containing the methods and properties to expose.
+ */
+export declare const useImperativeAPI: <T extends Record<string, any>>(ref: Ref<T> | undefined, api: T) => void;

package/dist/shared/hooks/useInitCoreServices.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to ensure core services are registered in the global service registry.
+ * This is crucial for isolated environments like Storybook or unit tests.
+ */
+export declare const useInitCoreServices: () => void;

package/dist/shared/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Configuration for the useKeyboardNavigation hook.
+ * @group Properties
+ */
+interface KeyboardNavigationOptions {
+    /** Total number of items in the navigable list. @group Data */
+    totalItems: number;
+    /** Number of columns for grid navigation (use 1 for simple lists). @default 1 @group Properties */
+    columns?: number;
+    /** Callback triggered when focus moves to a new index. @group Events */
+    onSelect?: (index: number) => void;
+    /** Callback triggered when the Enter key is pressed on a focused item. @group Events */
+    onAction?: (index: number) => void;
+    /** Callback triggered when the Escape key is pressed. @group Events */
+    onCancel?: () => void;
+    /** Whether navigation should wrap around at boundaries. @default true @group Properties */
+    wrap?: boolean;
+    /** Whether keyboard listening is currently active. @default true @group Properties */
+    enabled?: boolean;
+}
+/**
+ * Hook for managing keyboard focus and selection in lists and grids.
+ *
+ * Implements standard directional arrow key navigation, Enter for action,
+ * and Escape for cancellation/unfocus.
+ *
+ * @param options Keyboard navigation behavior configuration.
+ * @group Hooks
+ */
+export declare const useKeyboardNavigation: ({ totalItems, columns, onSelect, onAction, onCancel, wrap, enabled }: KeyboardNavigationOptions) => {
+    /** The current focused index (-1 if none). @group State */
+    selectedIndex: number;
+    /** Manually sets the focused index. @group Methods */
+    setSelectedIndex: import('react').Dispatch<import('react').SetStateAction<number>>;
+};
+export {};

package/dist/shared/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,14 @@
+export interface KeyboardShortcutConfig {
+    key: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    handler: (event: KeyboardEvent) => void;
+    preventDefault?: boolean;
+}
+/**
+ * Hook for registering keyboard shortcuts
+ * Automatically handles Ctrl (Windows/Linux) and Cmd (Mac) modifiers
+ */
+export declare const useKeyboardShortcuts: (shortcuts: KeyboardShortcutConfig[]) => void;

package/dist/shared/hooks/useLifecycleEvents.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lifecycle event callbacks that can be shared across components.
+ * Used by EzTable, EzScheduler, EzTreeView for render lifecycle.
+ */
+export interface LifecycleCallbacks {
+    /** Called before the component paints (synchronous with layout) */
+    onRenderStart?: () => void;
+    /** Called after the component has painted (asynchronous) */
+    onRenderComplete?: () => void;
+}
+/**
+ * Shared hook to handle render lifecycle events.
+ * - onRenderStart fires in useLayoutEffect (before browser paint)
+ * - onRenderComplete fires in useEffect (after browser paint)
+ *
+ * @example
+ * useLifecycleEvents({
+ *   onRenderStart: () => console.log('Rendering...'),
+ *   onRenderComplete: () => console.log('Rendered!')
+ * });
+ */
+export declare const useLifecycleEvents: (callbacks: LifecycleCallbacks) => void;

package/dist/shared/hooks/useLoadingState.d.ts

@@ -0,0 +1,17 @@
+interface UseLoadingStateOptions {
+    initialState?: boolean;
+    onError?: (error: any) => void;
+}
+/**
+ * Shared hook for managing loading states and lifecycle.
+ */
+export declare function useLoadingState(options?: UseLoadingStateOptions): {
+    isLoading: boolean;
+    error: Error | null;
+    startLoading: () => void;
+    stopLoading: () => void;
+    setIsLoading: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    setError: import('react').Dispatch<import('react').SetStateAction<Error | null>>;
+    wrapPromise: <T>(promise: Promise<T>) => Promise<T | undefined>;
+};
+export {};

package/dist/shared/hooks/useMediaQuery.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Custom hook to monitor media query status.
+ * @param query CSS media query string (e.g., '(max-width: 768px)')
+ * @returns boolean indicating if the media query matches
+ */
+export declare function useMediaQuery(query: string): boolean;

package/dist/shared/hooks/useNotificationService.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Internal hook to ensure the `NotificationService` is registered and initialized.
+ *
+ * Typically used by components that provide user feedback via snackbars or alerts.
+ *
+ * @group Hooks
+ */
+export declare const useNotificationService: () => void;

package/dist/shared/hooks/usePerformanceMonitor.d.ts

@@ -0,0 +1,15 @@
+export interface PerformanceMetrics {
+    renderCount: number;
+    lastRenderTime: number;
+    averageRenderTime: number;
+    memoryUsage?: number;
+}
+/**
+ * Hook for monitoring component performance
+ * Tracks render count, render time, and memory usage
+ */
+export declare const usePerformanceMonitor: (componentName: string) => PerformanceMetrics;
+/**
+ * Hook for tracking expensive computations
+ */
+export declare const useComputationTime: (label: string) => void;