flikkui 0.1.0-beta.8 → 0.2.0-beta.1

package/dist/utils/actionQueue.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Action Queue for Offline Support
+ * Manages queued mutations when the user is offline
+ */
+/**
+ * Queued action interface
+ */
+export interface QueuedAction<T = unknown> {
+    /** Unique identifier for the action */
+    id: string;
+    /** Function to execute when online */
+    action: () => Promise<T>;
+    /** Timestamp when action was queued */
+    timestamp: number;
+    /** Number of retry attempts */
+    retryCount: number;
+    /** Maximum retry attempts */
+    maxRetries: number;
+    /** Optional metadata for display */
+    metadata?: {
+        label?: string;
+        description?: string;
+    };
+}
+/**
+ * Configuration options for ActionQueue
+ */
+export interface ActionQueueOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Key for localStorage persistence (default: 'flikkui-action-queue') */
+    storageKey?: string;
+    /** Whether to persist queue to localStorage (default: true) */
+    persist?: boolean;
+    /** Called when an action is processed successfully */
+    onActionSuccess?: <T>(action: QueuedAction<T>, result: T) => void;
+    /** Called when an action fails after all retries */
+    onActionFailed?: <T>(action: QueuedAction<T>, error: Error) => void;
+    /** Called when queue changes */
+    onQueueChange?: (queue: QueuedAction[]) => void;
+}
+/**
+ * Options for adding an action to the queue
+ */
+export interface AddActionOptions {
+    /** Maximum retry attempts for this specific action */
+    maxRetries?: number;
+    /** Label for the action (shown in OfflineIndicator) */
+    label?: string;
+    /** Description for the action */
+    description?: string;
+}
+/**
+ * ActionQueue class for managing offline mutations
+ */
+export declare class ActionQueue {
+    private queue;
+    private isProcessing;
+    private options;
+    constructor(options?: ActionQueueOptions);
+    /**
+     * Generate a unique ID for an action
+     */
+    private generateId;
+    /**
+     * Save queue to localStorage
+     */
+    private saveToStorage;
+    /**
+     * Load queue from localStorage
+     * Note: Actions (functions) cannot be persisted, only metadata
+     */
+    private loadFromStorage;
+    /**
+     * Notify listeners of queue changes
+     */
+    private notifyChange;
+    /**
+     * Add an action to the queue
+     * @returns The action ID
+     */
+    add<T>(action: () => Promise<T>, options?: AddActionOptions): string;
+    /**
+     * Remove an action from the queue
+     */
+    remove(id: string): boolean;
+    /**
+     * Get all queued actions
+     */
+    getAll(): QueuedAction[];
+    /**
+     * Get the number of queued actions
+     */
+    get size(): number;
+    /**
+     * Check if queue is currently processing
+     */
+    get processing(): boolean;
+    /**
+     * Clear all queued actions
+     */
+    clear(): void;
+    /**
+     * Process all queued actions
+     * Call this when the user comes back online
+     */
+    process(): Promise<void>;
+}
+/**
+ * Create an ActionQueue instance
+ */
+export declare const createActionQueue: (options?: ActionQueueOptions) => ActionQueue;
+export declare const getDefaultQueue: () => ActionQueue;

package/dist/utils/actionQueue.js

@@ -0,0 +1,203 @@
+import { QueueError } from './optimisticErrors.js';
+
+/**
+ * Action Queue for Offline Support
+ * Manages queued mutations when the user is offline
+ */
+/**
+ * ActionQueue class for managing offline mutations
+ */
+class ActionQueue {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        this.queue = [];
+        this.isProcessing = false;
+        this.options = {
+            maxRetries: (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 3,
+            storageKey: (_b = options.storageKey) !== null && _b !== void 0 ? _b : "flikkui-action-queue",
+            persist: (_c = options.persist) !== null && _c !== void 0 ? _c : true,
+            onActionSuccess: options.onActionSuccess,
+            onActionFailed: options.onActionFailed,
+            onQueueChange: options.onQueueChange,
+        };
+        // Load persisted queue on initialization
+        if (this.options.persist) {
+            this.loadFromStorage();
+        }
+    }
+    /**
+     * Generate a unique ID for an action
+     */
+    generateId() {
+        return `action-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    /**
+     * Save queue to localStorage
+     */
+    saveToStorage() {
+        if (!this.options.persist || typeof window === "undefined")
+            return;
+        try {
+            // We can't serialize functions, so we only persist metadata
+            const persistableQueue = this.queue.map(({ id, timestamp, retryCount, maxRetries, metadata }) => ({
+                id,
+                timestamp,
+                retryCount,
+                maxRetries,
+                metadata,
+            }));
+            localStorage.setItem(this.options.storageKey, JSON.stringify(persistableQueue));
+        }
+        catch (_a) {
+            // localStorage might be unavailable or full
+            if (process.env.NODE_ENV !== "production") {
+                console.warn("[ActionQueue] Failed to persist queue to localStorage");
+            }
+        }
+    }
+    /**
+     * Load queue from localStorage
+     * Note: Actions (functions) cannot be persisted, only metadata
+     */
+    loadFromStorage() {
+        if (typeof window === "undefined")
+            return;
+        try {
+            const stored = localStorage.getItem(this.options.storageKey);
+            if (stored) {
+                // Only load metadata - actions will need to be re-registered
+                const parsed = JSON.parse(stored);
+                if (process.env.NODE_ENV !== "production" && parsed.length > 0) {
+                    console.warn(`[ActionQueue] Found ${parsed.length} stale queued actions. Actions cannot be restored after page reload.`);
+                }
+                // Clear stale entries
+                localStorage.removeItem(this.options.storageKey);
+            }
+        }
+        catch (_a) {
+            // localStorage might be unavailable
+        }
+    }
+    /**
+     * Notify listeners of queue changes
+     */
+    notifyChange() {
+        var _a, _b;
+        this.saveToStorage();
+        (_b = (_a = this.options).onQueueChange) === null || _b === void 0 ? void 0 : _b.call(_a, this.queue);
+    }
+    /**
+     * Add an action to the queue
+     * @returns The action ID
+     */
+    add(action, options) {
+        var _a;
+        const id = this.generateId();
+        const queuedAction = {
+            id,
+            action,
+            timestamp: Date.now(),
+            retryCount: 0,
+            maxRetries: (_a = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _a !== void 0 ? _a : this.options.maxRetries,
+            metadata: {
+                label: options === null || options === void 0 ? void 0 : options.label,
+                description: options === null || options === void 0 ? void 0 : options.description,
+            },
+        };
+        this.queue.push(queuedAction);
+        this.notifyChange();
+        return id;
+    }
+    /**
+     * Remove an action from the queue
+     */
+    remove(id) {
+        const initialLength = this.queue.length;
+        this.queue = this.queue.filter((action) => action.id !== id);
+        if (this.queue.length !== initialLength) {
+            this.notifyChange();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get all queued actions
+     */
+    getAll() {
+        return [...this.queue];
+    }
+    /**
+     * Get the number of queued actions
+     */
+    get size() {
+        return this.queue.length;
+    }
+    /**
+     * Check if queue is currently processing
+     */
+    get processing() {
+        return this.isProcessing;
+    }
+    /**
+     * Clear all queued actions
+     */
+    clear() {
+        this.queue = [];
+        this.notifyChange();
+    }
+    /**
+     * Process all queued actions
+     * Call this when the user comes back online
+     */
+    async process() {
+        var _a, _b, _c, _d;
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        // Process actions in order
+        while (this.queue.length > 0) {
+            const action = this.queue[0];
+            try {
+                const result = await action.action();
+                (_b = (_a = this.options).onActionSuccess) === null || _b === void 0 ? void 0 : _b.call(_a, action, result);
+                this.queue.shift(); // Remove successful action
+                this.notifyChange();
+            }
+            catch (error) {
+                action.retryCount++;
+                if (action.retryCount >= action.maxRetries) {
+                    // Max retries reached, remove and report failure
+                    (_d = (_c = this.options).onActionFailed) === null || _d === void 0 ? void 0 : _d.call(_c, action, error instanceof Error
+                        ? error
+                        : new QueueError("Action failed after max retries", action.id, error));
+                    this.queue.shift();
+                    this.notifyChange();
+                }
+                else {
+                    // Will retry on next process() call
+                    this.notifyChange();
+                    break; // Stop processing, wait for next attempt
+                }
+            }
+        }
+        this.isProcessing = false;
+    }
+}
+/**
+ * Create an ActionQueue instance
+ */
+const createActionQueue = (options) => {
+    return new ActionQueue(options);
+};
+/**
+ * Default singleton queue for simple use cases
+ */
+let defaultQueue = null;
+const getDefaultQueue = () => {
+    if (!defaultQueue) {
+        defaultQueue = createActionQueue();
+    }
+    return defaultQueue;
+};
+
+export { ActionQueue, createActionQueue, getDefaultQueue };

package/dist/utils/cn.js

@@ -1,11 +1,7 @@
-import { clsx } from '../node_modules/clsx/dist/clsx.js';
-import { twMerge } from '../node_modules/tailwind-merge/dist/bundle-mjs.js';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
 
-function cn() {
-    var inputs = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        inputs[_i] = arguments[_i];
-    }
+function cn(...inputs) {
     return twMerge(clsx(inputs));
 }
 

package/dist/utils/dateUtils.d.ts

@@ -56,3 +56,63 @@ export declare const isYesterday: (input: DateInput) => boolean;
  * Checks if a date is within the current week
  */
 export declare const isThisWeek: (input: DateInput) => boolean;
+/**
+ * Formats a date using a custom format string
+ * Supports common format tokens for flexible date display
+ *
+ * @param date - The date to format
+ * @param formatString - Format string with tokens (e.g., 'DD MMM YYYY', 'DD/MM/YYYY')
+ * @param locale - Optional locale for month names (default: 'en-US')
+ *
+ * Supported tokens:
+ * - DD: Day with leading zero (01, 02, ..., 31)
+ * - D: Day without leading zero (1, 2, ..., 31)
+ * - MMM: Short month name (Jan, Feb, ..., Dec)
+ * - MMMM: Full month name (January, February, ..., December)
+ * - MM: Month with leading zero (01, 02, ..., 12)
+ * - M: Month without leading zero (1, 2, ..., 12)
+ * - YYYY: Full year (2023, 2024, etc.)
+ * - YY: Two-digit year (23, 24, etc.)
+ *
+ * @example
+ * formatDateCustom(new Date('2023-09-21'), 'DD MMM YYYY') // "21 Sept 2023"
+ * formatDateCustom(new Date('2023-09-21'), 'DD/MM/YYYY') // "21/09/2023"
+ * formatDateCustom(new Date('2023-09-21'), 'MM-DD-YYYY') // "09-21-2023"
+ * formatDateCustom(new Date('2023-09-21'), 'D MMMM YYYY') // "21 September 2023"
+ */
+export declare const formatDateCustom: (date: Date, formatString: string, locale?: string) => string;
+/**
+ * Date range type for utility functions
+ */
+export interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+/**
+ * Get date range for the last N days
+ */
+export declare const getLastNDays: (days: number) => DateRange;
+/**
+ * Get date range for this week (Monday to Sunday)
+ */
+export declare const getThisWeek: () => DateRange;
+/**
+ * Get date range for last week (Monday to Sunday)
+ */
+export declare const getLastWeek: () => DateRange;
+/**
+ * Get date range for this month
+ */
+export declare const getThisMonth: () => DateRange;
+/**
+ * Get date range for last month
+ */
+export declare const getLastMonth: () => DateRange;
+/**
+ * Get date range for this year
+ */
+export declare const getThisYear: () => DateRange;
+/**
+ * Get date range for last year
+ */
+export declare const getLastYear: () => DateRange;

package/dist/utils/dateUtils.js

@@ -1,5 +1,3 @@
-import { __assign } from '../node_modules/tslib/tslib.es6.js';
-
 /**
  * Date and time utility functions for consistent formatting across the component library
  */
@@ -7,26 +5,83 @@ import { __assign } from '../node_modules/tslib/tslib.es6.js';
  * Formats a timestamp for display in chat messages, notifications, etc.
  * Shows time only for today, date + time for other days.
  */
-var formatTimestamp = function (input, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.alwaysShowDate, alwaysShowDate = _a === void 0 ? false : _a, _b = options.includeSeconds, includeSeconds = _b === void 0 ? false : _b, _c = options.use12Hour, use12Hour = _c === void 0 ? false : _c, locale = options.locale;
-    var date = new Date(input);
+const formatTimestamp = (input, options = {}) => {
+    const { alwaysShowDate = false, includeSeconds = false, use12Hour = false, locale } = options;
+    const date = new Date(input);
     // Check if date is valid
     if (isNaN(date.getTime())) {
         return 'Invalid date';
     }
     // Check if date is today
-    var now = new Date();
-    var isToday = date.toDateString() === now.toDateString();
-    var timeOptions = __assign(__assign({ hour: '2-digit', minute: '2-digit' }, (includeSeconds && { second: '2-digit' })), (use12Hour && { hour12: true }));
+    const now = new Date();
+    const isToday = date.toDateString() === now.toDateString();
+    const timeOptions = {
+        hour: '2-digit',
+        minute: '2-digit',
+        ...(includeSeconds && { second: '2-digit' }),
+        ...(use12Hour && { hour12: true }),
+    };
     if (isToday && !alwaysShowDate) {
         // Show time only if today
         return date.toLocaleTimeString(locale ? [locale] : [], timeOptions);
     }
     else {
         // Show date and time if not today or if alwaysShowDate is true
-        return date.toLocaleDateString(locale ? [locale] : [], __assign({ month: 'short', day: 'numeric' }, timeOptions));
+        return date.toLocaleDateString(locale ? [locale] : [], {
+            month: 'short',
+            day: 'numeric',
+            ...timeOptions,
+        });
+    }
+};
+/**
+ * Formats a date using a custom format string
+ * Supports common format tokens for flexible date display
+ *
+ * @param date - The date to format
+ * @param formatString - Format string with tokens (e.g., 'DD MMM YYYY', 'DD/MM/YYYY')
+ * @param locale - Optional locale for month names (default: 'en-US')
+ *
+ * Supported tokens:
+ * - DD: Day with leading zero (01, 02, ..., 31)
+ * - D: Day without leading zero (1, 2, ..., 31)
+ * - MMM: Short month name (Jan, Feb, ..., Dec)
+ * - MMMM: Full month name (January, February, ..., December)
+ * - MM: Month with leading zero (01, 02, ..., 12)
+ * - M: Month without leading zero (1, 2, ..., 12)
+ * - YYYY: Full year (2023, 2024, etc.)
+ * - YY: Two-digit year (23, 24, etc.)
+ *
+ * @example
+ * formatDateCustom(new Date('2023-09-21'), 'DD MMM YYYY') // "21 Sept 2023"
+ * formatDateCustom(new Date('2023-09-21'), 'DD/MM/YYYY') // "21/09/2023"
+ * formatDateCustom(new Date('2023-09-21'), 'MM-DD-YYYY') // "09-21-2023"
+ * formatDateCustom(new Date('2023-09-21'), 'D MMMM YYYY') // "21 September 2023"
+ */
+const formatDateCustom = (date, formatString, locale = 'en-US') => {
+    if (!(date instanceof Date) || isNaN(date.getTime())) {
+        return 'Invalid date';
     }
+    const day = date.getDate();
+    const month = date.getMonth() + 1;
+    const year = date.getFullYear();
+    // Get month names based on locale
+    const shortMonths = Array.from({ length: 12 }, (_, i) => new Date(2000, i, 1).toLocaleDateString(locale, { month: 'short' }));
+    const fullMonths = Array.from({ length: 12 }, (_, i) => new Date(2000, i, 1).toLocaleDateString(locale, { month: 'long' }));
+    // Replace tokens in order of length (longest first to avoid conflicts)
+    let result = formatString;
+    // Year tokens
+    result = result.replace(/YYYY/g, year.toString());
+    result = result.replace(/YY/g, year.toString().slice(-2));
+    // Month tokens (MMMM before MMM before MM before M)
+    result = result.replace(/MMMM/g, fullMonths[month - 1]);
+    result = result.replace(/MMM/g, shortMonths[month - 1]);
+    result = result.replace(/MM/g, month.toString().padStart(2, '0'));
+    result = result.replace(/M/g, month.toString());
+    // Day tokens (DD before D)
+    result = result.replace(/DD/g, day.toString().padStart(2, '0'));
+    result = result.replace(/D/g, day.toString());
+    return result;
 };
 
-export { formatTimestamp };
+export { formatDateCustom, formatTimestamp };

package/dist/utils/debounce.js

@@ -7,14 +7,10 @@
  * @returns A debounced version of the function
  */
 function debounce(func, wait) {
-    var timeoutId;
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+    let timeoutId;
+    return (...args) => {
         clearTimeout(timeoutId);
-        timeoutId = setTimeout(function () { return func.apply(void 0, args); }, wait);
+        timeoutId = setTimeout(() => func(...args), wait);
     };
 }
 

package/dist/utils/formValidation.d.ts

@@ -0,0 +1,20 @@
+import { StateIdentifier, StateMachineConfig } from "./stateMachine";
+/**
+ * Result of a step validation
+ * Can be a boolean, a string (single error), or an array of strings (multiple errors)
+ */
+export type ValidationResult = boolean | string | string[];
+/**
+ * Enhanced configuration that includes validation predicates for each step
+ */
+export interface ValidatedStateMachineConfig<TData> extends StateMachineConfig<TData> {
+    /** Map of states to validation functions */
+    validation?: Record<StateIdentifier, (data: TData) => ValidationResult | Promise<ValidationResult>>;
+}
+/**
+ * Helper to validate the data for a specific state
+ */
+export declare function validateStep<TData>(config: ValidatedStateMachineConfig<TData>, state: StateIdentifier, data: TData): Promise<{
+    success: boolean;
+    errors?: string[];
+}>;

package/dist/utils/formValidation.js

@@ -0,0 +1,21 @@
+/**
+ * Helper to validate the data for a specific state
+ */
+async function validateStep(config, state, data) {
+    var _a;
+    const validator = (_a = config.validation) === null || _a === void 0 ? void 0 : _a[state];
+    if (!validator)
+        return { success: true };
+    const result = await validator(data);
+    if (result === true)
+        return { success: true };
+    if (result === false)
+        return { success: false, errors: ["Invalid step data"] };
+    if (typeof result === "string")
+        return { success: false, errors: [result] };
+    if (Array.isArray(result))
+        return { success: false, errors: result };
+    return { success: true };
+}
+
+export { validateStep };

package/dist/utils/index.d.ts

@@ -1,5 +1,14 @@
-export { cn } from './cn';
-export { debounce } from './debounce';
-export { formatTimestamp, formatDate, formatTime, formatRelativeTime, isToday, isYesterday, isThisWeek, type DateInput, type TimestampOptions, } from './dateUtils';
-export { useClickOutside } from './useClickOutside';
-export { timeToMinutes, minutesToTime, getEventDuration, getTotalTimeSlots, getTimeSlotIndex, getTimeSlotForIndex, calculateEventPosition, calculateEventHeight, eventsOverlap, findOverlappingEvents, groupOverlappingEvents, resolveOverlappingEvents, generateTimeGrid, filterEventsByDate, sortEventsByStartTime, separateAllDayEvents, isValidTimeFormat, isValidDateFormat, validateEvent, DEFAULT_GRID_CONFIGS, type CalendarEvent, type GridConfig, type EventPosition, type EventLayout, type TimeSlot, } from './calendarUtils';
+export { cn } from "./cn";
+export { debounce } from "./debounce";
+export { formatTimestamp, formatDate, formatTime, formatDateCustom, formatRelativeTime, isToday, isYesterday, isThisWeek, getLastNDays, getThisWeek, getLastWeek, getThisMonth, getLastMonth, getThisYear, getLastYear, type DateInput, type TimestampOptions, type DateRange, } from "./dateUtils";
+export { useClickOutside } from "./useClickOutside";
+export { findNextMatchingOption, isValidTypeaheadChar, TYPEAHEAD_TIMEOUT_MS, type TypeaheadOption, type FindNextMatchingOptionParams, } from "./typeaheadUtils";
+export { timeToMinutes, minutesToTime, getEventDuration, getTotalTimeSlots, getTimeSlotIndex, getTimeSlotForIndex, calculateEventPosition, calculateEventHeight, eventsOverlap, findOverlappingEvents, groupOverlappingEvents, resolveOverlappingEvents, generateTimeGrid, filterEventsByDate, sortEventsByStartTime, separateAllDayEvents, isValidTimeFormat, isValidDateFormat, validateEvent, DEFAULT_GRID_CONFIGS, type CalendarEvent, type GridConfig, type EventPosition, type EventLayout, type TimeSlot, } from "./calendarUtils";
+export { parseOpenAI, parseAnthropic, parseGemini, parseSSELine, SSE_PARSERS, type SSEFormat, type SSEParser, } from "./sseFormatParsers";
+export { StreamingNetworkError, StreamingTimeoutError, StreamingParseError, StreamingAbortError, StreamingServerError, normalizeError, type StreamingError, } from "./streamingErrors";
+export { calculateRetryDelay, shouldRetry, type RetryConfig, } from "./retryUtils";
+export { MutationError, RollbackError, QueueError, OptimisticNetworkError, normalizeOptimisticError, isOptimisticError, type OptimisticError, } from "./optimisticErrors";
+export { ActionQueue, createActionQueue, getDefaultQueue, type QueuedAction, type ActionQueueOptions, type AddActionOptions, } from "./actionQueue";
+export * from "./stateMachine";
+export * from "./formValidation";
+export { formatTypingText, formatPresenceCount, validatePresenceUser, validateTypingUser, sortUsers, } from "./presenceUtils";

package/dist/utils/optimisticErrors.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Optimistic Mutation Error Classes
+ * Defines error types for optimistic UI updates with rollback support
+ */
+/**
+ * Base optimistic error interface
+ */
+export interface OptimisticError {
+    type: "mutation" | "rollback" | "queue" | "network";
+    message: string;
+    originalData?: unknown;
+    rollbackData?: unknown;
+    retryable: boolean;
+}
+/**
+ * Mutation error - occurs when the server rejects the mutation
+ * Retryable: Depends on error type (network yes, validation no)
+ */
+export declare class MutationError extends Error implements OptimisticError {
+    retryable: boolean;
+    originalData?: unknown | undefined;
+    rollbackData?: unknown | undefined;
+    details?: unknown | undefined;
+    type: "mutation";
+    constructor(message: string, retryable?: boolean, originalData?: unknown | undefined, rollbackData?: unknown | undefined, details?: unknown | undefined);
+}
+/**
+ * Rollback error - occurs when attempting to rollback optimistic state fails
+ * Retryable: No (indicates a serious state corruption issue)
+ */
+export declare class RollbackError extends Error implements OptimisticError {
+    originalData?: unknown | undefined;
+    rollbackData?: unknown | undefined;
+    details?: unknown | undefined;
+    type: "rollback";
+    retryable: boolean;
+    constructor(message: string, originalData?: unknown | undefined, rollbackData?: unknown | undefined, details?: unknown | undefined);
+}
+/**
+ * Queue error - occurs when action queue operations fail
+ * Retryable: Yes (queue operations can be retried)
+ */
+export declare class QueueError extends Error implements OptimisticError {
+    actionId?: string | undefined;
+    details?: unknown | undefined;
+    type: "queue";
+    retryable: boolean;
+    constructor(message: string, actionId?: string | undefined, details?: unknown | undefined);
+    originalData: undefined;
+    rollbackData: undefined;
+}
+/**
+ * Network error for optimistic operations - typically connection issues
+ * Retryable: Yes
+ */
+export declare class OptimisticNetworkError extends Error implements OptimisticError {
+    originalData?: unknown | undefined;
+    rollbackData?: unknown | undefined;
+    details?: unknown | undefined;
+    type: "network";
+    retryable: boolean;
+    constructor(message: string, originalData?: unknown | undefined, rollbackData?: unknown | undefined, details?: unknown | undefined);
+}
+/**
+ * Normalize any error into an OptimisticError
+ * Used to convert unknown errors into typed optimistic errors
+ *
+ * @param error - Any error object
+ * @param context - Optional context for rollback (originalData, rollbackData)
+ * @returns Normalized OptimisticError
+ */
+export declare const normalizeOptimisticError: (error: unknown, context?: {
+    originalData?: unknown;
+    rollbackData?: unknown;
+}) => OptimisticError;
+/**
+ * Check if an error is an OptimisticError
+ */
+export declare const isOptimisticError: (error: unknown) => error is OptimisticError;