@nice2dev/ui-platform 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,2484 @@
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { ReactNode } from 'react';
+
+declare interface AutoStartConfig {
+    /** Show splash screen */
+    showSplash?: boolean;
+    /** Splash duration (ms, minimum display time) */
+    splashDuration?: number;
+    /** Auto-hide splash on ready */
+    autoHideSplash?: boolean;
+    /** Show progress */
+    showProgress?: boolean;
+    /** Show task names */
+    showTaskNames?: boolean;
+    /** Global timeout (ms) */
+    globalTimeout?: number;
+    /** Auto-recovery on failure */
+    autoRecovery?: boolean;
+    /** Recovery attempts */
+    recoveryAttempts?: number;
+    /** Recovery delay (ms) */
+    recoveryDelay?: number;
+    /** Check for updates */
+    checkUpdates?: boolean;
+    /** Analytics */
+    sendAnalytics?: boolean;
+}
+
+declare interface AutoStartState {
+    /** Current phase */
+    phase: StartupPhase;
+    /** Is loading */
+    isLoading: boolean;
+    /** Is ready */
+    isReady: boolean;
+    /** Has error */
+    hasError: boolean;
+    /** Error message */
+    errorMessage?: string;
+    /** Current task name */
+    currentTask?: string;
+    /** Progress (0-100) */
+    progress: number;
+    /** Completed tasks */
+    completedTasks: number;
+    /** Total tasks */
+    totalTasks: number;
+    /** Task results */
+    results: StartupTaskResult[];
+    /** Recovery attempt */
+    recoveryAttempt: number;
+    /** Total duration (ms) */
+    totalDuration: number;
+}
+
+declare interface BackgroundSyncConfig {
+    /** IndexedDB database name for queue */
+    dbName?: string;
+    /** IndexedDB store name for queue */
+    storeName?: string;
+    /** Default max retry attempts */
+    defaultMaxAttempts?: number;
+    /** Retry delay in ms */
+    retryDelay?: number;
+    /** Exponential backoff factor */
+    backoffFactor?: number;
+    /** Max retry delay in ms */
+    maxRetryDelay?: number;
+    /** Auto-sync when coming online */
+    autoSyncOnConnect?: boolean;
+    /** Periodic sync interval in ms (0 = disabled) */
+    periodicSyncInterval?: number;
+}
+
+declare interface BackgroundSyncState {
+    /** Is online */
+    isOnline: boolean;
+    /** Is currently syncing */
+    isSyncing: boolean;
+    /** Pending tasks count */
+    pendingCount: number;
+    /** Failed tasks count */
+    failedCount: number;
+    /** Last sync timestamp */
+    lastSyncAt?: Date;
+    /** Current sync progress (0-100) */
+    syncProgress: number;
+    /** Error message */
+    error?: string;
+}
+
+declare type BarcodeFormat = 'aztec' | 'code_128' | 'code_39' | 'code_93' | 'codabar' | 'data_matrix' | 'ean_13' | 'ean_8' | 'itf' | 'pdf417' | 'qr_code' | 'upc_a' | 'upc_e' | 'unknown';
+
+declare type BarcodeFormat_2 = 'aztec' | 'code_128' | 'code_39' | 'code_93' | 'codabar' | 'data_matrix' | 'ean_13' | 'ean_8' | 'itf' | 'pdf417' | 'qr_code' | 'upc_a' | 'upc_e' | 'unknown';
+
+declare type BarcodeGeneratorFormat = 'code128' | 'code39' | 'code93' | 'ean13' | 'ean8' | 'upc' | 'itf14' | 'msi' | 'pharmacode' | 'codabar';
+
+declare interface BarcodeGeneratorOptions {
+    /** Barcode format */
+    format?: BarcodeGeneratorFormat;
+    /** Bar width */
+    width?: number;
+    /** Bar height */
+    height?: number;
+    /** Display value below barcode */
+    displayValue?: boolean;
+    /** Font for text */
+    font?: string;
+    /** Font size */
+    fontSize?: number;
+    /** Text alignment */
+    textAlign?: 'left' | 'center' | 'right';
+    /** Text position */
+    textPosition?: 'top' | 'bottom';
+    /** Text margin */
+    textMargin?: number;
+    /** Background color */
+    background?: string;
+    /** Bar/line color */
+    lineColor?: string;
+    /** Margin around barcode */
+    margin?: number;
+    /** Margin top */
+    marginTop?: number;
+    /** Margin bottom */
+    marginBottom?: number;
+    /** Margin left */
+    marginLeft?: number;
+    /** Margin right */
+    marginRight?: number;
+    /** Flat (no text) */
+    flat?: boolean;
+}
+
+declare interface BarcodeScannerConfig {
+    /** Formats to detect */
+    formats?: BarcodeFormat[];
+    /** Enable continuous scanning */
+    continuous?: boolean;
+    /** Scan interval (ms) for continuous mode */
+    scanInterval?: number;
+    /** Show bounding box overlay */
+    showBoundingBox?: boolean;
+    /** Enable beep on scan */
+    beepOnScan?: boolean;
+    /** Enable vibration on scan */
+    vibrateOnScan?: boolean;
+    /** Auto-focus mode */
+    autoFocus?: boolean;
+    /** Preferred camera facing mode */
+    facingMode?: 'user' | 'environment';
+    /** Resolution */
+    resolution?: 'sd' | 'hd' | 'fhd';
+}
+
+declare interface BarcodeScannerState {
+    /** Is scanner active */
+    isScanning: boolean;
+    /** Is camera ready */
+    isCameraReady: boolean;
+    /** Last scan result */
+    lastResult: BarcodeScanResult | null;
+    /** Error message */
+    error: string | null;
+    /** Is API supported */
+    isSupported: boolean;
+    /** Has camera permission */
+    hasPermission: boolean | null;
+}
+
+declare interface BarcodeScanResult {
+    /** Raw barcode value */
+    rawValue: string;
+    /** Detected format */
+    format: BarcodeFormat;
+    /** Bounding box coordinates */
+    boundingBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Corner points */
+    cornerPoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Scan timestamp */
+    timestamp: Date;
+    /** Confidence (if available) */
+    confidence?: number;
+}
+
+declare type BarcodeSymbology = 'code128' | 'code128a' | 'code128b' | 'code128c' | 'code39' | 'code93' | 'codabar' | 'ean13' | 'ean8' | 'ean5' | 'ean2' | 'upc_a' | 'upc_e' | 'itf' | 'itf14' | 'msi' | 'pharmacode' | 'plessey' | 'telepen' | 'qr_code' | 'data_matrix' | 'aztec' | 'pdf417' | 'maxicode' | 'gs1_128' | 'gs1_databar';
+
+declare interface BatchScannerOptions {
+    /** Allowed formats */
+    formats?: BarcodeFormat_2[];
+    /** Auto-increment quantity on duplicate */
+    autoIncrementDuplicates?: boolean;
+    /** Max items in batch */
+    maxItems?: number;
+    /** Scan interval (ms) */
+    scanInterval?: number;
+    /** Beep on scan */
+    beepOnScan?: boolean;
+    /** Vibrate on scan */
+    vibrateOnScan?: boolean;
+    /** Show bounding box */
+    showBoundingBox?: boolean;
+    /** Allow manual entry */
+    allowManualEntry?: boolean;
+    /** Minimum scan confidence (0-1) */
+    minConfidence?: number;
+}
+
+declare interface CacheConfig {
+    /** Cache name */
+    cacheName?: string;
+    /** Default TTL in ms */
+    defaultTTL?: number;
+    /** Max cache entries */
+    maxEntries?: number;
+    /** Default strategy */
+    defaultStrategy?: CacheStrategy;
+    /** Network timeout before fallback to cache (ms) */
+    networkTimeout?: number;
+    /** Enable stale data serving */
+    serveStale?: boolean;
+    /** Stale threshold in ms */
+    staleThreshold?: number;
+}
+
+declare interface CachedMedia {
+    /** Unique ID */
+    id: string;
+    /** Original URL */
+    url: string;
+    /** Media type */
+    type: MediaType;
+    /** File name */
+    name: string;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+    /** Download status */
+    status: DownloadStatus;
+    /** Download progress (0-100) */
+    progress: number;
+    /** Downloaded bytes */
+    downloadedBytes: number;
+    /** Cached timestamp */
+    cachedAt?: Date;
+    /** Expires at */
+    expiresAt?: Date;
+    /** Blob URL for playback */
+    blobUrl?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Metadata */
+    metadata?: {
+        title?: string;
+        artist?: string;
+        album?: string;
+        duration?: number;
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+        thumbnail?: string;
+        [key: string]: unknown;
+    };
+    /** Tags for organization */
+    tags?: string[];
+    /** Priority (higher = more important) */
+    priority?: number;
+}
+
+declare interface CacheEntry<T = unknown> {
+    /** Cached data */
+    data: T;
+    /** Cache timestamp */
+    timestamp: Date;
+    /** Expiration timestamp */
+    expiresAt?: Date;
+    /** ETag for validation */
+    etag?: string;
+    /** Cache key */
+    key: string;
+    /** Is stale */
+    isStale: boolean;
+    /** Source (cache or network) */
+    source: 'cache' | 'network';
+    /** Request URL */
+    url?: string;
+}
+
+declare interface CacheInfo {
+    name: string;
+    size: number;
+    itemCount: number;
+    lastUpdated?: Date;
+}
+
+declare interface CacheState {
+    /** Is fetching */
+    isFetching: boolean;
+    /** Total cache size (bytes) */
+    totalSize: number;
+    /** Number of entries */
+    entryCount: number;
+    /** Cache hits */
+    hits: number;
+    /** Cache misses */
+    misses: number;
+    /** Current strategy */
+    strategy: CacheStrategy;
+}
+
+declare type CacheStrategy = 'cache-first' | 'network-first' | 'cache-only' | 'network-only' | 'stale-while-revalidate';
+
+declare interface CalibrationConfig {
+    /** Number of calibration points */
+    pointCount?: 4 | 5 | 9;
+    /** Target size in pixels */
+    targetSize?: number;
+    /** Required accuracy (pixels) */
+    accuracyThreshold?: number;
+    /** Timeout per point (ms) */
+    pointTimeout?: number;
+    /** Show accuracy feedback */
+    showAccuracy?: boolean;
+    /** Allow retry on failure */
+    allowRetry?: boolean;
+    /** Save to localStorage */
+    persistCalibration?: boolean;
+    /** Storage key */
+    storageKey?: string;
+    /** Custom target component */
+    targetComponent?: ReactNode;
+}
+
+declare interface CalibrationMatrix {
+    /** Scale X */
+    scaleX: number;
+    /** Scale Y */
+    scaleY: number;
+    /** Offset X */
+    offsetX: number;
+    /** Offset Y */
+    offsetY: number;
+    /** Rotation angle (degrees) */
+    rotation: number;
+}
+
+declare interface CalibrationPoint {
+    /** Target X position (percentage 0-100) */
+    targetX: number;
+    /** Target Y position (percentage 0-100) */
+    targetY: number;
+    /** Actual touch X (if calibrated) */
+    actualX?: number;
+    /** Actual touch Y (if calibrated) */
+    actualY?: number;
+    /** Is calibrated */
+    calibrated: boolean;
+}
+
+declare interface CalibrationState {
+    /** Is calibration active */
+    isActive: boolean;
+    /** Current point index */
+    currentPointIndex: number;
+    /** Total points */
+    totalPoints: number;
+    /** Calibration points */
+    points: CalibrationPoint[];
+    /** Is completed */
+    isCompleted: boolean;
+    /** Is successful */
+    isSuccessful: boolean;
+    /** Calculated matrix */
+    matrix: CalibrationMatrix | null;
+    /** Average error (pixels) */
+    averageError: number;
+}
+
+declare interface ColorCycleConfig {
+    /** Colors to cycle through */
+    colors: string[];
+    /** Cycle interval (ms) */
+    interval: number;
+    /** Transition duration (ms) */
+    transitionDuration: number;
+}
+
+declare type CommandType = 'restart' | 'shutdown' | 'update' | 'config' | 'screenshot' | 'logs' | 'custom';
+
+declare interface Conflict<T = unknown> {
+    /** Unique conflict ID */
+    id: string;
+    /** Entity type (e.g., 'user', 'document') */
+    entityType: string;
+    /** Entity ID */
+    entityId: string;
+    /** Client version */
+    clientVersion: ConflictVersion<T>;
+    /** Server version */
+    serverVersion: ConflictVersion<T>;
+    /** Base version (common ancestor) */
+    baseVersion?: ConflictVersion<T>;
+    /** Conflict status */
+    status: ConflictStatus;
+    /** Resolved version (after resolution) */
+    resolvedVersion?: ConflictVersion<T>;
+    /** Resolution strategy used */
+    resolvedWith?: ConflictResolutionStrategy;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Resolved timestamp */
+    resolvedAt?: Date;
+    /** Error message if failed */
+    error?: string;
+    /** Conflicting fields (for partial conflicts) */
+    conflictingFields?: string[];
+    /** Custom data */
+    customData?: Record<string, unknown>;
+}
+
+declare interface ConflictHandlers<T = unknown> {
+    /** Auto-merge function */
+    merge?: MergeFunction<T>;
+    /** Compare values */
+    compare?: (a: T, b: T) => boolean;
+    /** Get hash for value */
+    hash?: (value: T) => string;
+    /** Get conflicting fields */
+    getConflictingFields?: (client: T, server: T) => string[];
+}
+
+declare interface ConflictResolutionConfig {
+    /** Default resolution strategy */
+    defaultStrategy?: ConflictResolutionStrategy;
+    /** Auto-resolve when possible */
+    autoResolve?: boolean;
+    /** Max pending conflicts before notification */
+    maxPendingConflicts?: number;
+    /** Persist conflicts to storage */
+    persistConflicts?: boolean;
+    /** Storage key for persistence */
+    storageKey?: string;
+}
+
+declare interface ConflictResolutionState {
+    /** Pending conflicts */
+    conflicts: Conflict[];
+    /** Is resolving */
+    isResolving: boolean;
+    /** Count by status */
+    counts: {
+        pending: number;
+        resolving: number;
+        resolved: number;
+        failed: number;
+    };
+}
+
+declare type ConflictResolutionStrategy = 'client-wins' | 'server-wins' | 'latest-wins' | 'merge' | 'manual';
+
+declare type ConflictStatus = 'pending' | 'resolving' | 'resolved' | 'failed';
+
+declare interface ConflictVersion<T = unknown> {
+    /** Version data */
+    data: T;
+    /** Version timestamp */
+    timestamp: Date;
+    /** Version source */
+    source: 'client' | 'server';
+    /** Version ID */
+    versionId?: string;
+    /** Hash for comparison */
+    hash?: string;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+
+declare interface ConnectionInfo {
+    /** Is online */
+    isOnline: boolean;
+    /** Connection type (if available) */
+    type?: ConnectionType;
+    /** Effective connection type */
+    effectiveType?: EffectiveConnectionType;
+    /** Downlink speed (Mbps) */
+    downlink?: number;
+    /** Round-trip time (ms) */
+    rtt?: number;
+    /** Save-data preference */
+    saveData?: boolean;
+    /** Connection quality (0-100) */
+    quality: number;
+    /** Last online timestamp */
+    lastOnlineAt?: Date;
+    /** Offline duration in ms */
+    offlineDuration?: number;
+}
+
+declare type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+
+declare type ConnectionType = 'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'other' | 'none' | 'unknown';
+
+declare interface DeviceInfo {
+    /** Device ID */
+    deviceId: string;
+    /** Device name */
+    name: string;
+    /** Device type */
+    type: string;
+    /** Location */
+    location?: string;
+    /** OS info */
+    os?: string;
+    /** Browser info */
+    browser?: string;
+    /** Screen resolution */
+    resolution?: string;
+    /** IP address */
+    ip?: string;
+    /** Last seen */
+    lastSeen?: Date;
+    /** Uptime (seconds) */
+    uptime?: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+
+declare interface DimmingConfig {
+    /** Dim level (0-1) */
+    level: number;
+    /** Fade duration (ms) */
+    fadeDuration: number;
+}
+
+declare interface DownloadOptions {
+    /** Media type (auto-detected if not provided) */
+    type?: MediaType;
+    /** Custom name */
+    name?: string;
+    /** Cache duration in ms */
+    cacheDuration?: number;
+    /** Priority */
+    priority?: number;
+    /** Tags */
+    tags?: string[];
+    /** Metadata */
+    metadata?: CachedMedia['metadata'];
+    /** Headers for request */
+    headers?: Record<string, string>;
+}
+
+declare type DownloadStatus = 'queued' | 'downloading' | 'paused' | 'completed' | 'failed' | 'cancelled';
+
+declare type EffectiveConnectionType = 'slow-2g' | '2g' | '3g' | '4g';
+
+declare type ExitMethod = 'keyboard' | 'pin' | 'gesture' | 'admin';
+
+declare interface ExternalDisplayConfig {
+    /** Auto-detect screens */
+    autoDetect?: boolean;
+    /** Poll interval for screen changes (ms) */
+    pollInterval?: number;
+    /** Default window features */
+    defaultFeatures?: WindowFeatures;
+    /** Allow multi-window */
+    allowMultiWindow?: boolean;
+    /** Sync content across windows */
+    syncContent?: boolean;
+}
+
+declare interface ExternalDisplayState {
+    /** Available screens */
+    screens: ScreenInfo[];
+    /** Primary screen */
+    primaryScreen: ScreenInfo | null;
+    /** External screens */
+    externalScreens: ScreenInfo[];
+    /** Open windows */
+    windows: WindowInfo[];
+    /** Is multi-screen API available */
+    isApiAvailable: boolean;
+    /** Permission state */
+    permissionState: 'prompt' | 'granted' | 'denied' | 'unknown';
+}
+
+declare interface FetchOptions extends RequestInit {
+    /** Override strategy for this request */
+    strategy?: CacheStrategy;
+    /** Override TTL for this request */
+    ttl?: number;
+    /** Cache key (defaults to URL) */
+    cacheKey?: string;
+    /** Force refresh cache */
+    forceRefresh?: boolean;
+    /** Timeout for network request */
+    timeout?: number;
+}
+
+declare interface FormDraft<T = Record<string, unknown>> {
+    /** Draft ID */
+    id: string;
+    /** Form ID/name */
+    formId: string;
+    /** Form data */
+    data: T;
+    /** Current status */
+    status: FormStatus;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Last modified timestamp */
+    modifiedAt: Date;
+    /** Last synced timestamp */
+    syncedAt?: Date;
+    /** Submission attempt count */
+    attempts: number;
+    /** Error message if failed */
+    error?: string;
+    /** Version for conflict detection */
+    version: number;
+    /** Was submitted while offline */
+    submittedOffline: boolean;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+
+declare type FormStatus = 'draft' | 'pending' | 'syncing' | 'synced' | 'failed';
+
+declare interface FormSubmitHandler<T = Record<string, unknown>> {
+    (data: T, draft: FormDraft<T>): Promise<void>;
+}
+
+declare interface HealthMetrics {
+    /** CPU usage (0-100) */
+    cpu?: number;
+    /** Memory usage (0-100) */
+    memory?: number;
+    /** Network latency (ms) */
+    latency?: number;
+    /** Battery level (0-100) */
+    battery?: number;
+    /** Storage free (bytes) */
+    storageFree?: number;
+    /** Temperature (celsius) */
+    temperature?: number;
+    /** Is online */
+    isOnline: boolean;
+    /** Last updated */
+    lastUpdated: Date;
+}
+
+declare interface IndexedDBConfig {
+    /** Database name */
+    dbName: string;
+    /** Database version (increment to trigger upgrade) */
+    version: number;
+    /** Object stores configuration */
+    stores: IndexedDBStoreConfig[];
+    /** Called during upgrade */
+    onUpgrade?: (db: IDBDatabase, oldVersion: number, newVersion: number | null) => void;
+    /** Called when blocked by another connection */
+    onBlocked?: () => void;
+}
+
+declare interface IndexedDBIndex {
+    name: string;
+    keyPath: string | string[];
+    options?: IDBIndexParameters;
+}
+
+declare interface IndexedDBState {
+    /** Database instance */
+    db?: IDBDatabase;
+    /** Is database open */
+    isOpen: boolean;
+    /** Is performing operation */
+    isLoading: boolean;
+    /** Error message */
+    error?: string;
+    /** Database version */
+    version?: number;
+    /** Store names */
+    storeNames: string[];
+}
+
+declare interface IndexedDBStoreConfig {
+    /** Store name */
+    name: string;
+    /** Key path for objects */
+    keyPath?: string;
+    /** Auto-increment keys */
+    autoIncrement?: boolean;
+    /** Indexes to create */
+    indexes?: IndexedDBIndex[];
+}
+
+declare type IndicatorMode = 'banner' | 'badge' | 'toast' | 'minimal' | 'detailed' | 'icon-only';
+
+declare type IndicatorPosition = 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'inline';
+
+declare interface KioskConfig {
+    /** Enable fullscreen on start */
+    autoFullscreen?: boolean;
+    /** Lock navigation (disable browser chrome) */
+    lockNavigation?: boolean;
+    /** Disable context menu */
+    disableContextMenu?: boolean;
+    /** Disable keyboard shortcuts (F5, Ctrl+R, etc.) */
+    disableShortcuts?: boolean;
+    /** Disable text selection */
+    disableSelection?: boolean;
+    /** Disable copy/paste */
+    disableCopyPaste?: boolean;
+    /** Exit PIN code */
+    exitPin?: string;
+    /** Exit keyboard shortcut (default: Ctrl+Shift+K) */
+    exitShortcut?: string;
+    /** Number of taps to trigger admin access */
+    adminTapCount?: number;
+    /** Admin tap timeout (ms) */
+    adminTapTimeout?: number;
+    /** Inactivity timeout (ms) for screensaver */
+    inactivityTimeout?: number;
+    /** Show cursor */
+    showCursor?: boolean;
+    /** Allow scrolling */
+    allowScrolling?: boolean;
+    /** Custom CSS class */
+    className?: string;
+}
+
+declare type KioskMode = 'fullscreen' | 'windowed' | 'locked';
+
+declare interface KioskState {
+    /** Current mode */
+    mode: KioskMode;
+    /** Is fullscreen */
+    isFullscreen: boolean;
+    /** Is locked */
+    isLocked: boolean;
+    /** Is admin mode */
+    isAdminMode: boolean;
+    /** Is screensaver active */
+    isScreensaverActive: boolean;
+    /** Time since last interaction */
+    idleTime: number;
+    /** Is PIN dialog open */
+    isPinDialogOpen: boolean;
+}
+
+declare interface LowPowerConfig {
+    /** Power modes configuration */
+    modes?: Partial<Record<PowerMode, Partial<PowerModeConfig>>>;
+    /** Initial mode */
+    initialMode?: PowerMode;
+    /** Auto-dim timeout (ms) */
+    autoDimTimeout?: number;
+    /** Auto-sleep timeout (ms) */
+    autoSleepTimeout?: number;
+    /** Low battery threshold (0-100) */
+    lowBatteryThreshold?: number;
+    /** Critical battery threshold (0-100) */
+    criticalBatteryThreshold?: number;
+    /** Enable wake on touch */
+    wakeOnTouch?: boolean;
+    /** Enable wake on motion */
+    wakeOnMotion?: boolean;
+    /** Brightness transition duration (ms) */
+    transitionDuration?: number;
+    /** Schedule-based power modes */
+    schedule?: Array<{
+        startHour: number;
+        endHour: number;
+        mode: PowerMode;
+    }>;
+}
+
+declare interface LowPowerState {
+    /** Current power mode */
+    currentMode: PowerMode;
+    /** Current brightness (0-1) */
+    brightness: number;
+    /** Is in power saving mode */
+    isPowerSaving: boolean;
+    /** Is sleeping */
+    isSleeping: boolean;
+    /** Battery level (0-100, if available) */
+    batteryLevel?: number;
+    /** Is charging */
+    isCharging?: boolean;
+    /** Idle time (ms) */
+    idleTime: number;
+    /** Is display on */
+    isDisplayOn: boolean;
+    /** Scheduled mode active */
+    scheduledModeActive?: PowerMode;
+}
+
+declare type MediaType = 'image' | 'video' | 'audio' | 'document' | 'other';
+
+declare interface MergeFunction<T = unknown> {
+    (client: T, server: T, base?: T): T | Promise<T>;
+}
+
+export declare const NiceAutoStart: default_2.ForwardRefExoticComponent<NiceAutoStartProps & default_2.RefAttributes<NiceAutoStartRef>>;
+
+declare interface NiceAutoStartProps {
+    /** Startup tasks */
+    tasks?: StartupTask[];
+    /** Configuration */
+    config?: AutoStartConfig;
+    /** Splash screen component */
+    splash?: ReactNode;
+    /** Error screen component */
+    errorScreen?: ReactNode;
+    /** On startup complete */
+    onComplete?: (results: StartupTaskResult[]) => void;
+    /** On task complete */
+    onTaskComplete?: (result: StartupTaskResult) => void;
+    /** On error */
+    onError?: (error: Error, taskId?: string) => void;
+    /** On recovery */
+    onRecovery?: (attempt: number) => void;
+    /** Children (shown when ready) */
+    children?: ReactNode;
+}
+
+declare interface NiceAutoStartRef {
+    /** Get current state */
+    getState: () => AutoStartState;
+    /** Restart startup */
+    restart: () => Promise<void>;
+    /** Skip startup (force ready) */
+    skip: () => void;
+    /** Add task */
+    addTask: (task: StartupTask) => void;
+    /** Remove task */
+    removeTask: (taskId: string) => void;
+    /** Get task result */
+    getTaskResult: (taskId: string) => StartupTaskResult | undefined;
+    /** Hide splash */
+    hideSplash: () => void;
+    /** Trigger recovery */
+    recover: () => Promise<void>;
+}
+
+export declare const NiceBackgroundSync: default_2.ForwardRefExoticComponent<NiceBackgroundSyncProps & default_2.RefAttributes<NiceBackgroundSyncRef>>;
+
+declare interface NiceBackgroundSyncProps {
+    /** Configuration */
+    config?: BackgroundSyncConfig;
+    /** Sync handlers by tag */
+    handlers: Record<string, SyncHandler>;
+    /** Callback when sync starts */
+    onSyncStart?: () => void;
+    /** Callback when sync completes */
+    onSyncComplete?: (results: {
+        success: number;
+        failed: number;
+    }) => void;
+    /** Callback when task succeeds */
+    onTaskSuccess?: (task: SyncTask) => void;
+    /** Callback when task fails */
+    onTaskFailed?: (task: SyncTask, error: Error) => void;
+    /** Callback on online status change */
+    onOnlineChange?: (isOnline: boolean) => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceBackgroundSyncRef {
+    /** Get current state */
+    getState: () => BackgroundSyncState;
+    /** Add task to sync queue */
+    addTask: <T = unknown>(tag: string, data: T, options?: Partial<Pick<SyncTask, 'priority' | 'maxAttempts'>>) => Promise<string>;
+    /** Remove task from queue */
+    removeTask: (taskId: string) => Promise<boolean>;
+    /** Get all tasks */
+    getTasks: (tag?: string) => Promise<SyncTask[]>;
+    /** Get pending tasks */
+    getPendingTasks: (tag?: string) => Promise<SyncTask[]>;
+    /** Get failed tasks */
+    getFailedTasks: (tag?: string) => Promise<SyncTask[]>;
+    /** Retry failed task */
+    retryTask: (taskId: string) => Promise<void>;
+    /** Retry all failed tasks */
+    retryAllFailed: (tag?: string) => Promise<void>;
+    /** Clear all tasks */
+    clearTasks: (tag?: string) => Promise<void>;
+    /** Clear failed tasks */
+    clearFailed: (tag?: string) => Promise<void>;
+    /** Trigger sync now */
+    syncNow: (tag?: string) => Promise<{
+        success: number;
+        failed: number;
+    }>;
+    /** Cancel ongoing sync */
+    cancelSync: () => void;
+    /** Register Background Sync API */
+    registerBackgroundSync: (tag: string) => Promise<boolean>;
+}
+
+declare interface NiceBarcodeGeneratorProps {
+    /** Value to encode */
+    value: string;
+    /** Generator options */
+    options?: BarcodeGeneratorOptions;
+    /** On generation complete */
+    onGenerate?: (dataUrl: string) => void;
+    /** On error */
+    onError?: (error: Error) => void;
+    /** Show border */
+    showBorder?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+
+declare interface NiceBarcodeGeneratorRef {
+    /** Get data URL */
+    toDataURL: (type?: string, quality?: number) => string | null;
+    /** Get SVG string */
+    toSVG: () => string | null;
+    /** Get canvas element */
+    getCanvas: () => HTMLCanvasElement | null;
+    /** Download barcode */
+    download: (filename?: string, type?: 'png' | 'svg') => void;
+    /** Regenerate barcode */
+    regenerate: () => void;
+}
+
+export declare const NiceBarcodeScanner: default_2.ForwardRefExoticComponent<NiceBarcodeScannerProps & default_2.RefAttributes<NiceBarcodeScannerRef>>;
+
+declare interface NiceBarcodeScannerProps {
+    /** Configuration */
+    config?: BarcodeScannerConfig;
+    /** On successful scan */
+    onScan?: (result: BarcodeScanResult) => void;
+    /** On multiple scans (batch mode) */
+    onBatchScan?: (results: BarcodeScanResult[]) => void;
+    /** On error */
+    onError?: (error: Error) => void;
+    /** On camera ready */
+    onCameraReady?: () => void;
+    /** Custom scan frame */
+    customScanFrame?: ReactNode;
+    /** Show scan frame */
+    showScanFrame?: boolean;
+    /** Start scanning on mount */
+    autoStart?: boolean;
+    /** Children (overlay content) */
+    children?: ReactNode;
+    /** Additional class name */
+    className?: string;
+}
+
+declare interface NiceBarcodeScannerRef {
+    /** Get current state */
+    getState: () => BarcodeScannerState;
+    /** Start scanning */
+    start: () => Promise<void>;
+    /** Stop scanning */
+    stop: () => void;
+    /** Toggle scanning */
+    toggle: () => Promise<void>;
+    /** Take snapshot */
+    takeSnapshot: () => string | null;
+    /** Switch camera */
+    switchCamera: () => Promise<void>;
+    /** Request permission */
+    requestPermission: () => Promise<boolean>;
+}
+
+export declare const NiceBatchScanner: default_2.ForwardRefExoticComponent<NiceBatchScannerProps & default_2.RefAttributes<NiceBatchScannerRef>>;
+
+declare interface NiceBatchScannerProps {
+    /** Scanner options */
+    options?: BatchScannerOptions;
+    /** Initial items */
+    initialItems?: ScannedItem[];
+    /** On item scanned */
+    onScan?: (item: ScannedItem) => void;
+    /** On item removed */
+    onRemove?: (item: ScannedItem) => void;
+    /** On batch complete */
+    onBatchComplete?: (items: ScannedItem[]) => void;
+    /** On quantity change */
+    onQuantityChange?: (item: ScannedItem, newQuantity: number) => void;
+    /** On error */
+    onError?: (error: Error) => void;
+    /** Validate scan */
+    validateScan?: (value: string, format: BarcodeFormat_2) => boolean | Promise<boolean>;
+    /** Transform value */
+    transformValue?: (value: string, format: BarcodeFormat_2) => string;
+    /** Class name */
+    className?: string;
+    /** Children */
+    children?: default_2.ReactNode;
+}
+
+declare interface NiceBatchScannerRef {
+    /** Start scanning */
+    startScanning: () => Promise<void>;
+    /** Stop scanning */
+    stopScanning: () => void;
+    /** Get all items */
+    getItems: () => ScannedItem[];
+    /** Add item manually */
+    addItem: (value: string, format?: BarcodeFormat_2) => void;
+    /** Remove item */
+    removeItem: (id: string) => void;
+    /** Update quantity */
+    updateQuantity: (id: string, quantity: number) => void;
+    /** Clear all items */
+    clearAll: () => void;
+    /** Export as CSV */
+    exportCSV: () => string;
+    /** Export as JSON */
+    exportJSON: () => string;
+    /** Is scanning */
+    isScanning: () => boolean;
+}
+
+export declare const NiceCacheStrategies: default_2.ForwardRefExoticComponent<NiceCacheStrategiesProps & default_2.RefAttributes<NiceCacheStrategiesRef>>;
+
+declare interface NiceCacheStrategiesProps {
+    /** Configuration */
+    config?: CacheConfig;
+    /** Route-specific strategies */
+    routeStrategies?: Record<string, CacheStrategy>;
+    /** URLs to precache */
+    precacheUrls?: string[];
+    /** Callback when data fetched */
+    onFetch?: <T>(entry: CacheEntry<T>) => void;
+    /** Callback on cache hit */
+    onCacheHit?: <T>(entry: CacheEntry<T>) => void;
+    /** Callback on cache miss */
+    onCacheMiss?: (url: string) => void;
+    /** Callback on network error */
+    onNetworkError?: (error: Error, url: string) => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceCacheStrategiesRef {
+    /** Get current state */
+    getState: () => CacheState;
+    /** Fetch with caching */
+    fetch: <T = unknown>(url: string, options?: FetchOptions) => Promise<CacheEntry<T>>;
+    /** Fetch JSON with caching */
+    fetchJSON: <T = unknown>(url: string, options?: FetchOptions) => Promise<T>;
+    /** Get from cache only */
+    getFromCache: <T = unknown>(key: string) => Promise<CacheEntry<T> | undefined>;
+    /** Add to cache manually */
+    addToCache: <T = unknown>(key: string, data: T, ttl?: number) => Promise<void>;
+    /** Remove from cache */
+    removeFromCache: (key: string) => Promise<boolean>;
+    /** Clear entire cache */
+    clearCache: () => Promise<void>;
+    /** Get all cache keys */
+    getCacheKeys: () => Promise<string[]>;
+    /** Get cache stats */
+    getCacheStats: () => Promise<{
+        size: number;
+        entryCount: number;
+        oldestEntry?: Date;
+        newestEntry?: Date;
+    }>;
+    /** Prefetch URLs */
+    prefetch: (urls: string[], options?: FetchOptions) => Promise<void>;
+    /** Check if cached */
+    isCached: (key: string) => Promise<boolean>;
+    /** Invalidate by pattern */
+    invalidateByPattern: (pattern: RegExp) => Promise<number>;
+    /** Set default strategy */
+    setStrategy: (strategy: CacheStrategy) => void;
+    /** Get strategy for URL */
+    getStrategyForUrl: (url: string) => CacheStrategy;
+}
+
+export declare const NiceConflictResolution: default_2.ForwardRefExoticComponent<NiceConflictResolutionProps & default_2.RefAttributes<NiceConflictResolutionRef>>;
+
+declare interface NiceConflictResolutionProps {
+    /** Configuration */
+    config?: ConflictResolutionConfig;
+    /** Handlers by entity type */
+    handlers?: Record<string, ConflictHandlers>;
+    /** Show conflict UI */
+    showConflictUI?: boolean;
+    /** Position for conflict UI */
+    uiPosition?: 'modal' | 'drawer' | 'inline' | 'toast';
+    /** Auto-open UI on new conflict */
+    autoOpenUI?: boolean;
+    /** Callback when conflict detected */
+    onConflictDetected?: (conflict: Conflict) => void;
+    /** Callback when conflict resolved */
+    onConflictResolved?: (conflict: Conflict) => void;
+    /** Callback when resolution fails */
+    onResolutionFailed?: (conflict: Conflict, error: Error) => void;
+    /** Custom conflict list renderer */
+    renderConflictList?: (props: {
+        conflicts: Conflict[];
+        onResolve: (id: string, strategy: ConflictResolutionStrategy, mergedData?: unknown) => void;
+        onDismiss: (id: string) => void;
+    }) => ReactNode;
+    /** Custom conflict item renderer */
+    renderConflictItem?: (props: {
+        conflict: Conflict;
+        onResolve: (strategy: ConflictResolutionStrategy, mergedData?: unknown) => void;
+        onDismiss: () => void;
+    }) => ReactNode;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceConflictResolutionRef {
+    /** Get current state */
+    getState: () => ConflictResolutionState;
+    /** Detect conflict */
+    detectConflict: <T = unknown>(entityType: string, entityId: string, clientVersion: ConflictVersion<T>, serverVersion: ConflictVersion<T>, baseVersion?: ConflictVersion<T>) => Conflict<T> | null;
+    /** Add conflict */
+    addConflict: <T = unknown>(conflict: Conflict<T>) => void;
+    /** Resolve conflict with strategy */
+    resolveConflict: (conflictId: string, strategy: ConflictResolutionStrategy, mergedData?: unknown) => Promise<void>;
+    /** Resolve all conflicts with strategy */
+    resolveAll: (strategy: ConflictResolutionStrategy) => Promise<void>;
+    /** Get conflict by ID */
+    getConflict: (conflictId: string) => Conflict | undefined;
+    /** Get conflicts by entity */
+    getConflictsByEntity: (entityType: string, entityId?: string) => Conflict[];
+    /** Get pending conflicts */
+    getPendingConflicts: () => Conflict[];
+    /** Dismiss conflict (remove without resolving) */
+    dismissConflict: (conflictId: string) => void;
+    /** Clear resolved conflicts */
+    clearResolved: () => void;
+    /** Clear all conflicts */
+    clearAll: () => void;
+    /** Open conflict UI */
+    openUI: () => void;
+    /** Close conflict UI */
+    closeUI: () => void;
+}
+
+export declare const NiceExternalDisplay: default_2.ForwardRefExoticComponent<NiceExternalDisplayProps & default_2.RefAttributes<NiceExternalDisplayRef>>;
+
+declare interface NiceExternalDisplayProps {
+    /** Configuration */
+    config?: ExternalDisplayConfig;
+    /** On screens change */
+    onScreensChange?: (screens: ScreenInfo[]) => void;
+    /** On window open */
+    onWindowOpen?: (info: WindowInfo) => void;
+    /** On window close */
+    onWindowClose?: (info: WindowInfo) => void;
+    /** On permission change */
+    onPermissionChange?: (state: 'prompt' | 'granted' | 'denied' | 'unknown') => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceExternalDisplayRef {
+    /** Get current state */
+    getState: () => ExternalDisplayState;
+    /** Request screen permission */
+    requestPermission: () => Promise<boolean>;
+    /** Get available screens */
+    getScreens: () => Promise<ScreenInfo[]>;
+    /** Open window on screen */
+    openWindow: (screen: ScreenInfo, url?: string, features?: WindowFeatures) => Promise<WindowInfo | null>;
+    /** Close window */
+    closeWindow: (windowId: string) => void;
+    /** Close all windows */
+    closeAllWindows: () => void;
+    /** Move window to screen */
+    moveWindowToScreen: (windowId: string, screen: ScreenInfo) => void;
+    /** Toggle fullscreen */
+    toggleFullscreen: (windowId: string) => Promise<boolean>;
+    /** Send message to window */
+    sendMessage: (windowId: string, message: unknown) => void;
+    /** Broadcast message to all windows */
+    broadcast: (message: unknown) => void;
+}
+
+export declare const NiceHardwareBarcodeGenerator: default_2.ForwardRefExoticComponent<NiceBarcodeGeneratorProps & default_2.RefAttributes<NiceBarcodeGeneratorRef>>;
+
+export declare const NiceHardwareQRGenerator: default_2.ForwardRefExoticComponent<NiceQRGeneratorProps & default_2.RefAttributes<NiceQRGeneratorRef>>;
+
+export declare const NiceIndexedDB: default_2.ForwardRefExoticComponent<NiceIndexedDBProps & default_2.RefAttributes<NiceIndexedDBRef>>;
+
+declare interface NiceIndexedDBProps {
+    /** Database configuration */
+    config: IndexedDBConfig;
+    /** Open database on mount */
+    autoOpen?: boolean;
+    /** Callback when database opens */
+    onOpen?: (db: IDBDatabase) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Callback when database closes */
+    onClose?: () => void;
+    /** Children to render */
+    children?: ReactNode;
+}
+
+declare interface NiceIndexedDBRef {
+    /** Get current state */
+    getState: () => IndexedDBState;
+    /** Open database */
+    open: () => Promise<IDBDatabase>;
+    /** Close database */
+    close: () => void;
+    /** Delete database */
+    deleteDatabase: () => Promise<void>;
+    /** Get item by key */
+    get: <T = unknown>(storeName: string, key: IDBValidKey) => Promise<T | undefined>;
+    /** Get all items */
+    getAll: <T = unknown>(storeName: string, options?: QueryOptions) => Promise<T[]>;
+    /** Get all keys */
+    getAllKeys: (storeName: string, options?: QueryOptions) => Promise<IDBValidKey[]>;
+    /** Add item (fails if exists) */
+    add: <T = unknown>(storeName: string, value: T, key?: IDBValidKey) => Promise<IDBValidKey>;
+    /** Put item (upsert) */
+    put: <T = unknown>(storeName: string, value: T, key?: IDBValidKey) => Promise<IDBValidKey>;
+    /** Delete item */
+    delete: (storeName: string, key: IDBValidKey) => Promise<void>;
+    /** Clear all items in store */
+    clear: (storeName: string) => Promise<void>;
+    /** Count items */
+    count: (storeName: string, key?: IDBValidKey | IDBKeyRange) => Promise<number>;
+    /** Query with index */
+    query: <T = unknown>(storeName: string, options: QueryOptions) => Promise<T[]>;
+    /** Execute transaction */
+    transaction: <T>(options: TransactionOptions, callback: (tx: IDBTransaction) => Promise<T>) => Promise<T>;
+    /** Bulk add items */
+    bulkAdd: <T = unknown>(storeName: string, items: T[]) => Promise<IDBValidKey[]>;
+    /** Bulk put items */
+    bulkPut: <T = unknown>(storeName: string, items: T[]) => Promise<IDBValidKey[]>;
+    /** Bulk delete items */
+    bulkDelete: (storeName: string, keys: IDBValidKey[]) => Promise<void>;
+    /** Get database info */
+    getInfo: () => Promise<{
+        name: string;
+        version: number;
+        stores: {
+            name: string;
+            keyPath: string | string[] | null;
+            autoIncrement: boolean;
+            indexNames: string[];
+        }[];
+    }>;
+}
+
+export declare const NiceKioskMode: default_2.ForwardRefExoticComponent<NiceKioskModeProps & default_2.RefAttributes<NiceKioskModeRef>>;
+
+declare interface NiceKioskModeProps {
+    /** Configuration */
+    config?: KioskConfig;
+    /** Children content */
+    children?: ReactNode;
+    /** Screensaver component */
+    screensaver?: ReactNode;
+    /** Admin panel component */
+    adminPanel?: ReactNode;
+    /** On mode change */
+    onModeChange?: (mode: KioskMode) => void;
+    /** On fullscreen change */
+    onFullscreenChange?: (isFullscreen: boolean) => void;
+    /** On admin access */
+    onAdminAccess?: () => void;
+    /** On inactivity */
+    onInactivity?: () => void;
+    /** On activity */
+    onActivity?: () => void;
+    /** On exit request */
+    onExitRequest?: (method: ExitMethod) => boolean | Promise<boolean>;
+}
+
+declare interface NiceKioskModeRef {
+    /** Get current state */
+    getState: () => KioskState;
+    /** Enter fullscreen */
+    enterFullscreen: () => Promise<void>;
+    /** Exit fullscreen */
+    exitFullscreen: () => Promise<void>;
+    /** Toggle fullscreen */
+    toggleFullscreen: () => Promise<void>;
+    /** Lock kiosk */
+    lock: () => void;
+    /** Unlock kiosk */
+    unlock: (pin?: string) => boolean;
+    /** Enter admin mode */
+    enterAdminMode: () => void;
+    /** Exit admin mode */
+    exitAdminMode: () => void;
+    /** Reset inactivity timer */
+    resetIdleTimer: () => void;
+    /** Show screensaver */
+    showScreensaver: () => void;
+    /** Hide screensaver */
+    hideScreensaver: () => void;
+    /** Open PIN dialog */
+    openPinDialog: () => void;
+    /** Close PIN dialog */
+    closePinDialog: () => void;
+}
+
+export declare const NiceLowPowerMode: default_2.ForwardRefExoticComponent<NiceLowPowerModeProps & default_2.RefAttributes<NiceLowPowerModeRef>>;
+
+declare interface NiceLowPowerModeProps {
+    /** Configuration */
+    config?: LowPowerConfig;
+    /** On mode change */
+    onModeChange?: (mode: PowerMode, previousMode: PowerMode) => void;
+    /** On brightness change */
+    onBrightnessChange?: (brightness: number) => void;
+    /** On sleep */
+    onSleep?: () => void;
+    /** On wake */
+    onWake?: () => void;
+    /** On low battery */
+    onLowBattery?: (level: number) => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceLowPowerModeRef {
+    /** Get current state */
+    getState: () => LowPowerState;
+    /** Set power mode */
+    setMode: (mode: PowerMode) => void;
+    /** Set brightness */
+    setBrightness: (level: number) => void;
+    /** Go to sleep */
+    sleep: () => void;
+    /** Wake up */
+    wake: () => void;
+    /** Toggle power saving */
+    togglePowerSaving: () => void;
+    /** Reset idle timer */
+    resetIdleTimer: () => void;
+    /** Get battery info */
+    getBatteryInfo: () => Promise<{
+        level?: number;
+        charging?: boolean;
+    }>;
+}
+
+export declare const NiceOfflineForms: default_2.ForwardRefExoticComponent<NiceOfflineFormsProps & default_2.RefAttributes<NiceOfflineFormsRef>>;
+
+declare interface NiceOfflineFormsProps {
+    /** Configuration */
+    config?: OfflineFormsConfig;
+    /** Submit handlers by form ID */
+    submitHandlers?: Record<string, FormSubmitHandler>;
+    /** Callback when draft saved */
+    onDraftSaved?: <T>(draft: FormDraft<T>) => void;
+    /** Callback when form submitted */
+    onFormSubmitted?: <T>(draft: FormDraft<T>) => void;
+    /** Callback when submission fails */
+    onSubmissionFailed?: <T>(draft: FormDraft<T>, error: Error) => void;
+    /** Callback on sync complete */
+    onSyncComplete?: (results: {
+        synced: number;
+        failed: number;
+    }) => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceOfflineFormsRef {
+    /** Get current state */
+    getState: () => OfflineFormsState;
+    /** Save form draft */
+    saveDraft: <T = Record<string, unknown>>(formId: string, data: T, metadata?: Record<string, unknown>) => Promise<string>;
+    /** Get draft by ID */
+    getDraft: <T = Record<string, unknown>>(draftId: string) => Promise<FormDraft<T> | undefined>;
+    /** Get all drafts for form */
+    getDrafts: <T = Record<string, unknown>>(formId: string) => Promise<FormDraft<T>[]>;
+    /** Get all pending drafts */
+    getPendingDrafts: <T = Record<string, unknown>>() => Promise<FormDraft<T>[]>;
+    /** Update draft */
+    updateDraft: <T = Record<string, unknown>>(draftId: string, data: Partial<T>) => Promise<void>;
+    /** Delete draft */
+    deleteDraft: (draftId: string) => Promise<void>;
+    /** Submit draft */
+    submitDraft: (draftId: string) => Promise<void>;
+    /** Submit form directly */
+    submitForm: <T = Record<string, unknown>>(formId: string, data: T) => Promise<void>;
+    /** Sync all pending */
+    syncPending: () => Promise<{
+        synced: number;
+        failed: number;
+    }>;
+    /** Retry failed */
+    retryFailed: () => Promise<void>;
+    /** Clear all drafts for form */
+    clearDrafts: (formId: string) => Promise<void>;
+    /** Register submit handler */
+    registerHandler: <T = Record<string, unknown>>(formId: string, handler: FormSubmitHandler<T>) => void;
+}
+
+export declare const NiceOfflineIndicator: default_2.ForwardRefExoticComponent<NiceOfflineIndicatorProps & default_2.RefAttributes<NiceOfflineIndicatorRef>>;
+
+declare interface NiceOfflineIndicatorProps {
+    /** Display mode */
+    mode?: IndicatorMode;
+    /** Position (for fixed modes) */
+    position?: IndicatorPosition;
+    /** Show when online */
+    showWhenOnline?: boolean;
+    /** Auto-hide online status after ms (0 = never) */
+    autoHideOnlineDelay?: number;
+    /** Show slow connection warning */
+    showSlowConnectionWarning?: boolean;
+    /** Slow connection threshold (Mbps) */
+    slowConnectionThreshold?: number;
+    /** Enable reconnecting attempts indicator */
+    showReconnecting?: boolean;
+    /** Reconnect check interval (ms) */
+    reconnectCheckInterval?: number;
+    /** Custom offline message */
+    offlineMessage?: string;
+    /** Custom online message */
+    onlineMessage?: string;
+    /** Custom slow connection message */
+    slowConnectionMessage?: string;
+    /** Custom reconnecting message */
+    reconnectingMessage?: string;
+    /** Show connection details */
+    showDetails?: boolean;
+    /** Animated transitions */
+    animated?: boolean;
+    /** Pulse animation when offline */
+    pulseWhenOffline?: boolean;
+    /** Custom offline icon */
+    offlineIcon?: ReactNode;
+    /** Custom online icon */
+    onlineIcon?: ReactNode;
+    /** Custom slow icon */
+    slowIcon?: ReactNode;
+    /** Render custom content */
+    renderContent?: (info: ConnectionInfo) => ReactNode;
+    /** Callback on status change */
+    onStatusChange?: (info: ConnectionInfo) => void;
+    /** Callback on reconnect */
+    onReconnect?: () => void;
+    /** Additional CSS class */
+    className?: string;
+    /** Inline styles */
+    style?: CSSProperties;
+}
+
+declare interface NiceOfflineIndicatorRef {
+    /** Get current connection info */
+    getConnectionInfo: () => ConnectionInfo;
+    /** Check connection now */
+    checkConnection: () => Promise<boolean>;
+    /** Force show indicator */
+    show: () => void;
+    /** Force hide indicator */
+    hide: () => void;
+    /** Toggle visibility */
+    toggle: () => void;
+}
+
+export declare const NiceOfflineMedia: default_2.ForwardRefExoticComponent<NiceOfflineMediaProps & default_2.RefAttributes<NiceOfflineMediaRef>>;
+
+declare interface NiceOfflineMediaProps {
+    /** Configuration */
+    config?: OfflineMediaConfig;
+    /** Callback when download starts */
+    onDownloadStart?: (media: CachedMedia) => void;
+    /** Callback on progress */
+    onDownloadProgress?: (media: CachedMedia) => void;
+    /** Callback when download completes */
+    onDownloadComplete?: (media: CachedMedia) => void;
+    /** Callback when download fails */
+    onDownloadFailed?: (media: CachedMedia, error: Error) => void;
+    /** Callback when media removed */
+    onMediaRemoved?: (mediaId: string) => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceOfflineMediaRef {
+    /** Get current state */
+    getState: () => OfflineMediaState;
+    /** Download media */
+    download: (url: string, options?: DownloadOptions) => Promise<string>;
+    /** Download multiple */
+    downloadMultiple: (items: Array<{
+        url: string;
+        options?: DownloadOptions;
+    }>) => Promise<string[]>;
+    /** Get cached media */
+    getCachedMedia: (mediaId: string) => Promise<CachedMedia | undefined>;
+    /** Get all cached media */
+    getAllCachedMedia: () => Promise<CachedMedia[]>;
+    /** Get media by type */
+    getMediaByType: (type: MediaType) => Promise<CachedMedia[]>;
+    /** Get media by tag */
+    getMediaByTag: (tag: string) => Promise<CachedMedia[]>;
+    /** Get blob URL for offline playback */
+    getBlobUrl: (mediaId: string) => Promise<string | undefined>;
+    /** Check if cached */
+    isCached: (url: string) => Promise<boolean>;
+    /** Pause download */
+    pauseDownload: (mediaId: string) => void;
+    /** Resume download */
+    resumeDownload: (mediaId: string) => Promise<void>;
+    /** Cancel download */
+    cancelDownload: (mediaId: string) => void;
+    /** Pause all downloads */
+    pauseAll: () => void;
+    /** Resume all downloads */
+    resumeAll: () => Promise<void>;
+    /** Remove cached media */
+    removeMedia: (mediaId: string) => Promise<void>;
+    /** Clear all cache */
+    clearCache: () => Promise<void>;
+    /** Clear expired */
+    clearExpired: () => Promise<number>;
+    /** Get cache stats */
+    getCacheStats: () => Promise<{
+        totalSize: number;
+        itemCount: number;
+        byType: Record<MediaType, {
+            count: number;
+            size: number;
+        }>;
+    }>;
+    /** Preload media (low priority) */
+    preload: (urls: string[]) => Promise<void>;
+}
+
+export declare const NiceOrientationLock: default_2.ForwardRefExoticComponent<NiceOrientationLockProps & default_2.RefAttributes<NiceOrientationLockRef>>;
+
+declare interface NiceOrientationLockProps {
+    /** Configuration */
+    config?: OrientationLockConfig;
+    /** On orientation change */
+    onOrientationChange?: (info: OrientationInfo) => void;
+    /** On lock status change */
+    onLockChange?: (isLocked: boolean, orientation: OrientationType_2 | null) => void;
+    /** On unsupported orientation */
+    onUnsupportedOrientation?: (current: OrientationType_2, supported: OrientationType_2[]) => void;
+    /** Custom rotation prompt */
+    rotationPrompt?: ReactNode;
+    /** Children */
+    children?: ReactNode;
+    /** Additional class name */
+    className?: string;
+}
+
+declare interface NiceOrientationLockRef {
+    /** Get current state */
+    getState: () => OrientationState;
+    /** Lock to specific orientation */
+    lock: (orientation: OrientationType_2) => Promise<boolean>;
+    /** Unlock orientation */
+    unlock: () => Promise<boolean>;
+    /** Toggle lock */
+    toggleLock: () => Promise<boolean>;
+    /** Get current orientation info */
+    getOrientationInfo: () => OrientationInfo;
+    /** Check if orientation is supported */
+    isOrientationSupported: (orientation: OrientationType_2) => boolean;
+}
+
+declare interface NiceQRGeneratorProps {
+    /** Data to encode */
+    value: string;
+    /** Generator options */
+    options?: QRGeneratorOptions;
+    /** On generation complete */
+    onGenerate?: (dataUrl: string) => void;
+    /** On error */
+    onError?: (error: Error) => void;
+    /** Show border */
+    showBorder?: boolean;
+    /** Class name */
+    className?: string;
+}
+
+declare interface NiceQRGeneratorRef {
+    /** Get data URL */
+    toDataURL: (type?: string, quality?: number) => string | null;
+    /** Get SVG string */
+    toSVG: () => string | null;
+    /** Download QR code */
+    download: (filename?: string, type?: 'png' | 'svg') => void;
+    /** Regenerate */
+    regenerate: () => void;
+}
+
+export declare const NiceQRScanner: default_2.ForwardRefExoticComponent<NiceQRScannerProps & default_2.RefAttributes<NiceQRScannerRef>>;
+
+declare interface NiceQRScannerProps {
+    /** Configuration */
+    config?: QRScannerConfig;
+    /** On scan */
+    onScan?: (result: QRScanResult) => void;
+    /** On error */
+    onError?: (error: Error) => void;
+    /** On camera ready */
+    onCameraReady?: () => void;
+    /** Auto start */
+    autoStart?: boolean;
+    /** Show scan frame */
+    showScanFrame?: boolean;
+    /** Custom overlay */
+    children?: ReactNode;
+    /** Class name */
+    className?: string;
+}
+
+declare interface NiceQRScannerRef {
+    /** Get state */
+    getState: () => QRScannerState;
+    /** Start */
+    start: () => Promise<void>;
+    /** Stop */
+    stop: () => void;
+    /** Toggle */
+    toggle: () => Promise<void>;
+    /** Switch camera */
+    switchCamera: () => Promise<void>;
+    /** Toggle torch */
+    toggleTorch: () => Promise<void>;
+    /** Take snapshot */
+    takeSnapshot: () => string | null;
+    /** Scan image file */
+    scanImage: (file: File) => Promise<QRScanResult | null>;
+}
+
+export declare const NiceRemoteManagement: default_2.ForwardRefExoticComponent<NiceRemoteManagementProps & default_2.RefAttributes<NiceRemoteManagementRef>>;
+
+declare interface NiceRemoteManagementProps {
+    /** Configuration */
+    config: RemoteManagementConfig;
+    /** On connection change */
+    onConnectionChange?: (status: ConnectionStatus) => void;
+    /** On command received */
+    onCommandReceived?: (command: RemoteCommand) => void;
+    /** On custom command */
+    onCustomCommand?: (command: RemoteCommand) => Promise<unknown>;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceRemoteManagementRef {
+    /** Get current state */
+    getState: () => RemoteManagementState;
+    /** Connect to server */
+    connect: () => Promise<void>;
+    /** Disconnect */
+    disconnect: () => void;
+    /** Send heartbeat */
+    sendHeartbeat: () => Promise<void>;
+    /** Send health metrics */
+    sendHealthMetrics: (metrics: Partial<HealthMetrics>) => Promise<void>;
+    /** Report command result */
+    reportCommandResult: (commandId: string, result: unknown, error?: string) => Promise<void>;
+    /** Send log */
+    sendLog: (level: string, message: string, data?: unknown) => void;
+    /** Capture screenshot */
+    captureScreenshot: () => Promise<string | undefined>;
+    /** Get device info */
+    getDeviceInfo: () => DeviceInfo;
+}
+
+export declare const NiceScreenBurnPrevention: default_2.ForwardRefExoticComponent<NiceScreenBurnPreventionProps & default_2.RefAttributes<NiceScreenBurnPreventionRef>>;
+
+declare interface NiceScreenBurnPreventionProps {
+    /** Configuration */
+    config?: Partial<ScreenBurnPreventionConfig>;
+    /** Enable/disable */
+    enabled?: boolean;
+    /** On activation */
+    onActivate?: () => void;
+    /** On deactivation */
+    onDeactivate?: () => void;
+    /** On mode change */
+    onModeChange?: (modes: PreventionMode[]) => void;
+    /** Children */
+    children?: ReactNode;
+}
+
+declare interface NiceScreenBurnPreventionRef {
+    /** Get current state */
+    getState: () => ScreenBurnPreventionState;
+    /** Activate prevention */
+    activate: () => void;
+    /** Deactivate prevention */
+    deactivate: () => void;
+    /** Toggle prevention */
+    toggle: () => void;
+    /** Reset idle timer */
+    resetIdleTimer: () => void;
+    /** Force shift */
+    forceShift: () => void;
+    /** Show screensaver */
+    showScreensaver: () => void;
+    /** Hide screensaver */
+    hideScreensaver: () => void;
+    /** Set dim level */
+    setDimLevel: (level: number) => void;
+}
+
+export declare const NiceServiceWorker: default_2.ForwardRefExoticComponent<NiceServiceWorkerProps & default_2.RefAttributes<NiceServiceWorkerRef>>;
+
+export declare interface NiceServiceWorkerProps {
+    /** Service worker configuration */
+    config?: ServiceWorkerConfig;
+    /** Show update notification UI */
+    showUpdateNotification?: boolean;
+    /** Show offline indicator */
+    showOfflineIndicator?: boolean;
+    /** Custom update notification component */
+    renderUpdateNotification?: (props: {
+        onUpdate: () => void;
+        onDismiss: () => void;
+    }) => ReactNode;
+    /** Custom offline indicator component */
+    renderOfflineIndicator?: (props: {
+        isOnline: boolean;
+    }) => ReactNode;
+    /** Notification position */
+    notificationPosition?: 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /** Auto-dismiss notification after ms (0 = never) */
+    autoDismissDelay?: number;
+    /** Callback when SW registered */
+    onRegistered?: (registration: ServiceWorkerRegistration) => void;
+    /** Callback when update available */
+    onUpdateAvailable?: () => void;
+    /** Callback when activated */
+    onActivated?: () => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Callback on online status change */
+    onOnlineStatusChange?: (isOnline: boolean) => void;
+    /** Children to render */
+    children?: ReactNode;
+    /** Additional CSS class */
+    className?: string;
+}
+
+export declare const NiceServiceWorkerProvider: default_2.ForwardRefExoticComponent<NiceServiceWorkerProviderProps & default_2.RefAttributes<NiceServiceWorkerRef>>;
+
+export declare interface NiceServiceWorkerProviderProps extends NiceServiceWorkerProps {
+}
+
+export declare interface NiceServiceWorkerRef {
+    /** Get current state */
+    getState: () => ServiceWorkerState_2;
+    /** Register service worker */
+    register: () => Promise<ServiceWorkerRegistration | undefined>;
+    /** Unregister service worker */
+    unregister: () => Promise<boolean>;
+    /** Check for updates */
+    checkForUpdates: () => Promise<void>;
+    /** Apply waiting update */
+    applyUpdate: () => void;
+    /** Skip waiting and activate new SW */
+    skipWaiting: () => void;
+    /** Get all caches info */
+    getCachesInfo: () => Promise<CacheInfo[]>;
+    /** Clear specific cache */
+    clearCache: (cacheName: string) => Promise<boolean>;
+    /** Clear all caches */
+    clearAllCaches: () => Promise<void>;
+    /** Add URLs to cache */
+    addToCache: (cacheName: string, urls: string[]) => Promise<void>;
+    /** Remove URL from cache */
+    removeFromCache: (cacheName: string, url: string) => Promise<boolean>;
+    /** Get cached URLs */
+    getCachedUrls: (cacheName: string) => Promise<string[]>;
+    /** Force reload */
+    forceReload: () => void;
+}
+
+export declare const NiceSymbologyConfig: default_2.ForwardRefExoticComponent<NiceSymbologyConfigProps & default_2.RefAttributes<NiceSymbologyConfigRef>>;
+
+declare interface NiceSymbologyConfigProps {
+    /** Selected symbologies */
+    selected?: BarcodeSymbology[];
+    /** On selection change */
+    onChange?: (selected: BarcodeSymbology[]) => void;
+    /** Filter by category */
+    category?: SymbologyCategory | 'all';
+    /** Multi-select mode */
+    multiSelect?: boolean;
+    /** Show details panel */
+    showDetails?: boolean;
+    /** Show validation */
+    showValidation?: boolean;
+    /** Test value for validation */
+    testValue?: string;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Class name */
+    className?: string;
+}
+
+declare interface NiceSymbologyConfigRef {
+    /** Get selected symbologies */
+    getSelected: () => BarcodeSymbology[];
+    /** Select symbology */
+    select: (id: BarcodeSymbology) => void;
+    /** Deselect symbology */
+    deselect: (id: BarcodeSymbology) => void;
+    /** Select all */
+    selectAll: () => void;
+    /** Clear selection */
+    clearSelection: () => void;
+    /** Validate value against symbology */
+    validate: (value: string, symbology: BarcodeSymbology) => SymbologyValidationResult;
+    /** Get symbology info */
+    getInfo: (symbology: BarcodeSymbology) => SymbologyInfo | undefined;
+    /** Get all symbologies */
+    getAll: () => SymbologyInfo[];
+}
+
+export declare const NiceTouchCalibration: default_2.ForwardRefExoticComponent<NiceTouchCalibrationProps & default_2.RefAttributes<NiceTouchCalibrationRef>>;
+
+declare interface NiceTouchCalibrationProps {
+    /** Configuration */
+    config?: CalibrationConfig;
+    /** Auto-start calibration */
+    autoStart?: boolean;
+    /** On calibration start */
+    onStart?: () => void;
+    /** On point calibrated */
+    onPointCalibrated?: (point: CalibrationPoint, index: number) => void;
+    /** On calibration complete */
+    onComplete?: (matrix: CalibrationMatrix, success: boolean) => void;
+    /** On calibration cancel */
+    onCancel?: () => void;
+    /** Children (shown when not calibrating) */
+    children?: ReactNode;
+}
+
+declare interface NiceTouchCalibrationRef {
+    /** Get current state */
+    getState: () => CalibrationState;
+    /** Start calibration */
+    start: () => void;
+    /** Cancel calibration */
+    cancel: () => void;
+    /** Reset calibration */
+    reset: () => void;
+    /** Get calibration matrix */
+    getMatrix: () => CalibrationMatrix | null;
+    /** Apply matrix to transform point */
+    transformPoint: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    /** Check if calibration exists */
+    hasCalibration: () => boolean;
+    /** Clear saved calibration */
+    clearCalibration: () => void;
+}
+
+declare interface OfflineFormsConfig {
+    /** IndexedDB database name */
+    dbName?: string;
+    /** Auto-save interval in ms (0 = disabled) */
+    autoSaveInterval?: number;
+    /** Max drafts per form */
+    maxDraftsPerForm?: number;
+    /** Auto-submit when online */
+    autoSubmitOnline?: boolean;
+    /** Retry failed submissions */
+    retryFailed?: boolean;
+    /** Max retry attempts */
+    maxRetryAttempts?: number;
+    /** Retry delay in ms */
+    retryDelay?: number;
+}
+
+declare interface OfflineFormsState {
+    /** Is online */
+    isOnline: boolean;
+    /** Is syncing */
+    isSyncing: boolean;
+    /** Draft counts by form */
+    draftCounts: Record<string, number>;
+    /** Pending submissions count */
+    pendingCount: number;
+    /** Failed submissions count */
+    failedCount: number;
+    /** Last sync timestamp */
+    lastSyncAt?: Date;
+}
+
+declare interface OfflineMediaConfig {
+    /** IndexedDB database name */
+    dbName?: string;
+    /** Max cache size in bytes */
+    maxCacheSize?: number;
+    /** Max concurrent downloads */
+    maxConcurrentDownloads?: number;
+    /** Auto-resume downloads on reconnect */
+    autoResumeOnReconnect?: boolean;
+    /** Default cache duration in ms */
+    defaultCacheDuration?: number;
+    /** Cleanup expired automatically */
+    autoCleanup?: boolean;
+    /** Cleanup interval in ms */
+    cleanupInterval?: number;
+}
+
+declare interface OfflineMediaState {
+    /** Is online */
+    isOnline: boolean;
+    /** Active downloads count */
+    activeDownloads: number;
+    /** Queued downloads count */
+    queuedDownloads: number;
+    /** Total cached items */
+    cachedCount: number;
+    /** Total cache size in bytes */
+    totalCacheSize: number;
+    /** Available quota (if available) */
+    availableQuota?: number;
+    /** Is downloading */
+    isDownloading: boolean;
+}
+
+declare interface OrientationInfo {
+    /** Current orientation type */
+    type: OrientationType_2;
+    /** Rotation angle (0, 90, 180, 270) */
+    angle: number;
+    /** Is portrait */
+    isPortrait: boolean;
+    /** Is landscape */
+    isLandscape: boolean;
+    /** Screen width */
+    width: number;
+    /** Screen height */
+    height: number;
+    /** Aspect ratio */
+    aspectRatio: number;
+}
+
+declare interface OrientationLockConfig {
+    /** Preferred orientation */
+    preferredOrientation?: OrientationType_2;
+    /** Allow user to change orientation */
+    allowUserChange?: boolean;
+    /** Show rotation prompt when mismatched */
+    showRotationPrompt?: boolean;
+    /** Lock orientation on mount */
+    lockOnMount?: boolean;
+    /** Auto-rotate content (CSS rotation) */
+    autoRotateContent?: boolean;
+    /** Supported orientations */
+    supportedOrientations?: OrientationType_2[];
+}
+
+declare interface OrientationState {
+    /** Current orientation */
+    current: OrientationType_2;
+    /** Locked orientation (if any) */
+    locked: OrientationType_2 | null;
+    /** Is orientation locked */
+    isLocked: boolean;
+    /** Is current orientation supported */
+    isSupported: boolean;
+    /** Orientation info */
+    info: OrientationInfo;
+    /** Is API available */
+    isApiAvailable: boolean;
+}
+
+declare type OrientationType_2 = 'any' | 'natural' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape' | 'landscape-primary' | 'landscape-secondary';
+
+declare type PowerMode = 'normal' | 'dim' | 'low' | 'sleep';
+
+declare interface PowerModeConfig {
+    /** Mode name */
+    mode: PowerMode;
+    /** Brightness level (0-1) */
+    brightness: number;
+    /** Frame rate cap */
+    frameRateCap?: number;
+    /** Disable animations */
+    disableAnimations?: boolean;
+    /** Reduce image quality */
+    reduceImageQuality?: boolean;
+    /** Disable background processes */
+    disableBackgroundProcesses?: boolean;
+    /** Wake on touch */
+    wakeOnTouch?: boolean;
+    /** Wake on motion (if sensor available) */
+    wakeOnMotion?: boolean;
+}
+
+declare type PreventionMode = 'pixel-shift' | 'color-cycling' | 'screensaver' | 'dimming' | 'invert';
+
+declare type QRDataType = 'url' | 'email' | 'tel' | 'sms' | 'geo' | 'vcard' | 'vevent' | 'wifi' | 'text' | 'unknown';
+
+declare type QRErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H';
+
+declare interface QRGeneratorOptions {
+    /** Error correction level (L=7%, M=15%, Q=25%, H=30%) */
+    errorCorrection?: QRErrorCorrectionLevel;
+    /** Size (width/height in pixels) */
+    size?: number;
+    /** Margin (quiet zone modules) */
+    margin?: number;
+    /** Dark module color */
+    darkColor?: string;
+    /** Light module color */
+    lightColor?: string;
+    /** Image to embed in center */
+    logo?: string;
+    /** Logo size (fraction of QR size) */
+    logoSize?: number;
+    /** Logo margin */
+    logoMargin?: number;
+    /** Rounded corners for modules */
+    cornerRadius?: number;
+}
+
+declare interface QRScannerConfig {
+    /** Continuous scanning */
+    continuous?: boolean;
+    /** Scan interval (ms) */
+    scanInterval?: number;
+    /** Beep on scan */
+    beepOnScan?: boolean;
+    /** Vibrate on scan */
+    vibrateOnScan?: boolean;
+    /** Auto-focus */
+    autoFocus?: boolean;
+    /** Preferred camera */
+    facingMode?: 'user' | 'environment';
+    /** Resolution */
+    resolution?: 'sd' | 'hd' | 'fhd';
+    /** Parse QR data type */
+    parseDataType?: boolean;
+    /** Highlight detected QR */
+    highlightDetected?: boolean;
+}
+
+declare interface QRScannerState {
+    /** Is scanning */
+    isScanning: boolean;
+    /** Camera ready */
+    isCameraReady: boolean;
+    /** Last result */
+    lastResult: QRScanResult | null;
+    /** Error */
+    error: string | null;
+    /** Is supported */
+    isSupported: boolean;
+    /** Has permission */
+    hasPermission: boolean | null;
+    /** Torch available */
+    torchAvailable: boolean;
+    /** Torch on */
+    torchOn: boolean;
+}
+
+declare interface QRScanResult {
+    /** Decoded text */
+    text: string;
+    /** Raw bytes (if available) */
+    rawBytes?: Uint8Array;
+    /** QR format/version */
+    format?: string;
+    /** Error correction level */
+    errorCorrectionLevel?: 'L' | 'M' | 'Q' | 'H';
+    /** Bounding box */
+    boundingBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Corner points */
+    cornerPoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Timestamp */
+    timestamp: Date;
+    /** Data type (URL, text, vCard, etc.) */
+    dataType?: QRDataType;
+    /** Parsed data (for structured types) */
+    parsedData?: unknown;
+}
+
+declare interface QueryOptions {
+    /** Index to use for query */
+    index?: string;
+    /** Key range */
+    range?: IDBKeyRange;
+    /** Direction for cursor */
+    direction?: IDBCursorDirection;
+    /** Limit results */
+    limit?: number;
+    /** Skip results */
+    offset?: number;
+}
+
+declare interface RemoteCommand {
+    /** Command ID */
+    id: string;
+    /** Command type */
+    type: CommandType;
+    /** Command payload */
+    payload?: unknown;
+    /** Timestamp */
+    timestamp: Date;
+    /** Acknowledged */
+    acknowledged: boolean;
+    /** Executed */
+    executed: boolean;
+    /** Result */
+    result?: unknown;
+    /** Error */
+    error?: string;
+}
+
+declare interface RemoteManagementConfig {
+    /** Server URL */
+    serverUrl: string;
+    /** Device ID */
+    deviceId: string;
+    /** Device name */
+    deviceName?: string;
+    /** API key */
+    apiKey?: string;
+    /** Heartbeat interval (ms) */
+    heartbeatInterval?: number;
+    /** Reconnect delay (ms) */
+    reconnectDelay?: number;
+    /** Max reconnect attempts */
+    maxReconnectAttempts?: number;
+    /** Enable health monitoring */
+    enableHealthMonitoring?: boolean;
+    /** Health report interval (ms) */
+    healthReportInterval?: number;
+    /** Enable screenshot capture */
+    enableScreenshot?: boolean;
+    /** Enable log collection */
+    enableLogs?: boolean;
+    /** Log buffer size */
+    logBufferSize?: number;
+}
+
+declare interface RemoteManagementState {
+    /** Connection status */
+    status: ConnectionStatus;
+    /** Is connected */
+    isConnected: boolean;
+    /** Last heartbeat */
+    lastHeartbeat?: Date;
+    /** Reconnect attempts */
+    reconnectAttempts: number;
+    /** Pending commands */
+    pendingCommands: RemoteCommand[];
+    /** Command history */
+    commandHistory: RemoteCommand[];
+    /** Health metrics */
+    healthMetrics?: HealthMetrics;
+    /** Error message */
+    error?: string;
+}
+
+declare interface ScannedItem {
+    /** Unique ID */
+    id: string;
+    /** Barcode/QR value */
+    value: string;
+    /** Barcode format */
+    format: BarcodeFormat_2;
+    /** Timestamp */
+    timestamp: number;
+    /** Raw data */
+    rawValue?: string;
+    /** Quantity (for inventory) */
+    quantity: number;
+    /** Bounding box */
+    boundingBox?: DOMRectReadOnly;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+
+declare interface ScreenBurnPreventionConfig {
+    /** Prevention modes to use */
+    modes: PreventionMode[];
+    /** Inactivity timeout before activation (ms) */
+    inactivityTimeout: number;
+    /** Pixel shift config */
+    pixelShift?: ShiftConfig;
+    /** Color cycling config */
+    colorCycle?: ColorCycleConfig;
+    /** Dimming config */
+    dimming?: DimmingConfig;
+    /** Screensaver config */
+    screensaver?: ScreensaverConfig;
+    /** Static element detection threshold (ms) */
+    staticDetectionThreshold?: number;
+    /** Auto-detect static elements */
+    autoDetectStatic?: boolean;
+}
+
+declare interface ScreenBurnPreventionState {
+    /** Is prevention active */
+    isActive: boolean;
+    /** Current active modes */
+    activeModes: PreventionMode[];
+    /** Current pixel shift X */
+    shiftX: number;
+    /** Current pixel shift Y */
+    shiftY: number;
+    /** Is dimmed */
+    isDimmed: boolean;
+    /** Is screensaver showing */
+    isScreensaverActive: boolean;
+    /** Time idle (ms) */
+    idleTime: number;
+}
+
+declare interface ScreenInfo {
+    /** Unique identifier */
+    id: string;
+    /** Screen label */
+    label: string;
+    /** Screen width */
+    width: number;
+    /** Screen height */
+    height: number;
+    /** Available width (excluding taskbar) */
+    availWidth: number;
+    /** Available height (excluding taskbar) */
+    availHeight: number;
+    /** Left position */
+    left: number;
+    /** Top position */
+    top: number;
+    /** Device pixel ratio */
+    devicePixelRatio: number;
+    /** Is primary screen */
+    isPrimary: boolean;
+    /** Is internal display */
+    isInternal?: boolean;
+    /** Orientation */
+    orientation: string;
+    /** Color depth */
+    colorDepth: number;
+}
+
+declare interface ScreensaverConfig {
+    /** Screensaver type */
+    type: 'blank' | 'bounce' | 'matrix' | 'noise' | 'custom';
+    /** Custom screensaver component */
+    component?: ReactNode;
+}
+
+declare interface ServiceWorkerConfig {
+    /** Path to service worker file */
+    swPath?: string;
+    /** Service worker scope */
+    scope?: string;
+    /** Update check interval in ms */
+    updateCheckInterval?: number;
+    /** Auto-update when new version available */
+    autoUpdate?: boolean;
+    /** Skip waiting on new version */
+    skipWaiting?: boolean;
+    /** Reload page after activation */
+    reloadOnActivation?: boolean;
+}
+
+declare interface ServiceWorkerState_2 {
+    /** Current status */
+    status: ServiceWorkerStatus;
+    /** Registration object */
+    registration?: ServiceWorkerRegistration;
+    /** Update available flag */
+    updateAvailable: boolean;
+    /** Waiting worker exists */
+    waitingWorker: boolean;
+    /** Error message if any */
+    error?: string;
+    /** Currently cached URLs */
+    cachedUrls: string[];
+    /** Cache storage info */
+    caches: CacheInfo[];
+    /** Is currently online */
+    isOnline: boolean;
+    /** Last sync time */
+    lastSyncTime?: Date;
+}
+
+declare type ServiceWorkerStatus = 'idle' | 'registering' | 'registered' | 'installing' | 'installed' | 'activating' | 'activated' | 'redundant' | 'error';
+
+declare interface ShiftConfig {
+    /** Maximum shift in pixels */
+    maxShift: number;
+    /** Shift interval (ms) */
+    interval: number;
+    /** Smooth transition */
+    smooth: boolean;
+}
+
+declare type StartupPhase = 'initializing' | 'loading' | 'ready' | 'error' | 'recovery';
+
+declare interface StartupTask {
+    /** Unique ID */
+    id: string;
+    /** Task name */
+    name: string;
+    /** Task description */
+    description?: string;
+    /** Priority (higher = earlier) */
+    priority?: number;
+    /** Dependencies (task IDs) */
+    dependencies?: string[];
+    /** Is critical (blocks startup on failure) */
+    critical?: boolean;
+    /** Timeout (ms) */
+    timeout?: number;
+    /** Retry count */
+    retries?: number;
+    /** Task function */
+    execute: () => Promise<void>;
+}
+
+declare interface StartupTaskResult {
+    /** Task ID */
+    taskId: string;
+    /** Success status */
+    success: boolean;
+    /** Error if failed */
+    error?: Error;
+    /** Duration (ms) */
+    duration: number;
+    /** Retry count used */
+    retriesUsed: number;
+}
+
+declare type SymbologyCategory = 'linear' | '2d' | 'postal' | 'gs1';
+
+declare interface SymbologyInfo {
+    /** Symbology identifier */
+    id: BarcodeSymbology;
+    /** Display name */
+    name: string;
+    /** Category */
+    category: SymbologyCategory;
+    /** Description */
+    description: string;
+    /** Allowed characters */
+    charset: string;
+    /** Min length */
+    minLength: number;
+    /** Max length */
+    maxLength: number;
+    /** Fixed length (null = variable) */
+    fixedLength: number | null;
+    /** Supports check digit */
+    hasCheckDigit: boolean;
+    /** Common use cases */
+    useCases: string[];
+    /** Industry standard */
+    standard?: string;
+    /** Browser BarcodeDetector format name */
+    detectorFormat?: string;
+}
+
+declare interface SymbologyValidationResult {
+    /** Is valid for this symbology */
+    valid: boolean;
+    /** Validation errors */
+    errors: string[];
+    /** Warnings */
+    warnings: string[];
+    /** Computed check digit */
+    checkDigit?: string;
+    /** Formatted value */
+    formattedValue?: string;
+}
+
+declare interface SyncHandler<T = unknown> {
+    /** Handler for processing sync task */
+    handler: (task: SyncTask<T>) => Promise<void>;
+    /** Min time between syncs in ms */
+    minInterval?: number;
+    /** Whether to sync immediately when online */
+    syncOnConnect?: boolean;
+}
+
+declare type SyncStatus = 'pending' | 'syncing' | 'success' | 'failed' | 'cancelled';
+
+declare interface SyncTask<T = unknown> {
+    /** Unique task ID */
+    id: string;
+    /** Task tag for grouping */
+    tag: string;
+    /** Task data */
+    data: T;
+    /** Current status */
+    status: SyncStatus;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Last attempted timestamp */
+    lastAttemptAt?: Date;
+    /** Number of attempts */
+    attempts: number;
+    /** Max retry attempts */
+    maxAttempts: number;
+    /** Error message if failed */
+    error?: string;
+    /** Priority (higher = more important) */
+    priority: number;
+}
+
+declare interface TransactionOptions {
+    /** Store names to include */
+    stores: string[];
+    /** Transaction mode */
+    mode?: IDBTransactionMode;
+    /** Durability hint */
+    durability?: 'default' | 'strict' | 'relaxed';
+}
+
+declare interface WindowFeatures {
+    /** Width */
+    width?: number;
+    /** Height */
+    height?: number;
+    /** Left position */
+    left?: number;
+    /** Top position */
+    top?: number;
+    /** Show menubar */
+    menubar?: boolean;
+    /** Show toolbar */
+    toolbar?: boolean;
+    /** Show location bar */
+    location?: boolean;
+    /** Show status bar */
+    status?: boolean;
+    /** Is resizable */
+    resizable?: boolean;
+    /** Show scrollbars */
+    scrollbars?: boolean;
+    /** Open fullscreen */
+    fullscreen?: boolean;
+}
+
+declare interface WindowInfo {
+    /** Window reference */
+    window: Window | null;
+    /** Target screen */
+    screen: ScreenInfo;
+    /** Window ID */
+    id: string;
+    /** Window state */
+    state: 'opening' | 'open' | 'closed' | 'error';
+    /** Is fullscreen */
+    isFullscreen: boolean;
+    /** Window features */
+    features: WindowFeatures;
+}
+
+export { }