@rilaykit/workflow 7.1.0 → 8.0.0

package/dist/index.d.mts

@@ -5,6 +5,169 @@ export { form } from '@rilaykit/forms';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React$1 from 'react';
 
+interface WorkflowState {
+    currentStepIndex: number;
+    allData: Record<string, any>;
+    stepData: Record<string, any>;
+    visitedSteps: Set<string>;
+    isSubmitting: boolean;
+    isTransitioning: boolean;
+    isInitializing: boolean;
+}
+interface UseWorkflowStateProps {
+    defaultValues?: Record<string, any>;
+    persistence?: {
+        workflowId: string;
+        adapter?: WorkflowPersistenceAdapter;
+        options?: PersistenceOptions;
+        userId?: string;
+        autoLoad?: boolean;
+    };
+}
+declare function useWorkflowState({ defaultValues, persistence }: UseWorkflowStateProps): {
+    workflowState: WorkflowState;
+    setCurrentStep: (stepIndex: number) => void;
+    setStepData: (data: Record<string, any>, stepId: string) => void;
+    setFieldValue: (fieldId: string, value: any, stepId: string) => void;
+    setSubmitting: (isSubmitting: boolean) => void;
+    setTransitioning: (isTransitioning: boolean) => void;
+    markStepVisited: (stepIndex: number, stepId: string) => void;
+    resetWorkflow: () => void;
+    loadPersistedState: () => Promise<boolean>;
+    persistence: {
+        isPersisting: boolean;
+        persistenceError: WorkflowPersistenceError | null;
+        persistNow: () => Promise<void>;
+        clearPersistedData: () => Promise<void>;
+        hasPersistedData: () => Promise<boolean>;
+    } | null;
+};
+
+/**
+ * @fileoverview Persistence system types for Rilay workflows
+ *
+ * This module defines the core interfaces and types for the workflow persistence system.
+ * It provides a flexible adapter pattern allowing different persistence strategies:
+ * - localStorage persistence
+ * - API-based persistence
+ * - Custom persistence implementations
+ *
+ * The system is designed to be type-safe and extensible while maintaining
+ * a simple API for common use cases.
+ */
+
+/**
+ * Persistent workflow data that gets saved/loaded
+ */
+interface PersistedWorkflowData {
+    /** Unique identifier for the workflow */
+    workflowId: string;
+    /** Current step index in the workflow */
+    currentStepIndex: number;
+    /** All collected data across steps */
+    allData: Record<string, any>;
+    /** Currently active step data */
+    stepData: Record<string, any>;
+    /** Set of visited step IDs */
+    visitedSteps: string[];
+    /** When this data was last saved */
+    lastSaved: number;
+    /** Optional metadata for custom persistence needs */
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for persistence operations
+ */
+interface PersistenceOptions {
+    /** Whether to automatically persist on state changes */
+    autoPersist?: boolean;
+    /** Debounce delay in ms for auto-persistence (default: 500ms) */
+    debounceMs?: number;
+    /** Custom key for storage (overrides default) */
+    storageKey?: string;
+    /** Additional metadata to include in persisted data */
+    metadata?: Record<string, any>;
+}
+/**
+ * Core persistence adapter interface
+ *
+ * All persistence implementations must implement this interface.
+ * It provides a consistent API regardless of the underlying storage mechanism.
+ */
+interface WorkflowPersistenceAdapter {
+    /**
+     * Save workflow data
+     * @param key - Unique identifier for the stored data
+     * @param data - Workflow data to persist
+     * @returns Promise that resolves when save is complete
+     */
+    save(key: string, data: PersistedWorkflowData): Promise<void>;
+    /**
+     * Load workflow data
+     * @param key - Unique identifier for the stored data
+     * @returns Promise that resolves to persisted data or null if not found
+     */
+    load(key: string): Promise<PersistedWorkflowData | null>;
+    /**
+     * Remove persisted workflow data
+     * @param key - Unique identifier for the stored data
+     * @returns Promise that resolves when deletion is complete
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Check if data exists for the given key
+     * @param key - Unique identifier to check
+     * @returns Promise that resolves to true if data exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * List all available keys (optional, for debugging/admin)
+     * @returns Promise that resolves to array of available keys
+     */
+    listKeys?(): Promise<string[]>;
+    /**
+     * Clear all persisted data (optional, for cleanup)
+     * @returns Promise that resolves when all data is cleared
+     */
+    clear?(): Promise<void>;
+}
+/**
+ * Configuration for localStorage persistence adapter
+ */
+interface LocalStorageAdapterConfig {
+    /** Prefix for localStorage keys (default: 'rilay_workflow_') */
+    keyPrefix?: string;
+    /** Whether to compress data before storage */
+    compress?: boolean;
+    /** Maximum age in ms before data expires (optional) */
+    maxAge?: number;
+}
+/**
+ * Error types for persistence operations
+ */
+declare class WorkflowPersistenceError extends Error {
+    readonly code: string;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: string, cause?: Error | undefined);
+}
+/**
+ * Persistence hook return type
+ */
+interface UsePersistenceReturn {
+    /** Whether persistence is currently saving */
+    isPersisting: boolean;
+    /** Last persistence error (if any) */
+    persistenceError: WorkflowPersistenceError | null;
+    /** Manually trigger a save operation */
+    persistNow: () => Promise<void>;
+    /** Load data from persistence */
+    loadPersistedData: () => Promise<PersistedWorkflowData | null>;
+    /** Clear persisted data */
+    clearPersistedData: () => Promise<void>;
+    /** Whether persisted data exists */
+    hasPersistedData: () => Promise<boolean>;
+}
+
 /**
  * Enhanced step configuration interface for better type safety and simplicity
  *
@@ -55,6 +218,30 @@ interface StepDefinition {
      * Controls visibility and skippable state
      */
     conditions?: StepConditionalBehavior;
+    /**
+     * Custom metadata for this step
+     * Allows storing arbitrary information that can be accessed via hooks and context
+     *
+     * This is useful for:
+     * - UI customization (icons, colors, themes)
+     * - Analytics tracking (categories, priorities, custom events)
+     * - Business logic flags (feature flags, permissions, workflow rules)
+     * - Integration data (external IDs, API endpoints, configuration)
+     *
+     * @example
+     * ```typescript
+     * {
+     *   metadata: {
+     *     icon: 'user-circle',
+     *     category: 'personal-info',
+     *     analytics: { trackCompletion: true, priority: 'high' },
+     *     ui: { theme: 'primary', showProgress: true },
+     *     business: { requiresApproval: false, estimatedTime: 120 }
+     *   }
+     * }
+     * ```
+     */
+    metadata?: Record<string, any>;
     /**
      * Callback function that executes after successful validation and before moving to next step
      * Provides clean helper methods for modifying workflow data and pre-filling subsequent steps
@@ -97,6 +284,12 @@ interface StepDefinition {
 interface WorkflowOptions {
     /** Analytics and tracking configuration */
     analytics?: WorkflowAnalytics;
+    /** Persistence configuration */
+    persistence?: {
+        adapter: WorkflowPersistenceAdapter;
+        options?: PersistenceOptions;
+        userId?: string;
+    };
 }
 /**
  * Workflow builder class for creating complex multi-step workflows
@@ -141,6 +334,7 @@ declare class flow {
     private workflowDescription?;
     private steps;
     private analytics?;
+    private persistenceConfig?;
     private plugins;
     private idGenerator;
     /**
@@ -231,17 +425,14 @@ declare class flow {
      * @example
      * ```typescript
      * workflow.configure({
-     *   navigation: {
-     *     allowBackNavigation: true,
-     *     showProgressBar: true
-     *   },
-     *   persistence: {
-     *     saveOnStepComplete: true,
-     *     storageKey: 'my-workflow'
-     *   },
      *   analytics: {
      *     trackStepCompletion: true,
      *     trackFieldInteractions: false
+     *   },
+     *   persistence: {
+     *     adapter: new LocalStorageAdapter(),
+     *     options: { autoPersist: true, debounceMs: 1000 },
+     *     userId: 'user123'
      *   }
      * });
      * ```
@@ -556,215 +747,146 @@ interface ConditionEvaluationResult {
  * @returns Evaluated condition results
  */
 declare function useConditionEvaluation(conditions?: ConditionalBehavior, workflowData?: Record<string, any>, defaultState?: Partial<ConditionEvaluationResult>): ConditionEvaluationResult;
-/**
- * Hook to evaluate multiple field conditions at once
- *
- * @param fieldsWithConditions - Map of field IDs to their conditional behaviors
- * @param workflowData - Current workflow data to evaluate against
- * @returns Map of field IDs to their evaluated conditions
- */
-declare function useMultipleConditionEvaluation(fieldsWithConditions: Record<string, ConditionalBehavior | undefined>, workflowData?: Record<string, any>): Record<string, ConditionEvaluationResult>;
-/**
- * Hook to evaluate multiple step conditions at once using numeric indices
- *
- * @param stepsWithConditions - Map of step indices to their conditional behaviors
- * @param workflowData - Current workflow data to evaluate against
- * @returns Map of step indices to their evaluated conditions
- */
-declare function useMultipleStepConditionEvaluation(stepsWithConditions: Record<number, ConditionalBehavior | undefined>, workflowData?: Record<string, any>): Record<number, ConditionEvaluationResult>;
 
 /**
- * @fileoverview Persistence system types for Rilay workflows
- *
- * This module defines the core interfaces and types for the workflow persistence system.
- * It provides a flexible adapter pattern allowing different persistence strategies:
- * - localStorage persistence
- * - API-based persistence
- * - Custom persistence implementations
+ * @fileoverview Persistence hook for Rilay workflows
  *
- * The system is designed to be type-safe and extensible while maintaining
- * a simple API for common use cases.
+ * This hook provides workflow persistence functionality with automatic
+ * debounced saving, error handling, and flexible adapter support.
+ * It integrates seamlessly with the existing workflow state management.
  */
 
-/**
- * Persistent workflow data that gets saved/loaded
- */
-interface PersistedWorkflowData {
-    /** Unique identifier for the workflow */
+interface UsePersistenceProps {
+    /** Unique workflow identifier */
     workflowId: string;
-    /** Current step index in the workflow */
-    currentStepIndex: number;
-    /** All collected data across steps */
-    allData: Record<string, any>;
-    /** Currently active step data */
-    stepData: Record<string, any>;
-    /** Set of visited step IDs */
-    visitedSteps: string[];
-    /** When this data was last saved */
-    lastSaved: number;
-    /** Optional metadata for custom persistence needs */
-    metadata?: Record<string, any>;
+    /** Current workflow state */
+    workflowState: WorkflowState;
+    /** Persistence adapter to use */
+    adapter: WorkflowPersistenceAdapter;
+    /** Persistence options */
+    options?: PersistenceOptions;
+    /** Optional user ID for multi-user scenarios */
+    userId?: string;
 }
 /**
- * Options for persistence operations
+ * Hook for managing workflow persistence
+ *
+ * Provides automatic persistence with debouncing, manual save/load operations,
+ * and comprehensive error handling. Integrates with any persistence adapter
+ * that implements the WorkflowPersistenceAdapter interface.
+ *
+ * @example
+ * ```typescript
+ * const persistence = usePersistence({
+ *   workflowId: 'user-onboarding',
+ *   workflowState,
+ *   adapter: new LocalStorageAdapter(),
+ *   options: {
+ *     autoPersist: true,
+ *     debounceMs: 1000
+ *   }
+ * });
+ *
+ * if (persistence.persistenceError) {
+ *   console.error('Persistence error:', persistence.persistenceError);
+ * }
+ * ```
  */
-interface PersistenceOptions {
-    /** Whether to automatically persist on state changes */
-    autoPersist?: boolean;
-    /** Debounce delay in ms for auto-persistence (default: 500ms) */
-    debounceMs?: number;
-    /** Custom key for storage (overrides default) */
-    storageKey?: string;
-    /** Additional metadata to include in persisted data */
-    metadata?: Record<string, any>;
-}
+declare function usePersistence({ workflowId, workflowState, adapter, options, userId, }: UsePersistenceProps): UsePersistenceReturn;
+
 /**
- * Core persistence adapter interface
- *
- * All persistence implementations must implement this interface.
- * It provides a consistent API regardless of the underlying storage mechanism.
+ * Hook return type for step metadata access
  */
-interface WorkflowPersistenceAdapter {
+interface UseStepMetadataReturn {
     /**
-     * Save workflow data
-     * @param key - Unique identifier for the stored data
-     * @param data - Workflow data to persist
-     * @returns Promise that resolves when save is complete
+     * Metadata for the current step
      */
-    save(key: string, data: PersistedWorkflowData): Promise<void>;
+    current: Record<string, any> | undefined;
     /**
-     * Load workflow data
-     * @param key - Unique identifier for the stored data
-     * @returns Promise that resolves to persisted data or null if not found
+     * Get metadata for a specific step by ID
+     * @param stepId - The ID of the step to get metadata for
+     * @returns The metadata object or undefined if step not found
      */
-    load(key: string): Promise<PersistedWorkflowData | null>;
+    getByStepId: (stepId: string) => Record<string, any> | undefined;
     /**
-     * Remove persisted workflow data
-     * @param key - Unique identifier for the stored data
-     * @returns Promise that resolves when deletion is complete
+     * Get metadata for a specific step by index
+     * @param stepIndex - The index of the step to get metadata for
+     * @returns The metadata object or undefined if step not found
      */
-    remove(key: string): Promise<void>;
+    getByStepIndex: (stepIndex: number) => Record<string, any> | undefined;
     /**
-     * Check if data exists for the given key
-     * @param key - Unique identifier to check
-     * @returns Promise that resolves to true if data exists
+     * Check if current step has specific metadata key
+     * @param key - The metadata key to check for
+     * @returns True if the key exists in current step metadata
      */
-    exists(key: string): Promise<boolean>;
+    hasCurrentKey: (key: string) => boolean;
     /**
-     * List all available keys (optional, for debugging/admin)
-     * @returns Promise that resolves to array of available keys
+     * Get specific metadata value from current step
+     * @param key - The metadata key to retrieve
+     * @param defaultValue - Default value if key doesn't exist
+     * @returns The metadata value or default value
      */
-    listKeys?(): Promise<string[]>;
+    getCurrentValue: <T = any>(key: string, defaultValue?: T) => T;
     /**
-     * Clear all persisted data (optional, for cleanup)
-     * @returns Promise that resolves when all data is cleared
+     * Get all steps with their metadata
+     * @returns Array of objects containing step info and metadata
      */
-    clear?(): Promise<void>;
-}
-/**
- * Configuration for localStorage persistence adapter
- */
-interface LocalStorageAdapterConfig {
-    /** Prefix for localStorage keys (default: 'rilay_workflow_') */
-    keyPrefix?: string;
-    /** Whether to compress data before storage */
-    compress?: boolean;
-    /** Maximum age in ms before data expires (optional) */
-    maxAge?: number;
-}
-/**
- * Error types for persistence operations
- */
-declare class WorkflowPersistenceError extends Error {
-    readonly code: string;
-    readonly cause?: Error | undefined;
-    constructor(message: string, code: string, cause?: Error | undefined);
+    getAllStepsMetadata: () => Array<{
+        id: string;
+        title: string;
+        index: number;
+        metadata: Record<string, any> | undefined;
+    }>;
+    /**
+     * Find steps by metadata criteria
+     * @param predicate - Function to test each step's metadata
+     * @returns Array of step IDs that match the criteria
+     */
+    findStepsByMetadata: (predicate: (metadata: Record<string, any> | undefined, stepId: string, stepIndex: number) => boolean) => string[];
 }
 /**
- * Persistence hook return type
+ * Hook to access and work with step metadata in workflows
+ *
+ * This hook provides convenient methods to access metadata for the current step
+ * or any other step in the workflow. It's useful for UI customization, analytics,
+ * business logic, and integration scenarios.
+ *
+ * @returns Object containing metadata access methods and current step metadata
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const {
+ *     current,
+ *     getCurrentValue,
+ *     hasCurrentKey,
+ *     getByStepId,
+ *     findStepsByMetadata
+ *   } = useStepMetadata();
+ *
+ *   // Access current step metadata
+ *   const stepIcon = getCurrentValue('icon', 'default-icon');
+ *   const hasAnalytics = hasCurrentKey('analytics');
+ *
+ *   // Find steps with specific metadata
+ *   const importantSteps = findStepsByMetadata(
+ *     (metadata) => metadata?.priority === 'high'
+ *   );
+ *
+ *   // Get metadata from specific step
+ *   const paymentStepMeta = getByStepId('payment-step');
+ *
+ *   return (
+ *     <div>
+ *       <Icon name={stepIcon} />
+ *       {hasAnalytics && <AnalyticsTracker />}
+ *       <p>Important steps: {importantSteps.length}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
  */
-interface UsePersistenceReturn {
-    /** Whether persistence is currently saving */
-    isPersisting: boolean;
-    /** Last persistence error (if any) */
-    persistenceError: WorkflowPersistenceError | null;
-    /** Manually trigger a save operation */
-    persistNow: () => Promise<void>;
-    /** Load data from persistence */
-    loadPersistedData: () => Promise<PersistedWorkflowData | null>;
-    /** Clear persisted data */
-    clearPersistedData: () => Promise<void>;
-    /** Whether persisted data exists */
-    hasPersistedData: () => Promise<boolean>;
-}
-
-interface WorkflowState {
-    currentStepIndex: number;
-    allData: Record<string, any>;
-    stepData: Record<string, any>;
-    visitedSteps: Set<string>;
-    isSubmitting: boolean;
-    isTransitioning: boolean;
-}
-type WorkflowAction = {
-    type: 'SET_CURRENT_STEP';
-    stepIndex: number;
-} | {
-    type: 'SET_STEP_DATA';
-    data: Record<string, any>;
-    stepId: string;
-} | {
-    type: 'SET_ALL_DATA';
-    data: Record<string, any>;
-} | {
-    type: 'SET_FIELD_VALUE';
-    fieldId: string;
-    value: any;
-    stepId: string;
-} | {
-    type: 'SET_SUBMITTING';
-    isSubmitting: boolean;
-} | {
-    type: 'SET_TRANSITIONING';
-    isTransitioning: boolean;
-} | {
-    type: 'MARK_STEP_VISITED';
-    stepIndex: number;
-    stepId: string;
-} | {
-    type: 'RESET_WORKFLOW';
-} | {
-    type: 'LOAD_PERSISTED_STATE';
-    state: Partial<WorkflowState>;
-};
-interface UseWorkflowStateProps {
-    defaultValues?: Record<string, any>;
-    persistence?: {
-        workflowId: string;
-        adapter?: WorkflowPersistenceAdapter;
-        options?: PersistenceOptions;
-        userId?: string;
-        autoLoad?: boolean;
-    };
-}
-declare function useWorkflowState({ defaultValues, persistence }: UseWorkflowStateProps): {
-    workflowState: WorkflowState;
-    setCurrentStep: (stepIndex: number) => void;
-    setStepData: (data: Record<string, any>, stepId: string) => void;
-    setFieldValue: (fieldId: string, value: any, stepId: string) => void;
-    setSubmitting: (isSubmitting: boolean) => void;
-    setTransitioning: (isTransitioning: boolean) => void;
-    markStepVisited: (stepIndex: number, stepId: string) => void;
-    resetWorkflow: () => void;
-    loadPersistedState: () => Promise<boolean>;
-    persistence: {
-        isPersisting: boolean;
-        persistenceError: WorkflowPersistenceError | null;
-        persistNow: () => Promise<void>;
-        clearPersistedData: () => Promise<void>;
-        hasPersistedData: () => Promise<boolean>;
-    } | null;
-};
+declare function useStepMetadata(): UseStepMetadataReturn;
 
 interface UseWorkflowAnalyticsProps {
     workflowConfig: WorkflowConfig;
@@ -858,6 +980,7 @@ interface WorkflowContextValue {
     context: WorkflowContext;
     formConfig?: FormConfiguration;
     conditionsHelpers: UseWorkflowConditionsReturn;
+    currentStepMetadata?: Record<string, any>;
     goToStep: (stepIndex: number) => Promise<boolean>;
     goNext: () => Promise<boolean>;
     goPrevious: () => Promise<boolean>;
@@ -872,6 +995,9 @@ interface WorkflowContextValue {
     submitWorkflow: () => Promise<void>;
     isSubmitting: boolean;
     canSubmit: boolean;
+    persistNow?: () => Promise<void>;
+    isPersisting?: boolean;
+    persistenceError?: Error | null;
 }
 interface WorkflowProviderProps {
     children: React$1.ReactNode;
@@ -896,17 +1022,41 @@ type WorkflowProps = Omit<WorkflowProviderProps, 'children' | 'workflowConfig'>
  */
 declare function Workflow({ children, workflowConfig, ...props }: WorkflowProps): react_jsx_runtime.JSX.Element;
 
+interface WorkflowBodyProps {
+    stepId?: string;
+}
 /**
  * Renders the main content of the current workflow step.
  * Simple component that renders either the children or FormBody by default.
  */
-declare function WorkflowBody(): react_jsx_runtime.JSX.Element | null;
+declare function WorkflowBody({ stepId }: WorkflowBodyProps): react_jsx_runtime.JSX.Element | null;
 
-declare function WorkflowNextButton({ className, ...props }: ComponentRendererBaseProps<WorkflowNextButtonRendererProps>): react_jsx_runtime.JSX.Element;
+interface WorkflowNextButtonProps extends ComponentRendererBaseProps<WorkflowNextButtonRendererProps> {
+    /**
+     * Override the isSubmitting state from workflow/form context
+     * If provided, this value will be used instead of the computed isSubmitting state
+     */
+    isSubmitting?: boolean;
+}
+declare function WorkflowNextButton({ className, isSubmitting: overrideIsSubmitting, ...props }: WorkflowNextButtonProps): react_jsx_runtime.JSX.Element;
 
-declare function WorkflowPreviousButton({ className, ...props }: ComponentRendererBaseProps<WorkflowPreviousButtonRendererProps>): react_jsx_runtime.JSX.Element;
+interface WorkflowPreviousButtonProps extends ComponentRendererBaseProps<WorkflowPreviousButtonRendererProps> {
+    /**
+     * Override the isSubmitting state from workflow/form context
+     * If provided, this value will be used instead of the computed isSubmitting state
+     */
+    isSubmitting?: boolean;
+}
+declare function WorkflowPreviousButton({ className, isSubmitting: overrideIsSubmitting, ...props }: WorkflowPreviousButtonProps): react_jsx_runtime.JSX.Element;
 
-declare function WorkflowSkipButton({ className, ...props }: ComponentRendererBaseProps<WorkflowSkipButtonRendererProps>): react_jsx_runtime.JSX.Element;
+interface WorkflowSkipButtonProps extends ComponentRendererBaseProps<WorkflowSkipButtonRendererProps> {
+    /**
+     * Override the isSubmitting state from workflow/form context
+     * If provided, this value will be used instead of the computed isSubmitting state
+     */
+    isSubmitting?: boolean;
+}
+declare function WorkflowSkipButton({ className, isSubmitting: overrideIsSubmitting, ...props }: WorkflowSkipButtonProps): react_jsx_runtime.JSX.Element;
 
 interface WorkflowStepperProps extends ComponentRendererBaseProps<WorkflowStepperRendererProps> {
     onStepClick?: (stepIndex: number) => void;
@@ -1031,52 +1181,6 @@ declare function debounce<T extends (...args: any[]) => any>(func: T, wait: numb
  */
 declare function mergePersistedState(currentState: WorkflowState, persistedData: PersistedWorkflowData, strategy?: 'persist' | 'current' | 'merge'): Partial<WorkflowState>;
 
-/**
- * @fileoverview Persistence hook for Rilay workflows
- *
- * This hook provides workflow persistence functionality with automatic
- * debounced saving, error handling, and flexible adapter support.
- * It integrates seamlessly with the existing workflow state management.
- */
-
-interface UsePersistenceProps {
-    /** Unique workflow identifier */
-    workflowId: string;
-    /** Current workflow state */
-    workflowState: WorkflowState;
-    /** Persistence adapter to use */
-    adapter: WorkflowPersistenceAdapter;
-    /** Persistence options */
-    options?: PersistenceOptions;
-    /** Optional user ID for multi-user scenarios */
-    userId?: string;
-}
-/**
- * Hook for managing workflow persistence
- *
- * Provides automatic persistence with debouncing, manual save/load operations,
- * and comprehensive error handling. Integrates with any persistence adapter
- * that implements the WorkflowPersistenceAdapter interface.
- *
- * @example
- * ```typescript
- * const persistence = usePersistence({
- *   workflowId: 'user-onboarding',
- *   workflowState,
- *   adapter: new LocalStorageAdapter(),
- *   options: {
- *     autoPersist: true,
- *     debounceMs: 1000
- *   }
- * });
- *
- * if (persistence.persistenceError) {
- *   console.error('Persistence error:', persistence.persistenceError);
- * }
- * ```
- */
-declare function usePersistence({ workflowId, workflowState, adapter, options, userId, }: UsePersistenceProps): UsePersistenceReturn;
-
 interface LicensePayload {
     plan: 'ARCHITECT' | 'FOUNDRY';
     company: string;
@@ -1145,4 +1249,4 @@ declare class RilayLicenseManager {
     }>;
 }
 
-export { type ConditionEvaluationResult, type LicensePayload, type LicensePlan, type LicenseResult, LocalStorageAdapter, type LocalStorageAdapterConfig, type PersistedWorkflowData, type PersistenceOptions, RilayLicenseManager, type StepConditionResult, type StepDefinition, type UsePersistenceProps, type UsePersistenceReturn, type UseWorkflowAnalyticsProps, type UseWorkflowAnalyticsReturn, type UseWorkflowConditionsProps, type UseWorkflowConditionsReturn, type UseWorkflowNavigationProps, type UseWorkflowNavigationReturn, type UseWorkflowStateProps, type UseWorkflowSubmissionProps, type UseWorkflowSubmissionReturn, Workflow, type WorkflowAction, WorkflowBody, type WorkflowContextValue, WorkflowNextButton, type WorkflowPersistenceAdapter, WorkflowPersistenceError, WorkflowPreviousButton, WorkflowProvider, WorkflowSkipButton, type WorkflowState, WorkflowStepper, createFlow, debounce, flow, generateStorageKey, mergePersistedState, persistedToWorkflowState, useConditionEvaluation, useMultipleConditionEvaluation, useMultipleStepConditionEvaluation, usePersistence, useWorkflowAnalytics, useWorkflowConditions, useWorkflowContext, useWorkflowNavigation, useWorkflowState, useWorkflowSubmission, validatePersistedData, workflowStateToPersisted };
+export { type LicensePayload, type LicensePlan, type LicenseResult, LocalStorageAdapter, type LocalStorageAdapterConfig, type PersistedWorkflowData, type PersistenceOptions, RilayLicenseManager, type StepDefinition, type UsePersistenceProps, type UsePersistenceReturn, Workflow, WorkflowBody, type WorkflowContextValue, WorkflowNextButton, type WorkflowPersistenceAdapter, WorkflowPersistenceError, WorkflowPreviousButton, WorkflowProvider, WorkflowSkipButton, WorkflowStepper, createFlow, debounce, flow, generateStorageKey, mergePersistedState, persistedToWorkflowState, useConditionEvaluation, usePersistence, useStepMetadata, useWorkflowAnalytics, useWorkflowConditions, useWorkflowContext, useWorkflowNavigation, useWorkflowState, useWorkflowSubmission, validatePersistedData, workflowStateToPersisted };