@signaltree/core 4.0.1 → 4.0.2

package/dist/index.d.ts

@@ -1,1384 +0,0 @@
-import { WritableSignal, Signal } from '@angular/core';
-export { deepEqual, deepEqual as equal, isBuiltInObject, parsePath } from '@signaltree/shared';
-
-/**
- * Security validator for SignalTree to prevent common vulnerabilities
- * @packageDocumentation
- */
-/**
- * Security event types for monitoring and logging
- */
-type SecurityEventType = 'dangerous-key-blocked' | 'xss-attempt-blocked' | 'function-value-blocked' | 'validation-error';
-/**
- * Security event callback signature
- */
-interface SecurityEvent {
-    type: SecurityEventType;
-    key?: string;
-    value?: unknown;
-    reason: string;
-    timestamp: number;
-}
-/**
- * Configuration options for SecurityValidator
- */
-interface SecurityValidatorConfig {
-    /**
-     * Enable prototype pollution prevention (default: true)
-     */
-    preventPrototypePollution?: boolean;
-    /**
-     * Enable XSS sanitization (default: false)
-     * When enabled, string values are sanitized to prevent script injection
-     */
-    preventXSS?: boolean;
-    /**
-     * Reject function values to ensure serializable state (default: true)
-     * Functions cannot be serialized and break time-travel, persistence, etc.
-     * This is ALWAYS enforced with no escape hatch to guarantee state serializability.
-     */
-    preventFunctions?: boolean;
-    /**
-     * Additional dangerous keys to block beyond the built-in list
-     */
-    customDangerousKeys?: string[];
-    /**
-     * Callback for security events (for logging/monitoring)
-     */
-    onSecurityEvent?: (event: SecurityEvent) => void;
-    /**
-     * Sanitization mode: 'strict' removes all HTML, 'permissive' allows safe HTML
-     * (default: 'strict')
-     */
-    sanitizationMode?: 'strict' | 'permissive';
-}
-/**
- * SecurityValidator prevents common security vulnerabilities in SignalTree
- *
- * Features:
- * - Prototype pollution prevention (blocks __proto__, constructor, prototype)
- * - XSS prevention (sanitizes string values)
- * - Security event callbacks for monitoring
- * - Configurable validation rules
- *
- * @example
- * ```ts
- * const validator = new SecurityValidator({
- *   preventPrototypePollution: true,
- *   preventXSS: true,
- *   onSecurityEvent: (event) => console.warn('Security event:', event)
- * });
- *
- * // This will throw an error
- * validator.validateKey('__proto__');
- *
- * // This will sanitize the value
- * const safe = validator.validateValue('<script>alert("xss")</script>');
- * ```
- */
-declare class SecurityValidator {
-    private readonly config;
-    private readonly dangerousKeys;
-    constructor(config?: SecurityValidatorConfig);
-    /**
-     * Validate a key to prevent prototype pollution
-     *
-     * @param key - The key to validate
-     * @throws Error if the key is dangerous and validation is enabled
-     */
-    validateKey(key: string): void;
-    /**
-     * Validate and sanitize a value to prevent XSS and block functions
-     *
-     * @param value - The value to validate
-     * @returns The sanitized value (or original if not a string or validation disabled)
-     * @throws Error if value is a function and preventFunctions is enabled
-     */
-    validateValue<T>(value: T): T;
-    /**
-     * Sanitize a string value based on the configured mode
-     *
-     * @param value - The string to sanitize
-     * @returns The sanitized string
-     */
-    private sanitize;
-    /**
-     * Validate both key and value (convenience method)
-     *
-     * @param key - The key to validate
-     * @param value - The value to validate
-     * @returns The sanitized value
-     */
-    validateKeyValue<T>(key: string, value: T): T;
-    /**
-     * Check if a key is dangerous without throwing
-     *
-     * @param key - The key to check
-     * @returns true if the key is dangerous
-     */
-    isDangerousKey(key: string): boolean;
-    /**
-     * Get the current configuration
-     */
-    getConfig(): Readonly<Required<SecurityValidatorConfig>>;
-}
-/**
- * Create a SecurityValidator with common presets
- */
-declare const SecurityPresets: {
-    /**
-     * Strict security: All protections enabled (recommended for production)
-     */
-    strict: () => SecurityValidator;
-    /**
-     * Standard security: Prototype pollution and function blocking (default)
-     */
-    standard: () => SecurityValidator;
-    /**
-     * Permissive security: Only prototype pollution prevention
-     * WARNING: Allows functions, breaking serialization features
-     */
-    permissive: () => SecurityValidator;
-    /**
-     * Disabled: No security validations
-     * DANGER: Not recommended - allows prototype pollution and functions
-     */
-    disabled: () => SecurityValidator;
-};
-
-/**
- * SignalTree Core Types v2.0.2
- * MIT License - Copyright (c) 2025 Jonathan D Borgia
- */
-/**
- * Helper type preventing ambiguity when a node itself stores a function value.
- * In that case direct callable set(fn) would clash with the update(fn) signature.
- * We exclude raw function values from the direct-set overload so users must use .set(fn)
- * (after transform) instead of callable form, while updater form still works.
- */
-type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
-/**
- * Augment Angular's WritableSignal to support callable syntax for DX.
- * This is purely TypeScript-level - the transform converts these calls to .set/.update
- */
-declare module '@angular/core' {
-    interface WritableSignal<T> {
-        (value: NotFn<T>): void;
-        (updater: (current: T) => T): void;
-    }
-}
-/**
- * Primitive types for type checking
- */
-type Primitive = string | number | boolean | null | undefined | bigint | symbol;
-/**
- * Built-in object types that should be treated as primitive values
- * (Keep this list in sync with runtime isBuiltInObject)
- */
-type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | URL | URLSearchParams | FormData | Blob | File | Headers | Request | Response | AbortController | AbortSignal;
-/**
- * Node accessor interface - unified API for get/set/update via function calls.
- * Overloads:
- *  (): T                     - getter
- *  (value: NotFn<T>): void   - direct set (blocked when T is itself a function)
- *  (updater: (T)=>T): void   - functional update
- */
-interface NodeAccessor$1<T> {
-    (): T;
-    (value: T): void;
-    (updater: (current: T) => T): void;
-}
-/**
- * Signalified node with callable interface
- */
-type AccessibleNode<T> = NodeAccessor$1<T> & TreeNode$1<T>;
-/**
- * Deep signalification type - converts object properties to signals recursively
- * - Leaves (primitives, arrays, functions, built-ins): Raw Angular WritableSignal<T>
- * - Nested objects: NodeAccessor<T> (callable) + recursive TreeNode<T> properties
- */
-type CallableWritableSignal<T> = WritableSignal<T> & {
-    (value: NotFn<T>): void;
-    (updater: (current: T) => T): void;
-};
-type TreeNode$1<T> = {
-    [K in keyof T]: T[K] extends readonly unknown[] ? CallableWritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends BuiltInObject ? CallableWritableSignal<T[K]> : T[K] extends (...args: unknown[]) => unknown ? CallableWritableSignal<T[K]> : AccessibleNode<T[K]> : CallableWritableSignal<T[K]>;
-};
-/**
- * Utility type to remove signal-specific methods from a type
- * Used by cleanUnwrap to return the original type shape
- */
-type RemoveSignalMethods<T> = T extends infer U ? U : never;
-/** Enhancer metadata for optional auto-ordering */
-interface EnhancerMeta {
-    name?: string;
-    requires?: string[];
-    provides?: string[];
-}
-/** Enhancer function that may carry metadata */
-type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
-/** Enhancer with optional metadata attached */
-type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
-    metadata?: EnhancerMeta;
-};
-/** Symbol key for enhancer metadata */
-declare const ENHANCER_META: unique symbol;
-/** Infer the final result type after applying enhancers */
-type ChainResult<Start, E extends Array<EnhancerWithMeta<unknown, unknown>>> = E extends [infer H, ...infer R] ? H extends EnhancerWithMeta<SignalTree<unknown>, infer O> ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : H extends EnhancerWithMeta<infer I, infer O> ? Start extends I ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : unknown : unknown : Start;
-/**
- * Simplified overload set for .with() method
- * Reduced from 20+ complex overloads to basic patterns that TypeScript can infer.
- * For complex enhancer chains, use applyEnhancer() helper or type assertions.
- */
-interface WithMethod<T> {
-    (): SignalTree<T>;
-    <O>(enhancer: (input: SignalTree<T>) => O): O;
-    <O1, O2>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2): O2;
-    <O1, O2, O3>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2, e3: (input: O2) => O3): O3;
-    <O>(enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;
-    <O1, O2>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
-    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
-}
-/**
- * Main SignalTree type with all methods
- */
-type SignalTree<T> = NodeAccessor$1<T> & {
-    /** The reactive state object */
-    state: TreeNode$1<T>;
-    /** Shorthand alias for state */
-    $: TreeNode$1<T>;
-    /** Core methods */
-    with: WithMethod<T>;
-    destroy(): void;
-    /**
-     * Dispose of the signal tree and clean up memory resources.
-     * Only available when using lazy signals (useLazySignals: true).
-     *
-     * This method:
-     * - Clears the memory manager cache (releases WeakRef references)
-     * - Calls the cleanup function on the lazy proxy
-     * - Allows garbage collection of unused signals
-     *
-     * @example
-     * ```typescript
-     * const tree = signalTree({ users: largeUserList }, { useLazySignals: true });
-     * // ... use tree
-     * tree.dispose(); // Clean up when done
-     * ```
-     */
-    dispose?(): void;
-    /** Enhanced functionality */
-    effect(fn: (tree: T) => void): void;
-    subscribe(fn: (tree: T) => void): () => void;
-    batch(updater: (tree: T) => void): void;
-    batchUpdate(updater: (current: T) => Partial<T>): void;
-    memoize<R>(fn: (tree: T) => R, cacheKey?: string): Signal<R>;
-    memoizedUpdate(updater: (current: T) => Partial<T>, cacheKey?: string): void;
-    clearMemoCache(key?: string): void;
-    getCacheStats(): {
-        size: number;
-        hitRate: number;
-        totalHits: number;
-        totalMisses: number;
-        keys: string[];
-    };
-    /** Performance methods */
-    optimize(): void;
-    clearCache(): void;
-    invalidatePattern(pattern: string): number;
-    /**
-     * Optimized update using diff-based patching and batching.
-     * Only updates signals that actually changed, providing significant
-     * performance improvements for large trees and partial updates.
-     *
-     * @param updates - Partial updates to apply
-     * @param options - Update options (batching, equality, etc.)
-     * @returns Update result with performance metrics
-     *
-     * @example
-     * ```typescript
-     * const tree = signalTree({ users: largeUserList });
-     *
-     * // Only updates what changed
-     * const result = tree.updateOptimized({
-     *   users: { 0: { name: 'Updated' } }
-     * });
-     *
-     * console.log(result.changedPaths); // ['users.0.name']
-     * console.log(result.duration); // ~2ms
-     * ```
-     */
-    updateOptimized?(updates: Partial<T>, options?: {
-        batch?: boolean;
-        batchSize?: number;
-        maxDepth?: number;
-        ignoreArrayOrder?: boolean;
-        equalityFn?: (a: unknown, b: unknown) => boolean;
-    }): {
-        changed: boolean;
-        duration: number;
-        changedPaths: string[];
-        stats?: {
-            totalPaths: number;
-            optimizedPaths: number;
-            batchedUpdates: number;
-        };
-    };
-    getMetrics(): PerformanceMetrics;
-    /** Middleware */
-    addTap(middleware: Middleware<T>): void;
-    removeTap(id: string): void;
-    /** Entity helpers */
-    entities<E extends {
-        id: string | number;
-    }>(entityKey?: keyof T): EntityHelpers<E>;
-    /** Async actions */
-    asyncAction<TInput, TResult>(operation: (input: TInput) => Promise<TResult>, config?: AsyncActionConfig<T, TResult>): AsyncAction<TInput, TResult>;
-    /** Time travel */
-    undo(): void;
-    redo(): void;
-    getHistory(): TimeTravelEntry$1<T>[];
-    resetHistory(): void;
-    jumpTo?: (index: number) => void;
-    canUndo?: () => boolean;
-    canRedo?: () => boolean;
-    getCurrentIndex?: () => number;
-    /** Index signature for enhancer compatibility */
-    [key: string]: unknown;
-};
-type TreePreset$1 = 'basic' | 'performance' | 'development' | 'production';
-interface TreeConfig {
-    batchUpdates?: boolean;
-    useMemoization?: boolean;
-    enableTimeTravel?: boolean;
-    useLazySignals?: boolean;
-    useShallowComparison?: boolean;
-    maxCacheSize?: number;
-    trackPerformance?: boolean;
-    treeName?: string;
-    enableDevTools?: boolean;
-    debugMode?: boolean;
-    useStructuralSharing?: boolean;
-    /**
-     * Security validation configuration
-     * When enabled, validates keys and values during tree construction and updates
-     * to prevent prototype pollution, XSS, and function values.
-     *
-     * @default undefined (no security validation)
-     * @see SecurityValidator for configuration options
-     *
-     * @example
-     * ```ts
-     * // Enable all security features
-     * const tree = signalTree(state, {
-     *   security: {
-     *     preventPrototypePollution: true,
-     *     preventXSS: true,
-     *     preventFunctions: true,
-     *     onSecurityEvent: (event) => console.warn('Security event:', event)
-     *   }
-     * });
-     *
-     * // Or use a preset
-     * import { SecurityPresets } from '@signaltree/core';
-     * const tree = signalTree(state, {
-     *   security: SecurityPresets.strict().getConfig()
-     * });
-     * ```
-     */
-    security?: SecurityValidatorConfig;
-}
-interface Middleware<T> {
-    id: string;
-    before?: (action: string, payload: unknown, state: T) => boolean;
-    after?: (action: string, payload: unknown, state: T, newState: T) => void;
-}
-interface PerformanceMetrics {
-    updates: number;
-    computations: number;
-    cacheHits: number;
-    cacheMisses: number;
-    averageUpdateTime: number;
-}
-interface EntityHelpers<E extends {
-    id: string | number;
-}> {
-    add(entity: E): void;
-    update(id: E['id'], updates: Partial<E>): void;
-    remove(id: E['id']): void;
-    upsert(entity: E): void;
-    selectById(id: E['id']): Signal<E | undefined>;
-    selectBy(predicate: (entity: E) => boolean): Signal<E[]>;
-    selectIds(): Signal<Array<string | number>>;
-    selectAll(): Signal<E[]>;
-    selectTotal(): Signal<number>;
-    clear(): void;
-}
-interface AsyncActionConfig<T, TResult> {
-    onStart?: (state: T) => Partial<T>;
-    onSuccess?: (result: TResult, state: T) => Partial<T>;
-    onError?: (error: Error, state: T) => Partial<T>;
-    onComplete?: (state: T) => Partial<T>;
-}
-interface AsyncAction<TInput, TResult> {
-    execute(input: TInput): Promise<TResult>;
-    pending: Signal<boolean>;
-    error: Signal<Error | null>;
-    result: Signal<TResult | null>;
-}
-interface TimeTravelEntry$1<T> {
-    action: string;
-    timestamp: number;
-    state: T;
-    payload?: unknown;
-}
-
-declare function signalTree<T>(obj: T): SignalTree<T>;
-declare function signalTree<T>(obj: T, preset: TreePreset$1): SignalTree<T>;
-declare function signalTree<T>(obj: T, config: TreeConfig): SignalTree<T>;
-declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>, configOrPreset?: TreeConfig | TreePreset$1): SignalTree<Required<T>>;
-declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset$1): SignalTree<T>;
-
-/**
- * Generic memory manager interface for lazy signal trees
- */
-interface MemoryManager {
-    getSignal(path: string): WritableSignal<unknown> | undefined;
-    cacheSignal(path: string, signal: WritableSignal<unknown>): void;
-    dispose(): void;
-}
-/**
- * Minimal type definitions for utils package
- * (Full definitions are in @signaltree/types)
- */
-interface NodeAccessor<T> {
-    (): T;
-    (value: T): void;
-    (updater: (current: T) => T): void;
-}
-type TreeNode<T> = {
-    [K in keyof T]: T[K] extends readonly unknown[] ? WritableSignal<T[K]> : T[K] extends object ? T[K] extends Signal<unknown> ? T[K] : T[K] extends (...args: unknown[]) => unknown ? WritableSignal<T[K]> : NodeAccessor<T[K]> : WritableSignal<T[K]>;
-};
-/**
- * Checks if a value is a node accessor created by makeNodeAccessor
- */
-declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
-/**
- * Checks if a value is either an Angular signal or a callable signal
- * This is useful for packages that need to work with both types
- */
-declare function isAnySignal(value: unknown): boolean;
-declare function composeEnhancers<T>(...enhancers: Array<(tree: T) => T>): (tree: T) => T;
-/**
- * Creates a lazy signal tree using Proxy for on-demand signal creation
- */
-declare function createLazySignalTree<T extends object>(obj: T, equalityFn: (a: unknown, b: unknown) => boolean, basePath?: string, memoryManager?: MemoryManager): TreeNode<T>;
-
-/**
- * SignalTree Enhancer System
- * Handles enhancer composition and dependency resolution
- */
-
-/**
- * Helper to create an enhancer with metadata attached
- *
- * @param meta - Metadata describing the enhancer
- * @param enhancerFn - The enhancer function
- * @returns Enhancer function with metadata attached
- *
- * @example
- * ```typescript
- * const myEnhancer = createEnhancer(
- *   {
- *     name: 'myEnhancer',
- *     provides: ['feature1'],
- *     requires: ['feature2']
- *   },
- *   (tree) => {
- *     // Enhance the tree
- *     return { ...tree, feature1: true };
- *   }
- * );
- * ```
- */
-declare function createEnhancer<I = unknown, O = unknown>(meta: EnhancerMeta, enhancerFn: (input: I) => O): EnhancerWithMeta<I, O>;
-/**
- * Resolve enhancer order using topological sort based on dependencies
- *
- * @param enhancers - Array of enhancers to order
- * @param availableCapabilities - Set of already available capabilities
- * @param debugMode - Whether to log debug information
- * @returns Ordered array of enhancers
- */
-declare function resolveEnhancerOrder(enhancers: EnhancerWithMeta<unknown, unknown>[], availableCapabilities?: Set<string>, debugMode?: boolean): EnhancerWithMeta<unknown, unknown>[];
-
-/**
- * Configuration options for intelligent batching behavior.
- * Controls how updates are grouped and processed for optimal performance.
- * Uses unconstrained recursive typing - no limitations on T
- *
- * @example
- * ```typescript
- * const config: BatchingConfig = {
- *   enabled: true,
- *   maxBatchSize: 50,
- *   autoFlushDelay: 16, // 60fps
- *   batchTimeoutMs: 100
- * };
- * ```
- */
-interface BatchingConfig {
-    /** Whether batching is enabled (default: true) */
-    enabled?: boolean;
-    /** Maximum number of updates per batch (default: 100) */
-    maxBatchSize?: number;
-    /** Delay before auto-flushing batch in milliseconds (default: 16) */
-    autoFlushDelay?: number;
-    /** Maximum time to wait before forcing batch flush (default: 100) */
-    batchTimeoutMs?: number;
-}
-/**
- * Enhanced SignalTree interface with intelligent batching capabilities.
- * Provides high-performance batch update methods that group multiple state changes.
- *
- * @template T - The state object type extending StateObject
- *
- * @example
- * ```typescript
- * interface AppState {
- *   users: User[];
- *   ui: { loading: boolean; error: string | null };
- *   stats: { total: number; active: number };
- * }
- *
- * const tree: BatchingSignalTree<AppState> = create(initialState)
- *   .with(withBatching());
- *
- * // Batch multiple related updates
- * tree.batchUpdate((state) => ({
- *   users: [...state.users, newUser],
- *   ui: { ...state.ui, loading: false },
- *   stats: {
- *     total: state.users.length + 1,
- *     active: state.users.filter(u => u.active).length + (newUser.active ? 1 : 0)
- *   }
- * }));
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-interface BatchingSignalTree<T> extends SignalTree<T> {
-    /**
-     * Batches multiple state updates into a single change cycle for optimal performance.
-     * Groups related updates to prevent UI thrashing and improve rendering efficiency.
-     *
-     * @param updater - Function that receives current state and returns partial update
-     *
-     * @example
-     * ```typescript
-     * // Instead of multiple individual updates
-     * tree.update(() => ({ loading: true }));
-     * tree.update(() => ({ error: null }));
-     * tree.update(() => ({ users: [] }));
-     *
-     * // Use a single batched update
-     * tree.batchUpdate((state) => ({
-     *   loading: true,
-     *   error: null,
-     *   users: []
-     * }));
-     * ```
-     */
-    batchUpdate(updater: (current: T) => Partial<T>): void;
-}
-/**
- * Enhances a SignalTree with intelligent batching capabilities for optimal performance.
- * Automatically groups rapid state updates into efficient batch cycles to eliminate UI thrashing.
- *
- * @template T - The state object type extending StateObject
- * @param config - Configuration options for batching behavior
- * @returns Function that enhances a SignalTree with batching capabilities
- *
- * @example
- * ```typescript
- * // Basic batching with default settings
- * const tree = create(initialState).with(withBatching());
- *
- * // High-performance batching for demanding applications
- * const tree = create(initialState).with(withBatching({
- *   maxBatchSize: 50,
- *   autoFlushDelay: 8, // ~120fps
- *   batchTimeoutMs: 50
- * }));
- *
- * // Conservative batching for stable UIs
- * const tree = create(initialState).with(withBatching({
- *   maxBatchSize: 10,
- *   autoFlushDelay: 100,
- *   batchTimeoutMs: 200
- * }));
- *
- * // Use batching methods
- * tree.batchUpdate((state) => ({
- *   users: [...state.users, newUser],
- *   loading: false,
- *   error: null
- * }));
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-declare function withBatching<T>(config?: BatchingConfig): (tree: SignalTree<T>) => BatchingSignalTree<T>;
-/**
- * Convenience function to enable batching with default settings.
- * Equivalent to withBatching({ enabled: true }) but more concise for common usage.
- *
- * @template T - The state object type extending StateObject
- * @returns Function that enhances a SignalTree with default batching settings
- *
- * @example
- * ```typescript
- * // Simple batching enablement
- * const tree = create(initialState).with(enableBatching());
- *
- * // Equivalent to:
- * const tree = create(initialState).with(withBatching({ enabled: true }));
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-/**
- * Creates high-performance batching configuration optimized for demanding applications.
- * Uses aggressive batching settings for maximum performance in high-frequency update scenarios.
- * Uses unconstrained recursive typing - no limitations on T
- *
- * @template T - The state object type extending StateObject
- * @returns Function that enhances a SignalTree with high-performance batching
- *
- * @example
- * ```typescript
- * // For performance-critical applications
- * const gameTree = create(gameState).with(withHighPerformanceBatching());
- *
- * // Perfect for:
- * // - Real-time games
- * // - High-frequency data updates
- * // - Animation-heavy UIs
- * // - Large dataset operations
- *
- * // Automatically includes:
- * // - Large batch sizes (200 updates)
- * // - Immediate processing (0ms timeout)
- * // - Aggressive optimization
- * Uses unconstrained recursive typing - no limitations on T
- * ```
- */
-declare function withHighPerformanceBatching<T>(): (tree: SignalTree<T>) => BatchingSignalTree<T>;
-/**
- * Manually flushes all pending batched updates immediately.
- * Forces synchronous execution of queued updates, bypassing normal batching delays.
- * Useful for testing scenarios or when immediate state consistency is required.
- *
- * @example
- * ```typescript
- * // Queue some updates
- * tree.batchUpdate(() => ({ count: 1 }));
- * tree.batchUpdate(() => ({ name: 'test' }));
- *
- * // In tests, ensure updates are applied immediately
- * flushBatchedUpdates();
- * expect(tree().count).toBe(1);
- * expect(tree().name).toBe('test');
- *
- * // Before critical operations that need current state
- * flushBatchedUpdates();
- * const currentState = tree(); // Guaranteed to be up-to-date
- *
- * // In animation frames for precise timing
- * requestAnimationFrame(() => {
- *   flushBatchedUpdates(); // Ensure updates are applied before render
- *   updateUI();
- * });
- * ```
- */
-declare function flushBatchedUpdates(): void;
-/**
- * Checks if there are pending batched updates waiting to be processed.
- * Useful for testing, debugging, or conditional logic based on update queue state.
- *
- * @returns True if updates are queued, false if queue is empty
- *
- * @example
- * ```typescript
- * // Check before critical operations
- * tree.batchUpdate(() => ({ loading: true }));
- *
- * if (hasPendingUpdates()) {
- *   console.log('Updates are queued for processing');
- *   flushBatchedUpdates(); // Process them now if needed
- * }
- *
- * // In testing
- * tree.batchUpdate(() => ({ count: 1 }));
- * expect(hasPendingUpdates()).toBe(true);
- *
- * flushBatchedUpdates();
- * expect(hasPendingUpdates()).toBe(false);
- *
- * // Conditional behavior
- * function performCriticalOperation() {
- *   if (hasPendingUpdates()) {
- *     flushBatchedUpdates(); // Ensure consistent state
- *   }
- *   // Proceed with operation
- * }
- * ```
- */
-declare function hasPendingUpdates(): boolean;
-/**
- * Gets the current number of updates waiting in the batch queue.
- * Useful for performance monitoring, debugging, and batch size optimization.
- *
- * @returns Number of queued updates
- *
- * @example
- * ```typescript
- * // Performance monitoring
- * function monitorBatchPerformance() {
- *   const queueSize = getBatchQueueSize();
- *
- *   if (queueSize > 50) {
- *     console.warn(`Large batch queue detected: ${queueSize} updates`);
- *   }
- *
- *   // Log metrics
- *   console.log(`Current queue size: ${queueSize}`);
- * }
- *
- * // Debug batching behavior
- * tree.batchUpdate(() => ({ a: 1 }));
- * tree.batchUpdate(() => ({ b: 2 }));
- * tree.batchUpdate(() => ({ c: 3 }));
- *
- * console.log(`Queue size: ${getBatchQueueSize()}`); // 3
- *
- * flushBatchedUpdates();
- * console.log(`Queue size after flush: ${getBatchQueueSize()}`); // 0
- *
- * // Optimize batch configuration
- * const currentQueueSize = getBatchQueueSize();
- * if (currentQueueSize > 100) {
- *   // Consider reducing maxBatchSize or autoFlushDelay
- *   console.log('Consider optimizing batch configuration');
- * }
- * ```
- */
-declare function getBatchQueueSize(): number;
-
-/**
- * Extended SignalTree interface with memoization capabilities
- * Uses the same unconstrained recursive typing approach as core
- */
-interface MemoizedSignalTree<T> extends SignalTree<T> {
-    memoizedUpdate: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
-    clearMemoCache: (key?: string) => void;
-    getCacheStats: () => {
-        size: number;
-        hitRate: number;
-        totalHits: number;
-        totalMisses: number;
-        keys: string[];
-    };
-}
-/**
- * Cleanup the cache interval on app shutdown
- */
-declare function cleanupMemoizationCache(): void;
-/**
- * Memoization configuration options
- */
-interface MemoizationConfig {
-    enabled?: boolean;
-    maxCacheSize?: number;
-    ttl?: number;
-    equality?: 'deep' | 'shallow' | 'reference';
-    enableLRU?: boolean;
-}
-/**
- * Memoization function that caches expensive computations with enhanced cache management
- */
-declare function memoize<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string, config?: MemoizationConfig): (...args: TArgs) => TReturn;
-/**
- * High-performance memoization function optimized for speed
- * Uses shallow equality and minimal cache management overhead
- */
-declare function memoizeShallow<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-/**
- * Lightweight memoization function with reference equality only
- * Maximum performance for scenarios where exact reference matches are sufficient
- */
-declare function memoizeReference<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
-/**
- * Convenience function: Memoization optimized for selectors
- * Uses reference equality and small cache for maximum performance
- *
- * @example
- * ```typescript
- * const tree = signalTree(state).with(withSelectorMemoization());
- * const activeUsers = computed(() =>
- *   tree.state.users().filter(u => u.active)
- * );
- * ```
- */
-declare function withSelectorMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Convenience function: Memoization optimized for computed values
- * Uses shallow equality for balanced performance
- *
- * @example
- * ```typescript
- * const tree = signalTree(state).with(withComputedMemoization());
- * const metrics = computed(() =>
- *   calculateExpensiveMetrics(tree.state.data())
- * );
- * ```
- */
-declare function withComputedMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Convenience function: Memoization for complex nested state
- * Uses deep equality and LRU management
- *
- * @example
- * ```typescript
- * const tree = signalTree(state).with(withDeepStateMemoization());
- * // Handles complex nested object comparisons
- * ```
- */
-declare function withDeepStateMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Convenience function: Minimal memoization for hot paths
- * Maximum performance with minimal overhead
- *
- * @example
- * ```typescript
- * const tree = signalTree(state).with(withHighFrequencyMemoization());
- * // For operations called thousands of times per second
- * ```
- */
-declare function withHighFrequencyMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Enhances a SignalTree with memoization capabilities
- * Uses unconstrained recursive typing - no limitations on T
- */
-declare function withMemoization<T>(config?: MemoizationConfig): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * High-performance memoization with aggressive caching
- * Uses unconstrained recursive typing - no limitations on T
- */
-declare function withHighPerformanceMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Lightweight memoization optimized for performance-critical scenarios
- * Disables expensive cache management features for maximum speed
- */
-declare function withLightweightMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Shallow equality memoization for objects with primitive values
- * Good balance between performance and correctness
- */
-declare function withShallowMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
-/**
- * Clear all memoization caches
- */
-declare function clearAllCaches(): void;
-/**
- * Get global cache statistics
- */
-declare function getGlobalCacheStats(): {
-    treeCount: number;
-    totalSize: number;
-    totalHits: number;
-    averageCacheSize: number;
-};
-
-/**
- * Entry in the time travel history
- */
-interface TimeTravelEntry<T> {
-    state: T;
-    timestamp: number;
-    action: string;
-    payload?: unknown;
-}
-/**
- * Time travel interface for state history management
- */
-interface TimeTravelInterface<T> {
-    /**
-     * Navigate backward in history by one step
-     */
-    undo(): boolean;
-    /**
-     * Navigate forward in history by one step
-     */
-    redo(): boolean;
-    /**
-     * Get the complete history of state changes
-     */
-    getHistory(): TimeTravelEntry<T>[];
-    /**
-     * Reset the history, keeping only the current state
-     */
-    resetHistory(): void;
-    /**
-     * Jump to a specific point in history by index
-     */
-    jumpTo(index: number): boolean;
-    /**
-     * Get current position in history
-     */
-    getCurrentIndex(): number;
-    /**
-     * Check if undo is possible
-     */
-    canUndo(): boolean;
-    /**
-     * Check if redo is possible
-     */
-    canRedo(): boolean;
-}
-/**
- * Configuration options for time travel
- */
-interface TimeTravelConfig {
-    /**
-     * Maximum number of history entries to keep
-     * @default 50
-     */
-    maxHistorySize?: number;
-    /**
-     * Whether to include payload information in history entries
-     * @default true
-     */
-    includePayload?: boolean;
-    /**
-     * Custom action names for different operations
-     */
-    actionNames?: {
-        update?: string;
-        set?: string;
-        batch?: string;
-        [key: string]: string | undefined;
-    };
-}
-/**
- * Enhances a SignalTree with comprehensive time travel capabilities.
- *
- * Adds undo/redo functionality, state history management, and snapshot features.
- * Automatically tracks state changes and provides methods to navigate through
- * the application's state history with configurable limits and optimizations.
- *
- * @template T - The state object type
- * @param config - Configuration options for time travel behavior
- * @returns Function that enhances a SignalTree with time travel capabilities
- *
- * @example
- * ```typescript
- * // Basic time travel enhancement
- * const store = signalTree({ count: 0, text: '' }).with(withTimeTravel());
- *
- * // Make some changes
- * store.count.set(1);
- * store.text.set('hello');
- * store.count.set(2);
- *
- * // Access time travel interface
- * const timeTravel = store.__timeTravel;
- *
- * // Navigate history
- * console.log(timeTravel.canUndo()); // true
- * timeTravel.undo(); // count: 1, text: 'hello'
- * timeTravel.undo(); // count: 1, text: ''
- * timeTravel.undo(); // count: 0, text: ''
- *
- * timeTravel.redo(); // count: 1, text: ''
- * console.log(timeTravel.canRedo()); // true
- * ```
- *
- * @example
- * ```typescript
- * // Advanced configuration
- * const store = signalTree({
- *   document: { title: '', content: '' },
- *   settings: { theme: 'light' }
- * }).with(withTimeTravel({
- *   maxHistorySize: 50,        // Limit memory usage
- *   includePayload: true,      // Store action metadata
- *   actionNames: {             // Custom action names
- *     'update_title': 'Update Document Title',
- *     'change_theme': 'Change Theme'
- *   }
- * }));
- *
- * // Named actions with metadata
- * store.update(() => ({ document: { title: 'New Title' } }), 'update_title');
- *
- * // View detailed history
- * const history = store.__timeTravel.getHistory();
- * console.log(history[0].action); // 'Update Document Title'
- * console.log(history[0].timestamp); // Date when change occurred
- * ```
- */
-declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-/**
- * Convenience function to enable basic time travel
- */
-declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-/**
- * Get time travel interface from an enhanced tree
- */
-declare function getTimeTravel<T>(tree: SignalTree<T> & {
-    __timeTravel?: TimeTravelInterface<T>;
-}): TimeTravelInterface<T> | undefined;
-
-/**
- * Entity configuration options
- */
-interface EntityConfig {
-    enabled?: boolean;
-    trackChanges?: boolean;
-    validateIds?: boolean;
-}
-/**
- * Enhances a SignalTree with entity management capabilities
- * Works with SignalTree's TreeNode type structure
- *
- * The key insight: The state is already deeply signalified, so array properties
- * like `users: User[]` become `users: WritableSignal<User[]>` in tree.state
- */
-declare function withEntities(config?: EntityConfig): <T>(tree: SignalTree<T>) => SignalTree<T> & {
-    entities<E extends {
-        id: string | number;
-    }>(entityKey: keyof T): EntityHelpers<E>;
-};
-/**
- * Convenience function to enable entities with default config
- */
-declare function enableEntities(): <T>(tree: SignalTree<T>) => SignalTree<T> & {
-    entities<E extends {
-        id: string | number;
-    }>(entityKey: keyof T): EntityHelpers<E>;
-};
-/**
- * High-performance entity management configuration
- */
-declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => SignalTree<T> & {
-    entities<E extends {
-        id: string | number;
-    }>(entityKey: keyof T): EntityHelpers<E>;
-};
-
-/**
- * Serialization configuration options
- */
-interface SerializationConfig {
-    /**
-     * Whether to include metadata (timestamps, version, etc.)
-     * @default true
-     */
-    includeMetadata?: boolean;
-    /**
-     * Custom replacer function for JSON.stringify
-     */
-    replacer?: (key: string, value: unknown) => unknown;
-    /**
-     * Custom reviver function for JSON.parse
-     */
-    reviver?: (key: string, value: unknown) => unknown;
-    /**
-     * Whether to preserve special types (Date, RegExp, etc.)
-     * @default true
-     */
-    preserveTypes?: boolean;
-    /**
-     * Maximum depth to serialize (prevents infinite recursion)
-     * @default 50
-     */
-    maxDepth?: number;
-    /**
-     * Whether to handle circular references
-     * @default true
-     */
-    handleCircular?: boolean;
-}
-/**
- * Serialized state wrapper with metadata
- */
-interface SerializedState<T = unknown> {
-    /**
-     * The actual serialized state data
-     */
-    data: T;
-    /**
-     * Metadata about the serialization
-     */
-    metadata?: {
-        /**
-         * Timestamp when serialized
-         */
-        timestamp: number;
-        /**
-         * Version of the serialization format
-         */
-        version: string;
-        /**
-         * Custom application version
-         */
-        appVersion?: string;
-        /**
-         * Type information for special objects
-         */
-        types?: Record<string, string>;
-        /**
-         * Circular reference paths
-         */
-        circularRefs?: Array<{
-            path: string;
-            targetPath: string;
-        }>;
-        /**
-         * Optional map of paths that indicate where the target tree contains
-         * branch nodes (objects with set/update) or root-as-signal markers.
-         * Keys are paths (dot/array notation), values: 'b' = branch, 'r' = root
-         */
-        nodeMap?: Record<string, 'b' | 'r'>;
-    };
-}
-/**
- * Enhanced SignalTree interface with serialization capabilities
- */
-interface SerializableSignalTree<T> extends SignalTree<T> {
-    /** Explicit reactive alias for state (helps TS resolution in tests) */
-    $: any;
-    /**
-     * Serialize the current state to a JSON string
-     */
-    serialize(config?: SerializationConfig): string;
-    /**
-     * Deserialize and apply state from a JSON string
-     */
-    deserialize(json: string, config?: SerializationConfig): void;
-    /**
-     * Get a plain object representation of the current state
-     */
-    toJSON(): T;
-    /**
-     * Restore state from a plain object
-     */
-    fromJSON(data: T, metadata?: SerializedState<T>['metadata']): void;
-    /**
-     * Create a snapshot of the current state
-     */
-    snapshot(): SerializedState<T>;
-    /**
-     * Restore state from a snapshot
-     */
-    restore(snapshot: SerializedState<T>): void;
-}
-/**
- * Methods added by the persistence enhancer
- */
-interface PersistenceMethods {
-    save(): Promise<void>;
-    load(): Promise<void>;
-    clear(): Promise<void>;
-    __flushAutoSave?: () => Promise<void>;
-}
-/**
- * Enhances a SignalTree with serialization capabilities
- */
-declare function withSerialization<T extends Record<string, unknown> = Record<string, unknown>>(defaultConfig?: SerializationConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
-/**
- * Convenience function to enable serialization with defaults
- */
-declare function enableSerialization<T extends Record<string, unknown> = Record<string, unknown>>(): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
-/**
- * Storage adapter interface for persistence
- */
-interface StorageAdapter {
-    getItem(key: string): string | null | Promise<string | null>;
-    setItem(key: string, value: string): void | Promise<void>;
-    removeItem(key: string): void | Promise<void>;
-}
-/**
- * Persistence configuration
- */
-interface PersistenceConfig extends SerializationConfig {
-    /**
-     * Storage key to use
-     */
-    key: string;
-    /**
-     * Storage adapter (defaults to localStorage)
-     */
-    storage?: StorageAdapter;
-    /**
-     * Whether to auto-save on every update
-     * @default true
-     */
-    autoSave?: boolean;
-    /**
-     * Debounce delay for auto-save in ms
-     * @default 1000
-     */
-    debounceMs?: number;
-    /**
-     * Whether to auto-load on creation
-     * @default true
-     */
-    autoLoad?: boolean;
-    /**
-     * Whether to skip caching and force storage writes even if unchanged
-     * @default false
-     */
-    skipCache?: boolean;
-}
-/**
- * Adds persistence capabilities to a SerializableSignalTree
- */
-declare function withPersistence<T extends Record<string, unknown> = Record<string, unknown>>(config: PersistenceConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T> & PersistenceMethods>;
-/**
- * Create a custom storage adapter
- */
-declare function createStorageAdapter(getItem: (key: string) => string | null | Promise<string | null>, setItem: (key: string, value: string) => void | Promise<void>, removeItem: (key: string) => void | Promise<void>): StorageAdapter;
-/**
- * IndexedDB storage adapter for large state trees
- */
-declare function createIndexedDBAdapter(dbName?: string, storeName?: string): StorageAdapter;
-/**
- * Helpers to apply enhancers with explicit typing to avoid depending on
- * complex `.with()` overload inference in tests and tooling.
- */
-declare function applySerialization<T extends Record<string, unknown>>(tree: SignalTree<T>): SerializableSignalTree<T>;
-declare function applyPersistence<T extends Record<string, unknown>>(tree: SignalTree<T>, cfg: PersistenceConfig): SerializableSignalTree<T> & PersistenceMethods;
-
-type TreePreset = 'basic' | 'performance' | 'development' | 'production';
-/**
- * Pre-configured SignalTree configurations for common use cases.
- *
- * - **basic**: Minimal configuration with no advanced features
- * - **performance**: Optimized for speed with batching and memoization
- * - **development**: Full debugging features including time-travel and devtools
- * - **production**: Optimized for production with performance features only
- */
-declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
-/**
- * Helper function to create a tree configuration from a preset.
- * Can be used to start with a preset and then customize specific options.
- *
- * @param preset - The preset name to use as a base
- * @param overrides - Optional overrides to apply on top of the preset
- * @returns Complete tree configuration
- *
- * @example
- * ```typescript
- * // Use development preset with custom tree name
- * const config = createPresetConfig('development', { treeName: 'MyApp' });
- *
- * // Use performance preset but enable debug mode
- * const debugPerf = createPresetConfig('performance', { debugMode: true });
- * ```
- */
-declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
-/**
- * Validates that a preset configuration is valid.
- * Useful for development-time checks.
- *
- * @param preset - The preset to validate
- * @returns True if valid, throws error if invalid
- */
-declare function validatePreset(preset: TreePreset): boolean;
-/**
- * Gets the list of available preset names.
- *
- * @returns Array of preset names
- */
-declare function getAvailablePresets(): TreePreset[];
-/**
- * Creates a custom preset by combining multiple existing presets.
- * Later presets in the array take precedence over earlier ones.
- *
- * @param presets - Array of presets to combine
- * @param overrides - Optional final overrides
- * @returns Combined configuration
- *
- * @example
- * ```typescript
- * // Combine basic preset with some performance features
- * const config = combinePresets(['basic', 'performance'], { enableDevTools: true });
- * ```
- */
-declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
-/**
- * Convenience helper for creating a development-ready SignalTree.
- * Composes dev-only enhancers (devtools, time-travel, async) into a single
- * enhancer function that can be applied to a tree. This keeps packages
- * independent while offering a one-line dev onboarding.
- */
-declare function createDevTree(overrides?: Partial<TreeConfig>): {
-    readonly config: TreeConfig;
-    readonly enhancer: (tree: unknown) => unknown;
-};
-
-/**
- * SignalTree Constants
- * Centralized configuration values and messages
- */
-declare const SIGNAL_TREE_CONSTANTS: {
-    /** Cache configuration */
-    readonly MAX_PATH_CACHE_SIZE: any;
-    /** Performance thresholds */
-    readonly LAZY_THRESHOLD: 50;
-    readonly ESTIMATE_MAX_DEPTH: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_ARRAY: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_OBJECT: 5;
-    /** Default values */
-    readonly DEFAULT_CACHE_SIZE: 100;
-    readonly DEFAULT_BATCH_SIZE: 10;
-};
-declare const SIGNAL_TREE_MESSAGES: Readonly<{
-    readonly NULL_OR_UNDEFINED: "null/undefined";
-    readonly CIRCULAR_REF: "circular ref";
-    readonly UPDATER_INVALID: "updater invalid";
-    readonly LAZY_FALLBACK: "lazy fallback";
-    readonly SIGNAL_CREATION_FAILED: "signal creation failed";
-    readonly UPDATE_PATH_NOT_FOUND: "update path not found";
-    readonly UPDATE_FAILED: "update failed";
-    readonly ROLLBACK_FAILED: "rollback failed";
-    readonly CLEANUP_ERROR: "cleanup error";
-    readonly PRESET_UNKNOWN: "unknown preset";
-    readonly STRATEGY_SELECTION: "strategy select";
-    readonly TREE_DESTROYED: "destroyed";
-    readonly UPDATE_TRANSACTION: "update tx";
-    readonly BATCH_NOT_ENABLED: "batching disabled";
-    readonly MEMOIZE_NOT_ENABLED: "memoize disabled";
-    readonly MIDDLEWARE_NOT_AVAILABLE: "middleware missing";
-    readonly ENTITY_HELPERS_NOT_AVAILABLE: "entity helpers missing";
-    readonly ASYNC_ACTIONS_NOT_AVAILABLE: "async actions missing";
-    readonly TIME_TRAVEL_NOT_AVAILABLE: "time travel missing";
-    readonly OPTIMIZE_NOT_AVAILABLE: "optimize missing";
-    readonly UPDATE_OPTIMIZED_NOT_AVAILABLE: "update optimized missing";
-    readonly CACHE_NOT_AVAILABLE: "cache missing";
-    readonly PERFORMANCE_NOT_ENABLED: "performance disabled";
-    readonly ENHANCER_ORDER_FAILED: "enhancer order failed";
-    readonly ENHANCER_CYCLE_DETECTED: "enhancer cycle";
-    readonly ENHANCER_REQUIREMENT_MISSING: "enhancer req missing";
-    readonly ENHANCER_PROVIDES_MISSING: "enhancer provides missing";
-    readonly ENHANCER_FAILED: "enhancer failed";
-    readonly ENHANCER_NOT_FUNCTION: "enhancer not function";
-    readonly EFFECT_NO_CONTEXT: "no angular context";
-    readonly SUBSCRIBE_NO_CONTEXT: "no angular context";
-}>;
-
-export { ENHANCER_META, SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, SecurityPresets, SecurityValidator, TREE_PRESETS, applyPersistence, applySerialization, cleanupMemoizationCache, clearAllCaches, combinePresets, composeEnhancers, createDevTree, createEnhancer, createIndexedDBAdapter, createLazySignalTree, createPresetConfig, createStorageAdapter, enableEntities, enableSerialization, enableTimeTravel, flushBatchedUpdates, getAvailablePresets, getBatchQueueSize, getGlobalCacheStats, getTimeTravel, hasPendingUpdates, isAnySignal, isNodeAccessor, memoize, memoizeReference, memoizeShallow, resolveEnhancerOrder, signalTree, validatePreset, withBatching, withComputedMemoization, withDeepStateMemoization, withEntities, withHighFrequencyMemoization, withHighPerformanceBatching, withHighPerformanceEntities, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withPersistence, withSelectorMemoization, withSerialization, withShallowMemoization, withTimeTravel };
-export type { AsyncAction, AsyncActionConfig, BuiltInObject, ChainResult, Enhancer, EnhancerMeta, EnhancerWithMeta, EntityHelpers, Middleware, NotFn, PerformanceMetrics, Primitive, RemoveSignalMethods, SecurityEvent, SecurityEventType, SecurityValidatorConfig, SignalTree, TimeTravelEntry$1 as TimeTravelEntry, TimeTravelInterface, TreeConfig, TreeNode$1 as TreeNode, TreePreset$1 as TreePreset, WithMethod };