@signaltree/core 5.1.0 → 5.1.1

package/src/enhancers/serialization/test-setup.d.ts

@@ -1,3 +0,0 @@
-import '@angular/compiler';
-import 'zone.js';
-import 'zone.js/testing';

package/src/enhancers/time-travel/index.d.ts

@@ -1 +0,0 @@
-export * from './lib/time-travel';

package/src/enhancers/time-travel/lib/time-travel.d.ts

@@ -1,36 +0,0 @@
-import type { SignalTree } from '../../../lib/types';
-export interface TimeTravelEntry<T> {
-    state: T;
-    timestamp: number;
-    action: string;
-    payload?: unknown;
-}
-export interface TimeTravelInterface<T> {
-    undo(): boolean;
-    redo(): boolean;
-    getHistory(): TimeTravelEntry<T>[];
-    resetHistory(): void;
-    jumpTo(index: number): boolean;
-    getCurrentIndex(): number;
-    canUndo(): boolean;
-    canRedo(): boolean;
-}
-export interface TimeTravelConfig {
-    maxHistorySize?: number;
-    includePayload?: boolean;
-    actionNames?: {
-        update?: string;
-        set?: string;
-        batch?: string;
-        [key: string]: string | undefined;
-    };
-}
-export declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-export declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
-    __timeTravel: TimeTravelInterface<T>;
-};
-export declare function getTimeTravel<T>(tree: SignalTree<T> & {
-    __timeTravel?: TimeTravelInterface<T>;
-}): TimeTravelInterface<T> | undefined;

package/src/enhancers/time-travel/lib/utils.d.ts

@@ -1 +0,0 @@
-export { deepClone, deepEqual } from '@signaltree/shared';

package/src/enhancers/time-travel/test-setup.d.ts

@@ -1,3 +0,0 @@
-import '@angular/compiler';
-import 'zone.js';
-import 'zone.js/testing';

package/src/enhancers/types.d.ts

@@ -1,74 +0,0 @@
-export interface BatchingConfig {
-    maxBatchSize?: number;
-    debounceMs?: number;
-    flushOnMicrotask?: boolean;
-}
-export interface BatchUpdate<T = unknown> {
-    path: string[];
-    value: T;
-    timestamp: number;
-}
-export interface ComputedSignal<T> {
-    (): T;
-    readonly value: T;
-}
-export interface ComputedConfig {
-    lazy?: boolean;
-    memoize?: boolean;
-}
-export interface MemoizationConfig {
-    maxSize?: number;
-    ttl?: number;
-    strategy?: 'lru' | 'fifo' | 'lfu';
-}
-export interface MemoizedFunction<T extends (...args: never[]) => unknown> {
-    (...args: Parameters<T>): ReturnType<T>;
-    clear(): void;
-    stats(): {
-        hits: number;
-        misses: number;
-        size: number;
-    };
-}
-export interface TimeTravelConfig {
-    maxHistorySize?: number;
-    enableCompression?: boolean;
-}
-export interface TimeTravelState {
-    canUndo: boolean;
-    canRedo: boolean;
-    historySize: number;
-    currentIndex: number;
-}
-export interface DevToolsConfig {
-    name?: string;
-    enabled?: boolean;
-    logLevel?: 'debug' | 'info' | 'warn' | 'error';
-}
-export interface DevToolsAction {
-    type: string;
-    payload?: unknown;
-    timestamp: number;
-    source: string;
-}
-export interface PresetConfig {
-    name: string;
-    enhancers: unknown[];
-    config?: Record<string, unknown>;
-}
-export interface EntityConfig {
-    idField?: string;
-    indexes?: string[];
-    relations?: Record<string, string>;
-}
-export interface SerializationConfig {
-    includeComputed?: boolean;
-    includeMeta?: boolean;
-    customSerializers?: Record<string, (value: unknown) => unknown>;
-}
-export interface SerializedState {
-    version: string;
-    timestamp: number;
-    data: unknown;
-    meta?: Record<string, unknown>;
-}

package/src/index.d.ts

@@ -1,18 +0,0 @@
-export { signalTree } from './lib/signal-tree';
-export type { SignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, PerformanceMetrics, EntityHelpers, TimeTravelEntry, } from './lib/types';
-export { entityMap } from './lib/types';
-export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
-export { getPathNotifier } from './lib/path-notifier';
-export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
-export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
-export { ENHANCER_META } from './lib/types';
-export { withBatching, withHighPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/lib/batching';
-export { withMemoization, withSelectorMemoization, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withShallowMemoization, memoize, memoizeShallow, memoizeReference, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/lib/memoization';
-export { withTimeTravel, enableTimeTravel, getTimeTravel, type TimeTravelInterface, } from './enhancers/time-travel/lib/time-travel';
-export { withEntities, enableEntities, withHighPerformanceEntities, } from './enhancers/entities/lib/entities';
-export { withSerialization, enableSerialization, withPersistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/lib/serialization';
-export { withDevTools, enableDevTools, withFullDevTools, withProductionDevTools, } from './enhancers/devtools/lib/devtools';
-export { createAsyncOperation, trackAsync } from './lib/async-helpers';
-export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
-export { computedEnhancer, createComputed, type ComputedConfig, type ComputedSignal, type ComputedSignalTree, } from './enhancers/computed/lib/computed';
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';

package/src/lib/async-helpers.d.ts

@@ -1,8 +0,0 @@
-import type { SignalTree } from './types';
-export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
-export declare function trackAsync<T>(operation: () => Promise<T>): {
-    pending: import("@angular/core").Signal<boolean>;
-    error: import("@angular/core").Signal<Error | null>;
-    result: import("@angular/core").Signal<T | null>;
-    execute: () => Promise<T>;
-};

package/src/lib/constants.d.ts

@@ -1,41 +0,0 @@
-export declare const SIGNAL_TREE_CONSTANTS: {
-    readonly MAX_PATH_CACHE_SIZE: 1000;
-    readonly LAZY_THRESHOLD: 50;
-    readonly ESTIMATE_MAX_DEPTH: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_ARRAY: 3;
-    readonly ESTIMATE_SAMPLE_SIZE_OBJECT: 5;
-    readonly DEFAULT_CACHE_SIZE: 100;
-    readonly DEFAULT_BATCH_SIZE: 10;
-};
-export 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 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";
-}>;

package/src/lib/entity-signal.d.ts

@@ -1 +0,0 @@
-export {};

package/src/lib/memory/memory-manager.d.ts

@@ -1,30 +0,0 @@
-import type { WritableSignal } from '@angular/core';
-export interface MemoryStats {
-    cachedSignals: number;
-    cleanedUpSignals: number;
-    peakCachedSignals: number;
-    manualDisposes: number;
-    estimatedMemoryBytes: number;
-}
-export interface MemoryManagerConfig {
-    enableAutoCleanup?: boolean;
-    debugMode?: boolean;
-    onCleanup?: (path: string, stats: MemoryStats) => void;
-}
-export declare class SignalMemoryManager {
-    private cache;
-    private registry;
-    private config;
-    private stats;
-    constructor(config?: MemoryManagerConfig);
-    cacheSignal<T>(path: string, signal: WritableSignal<T>): void;
-    getSignal(path: string): WritableSignal<unknown> | undefined;
-    hasSignal(path: string): boolean;
-    removeSignal(path: string): boolean;
-    private handleCleanup;
-    getStats(): MemoryStats;
-    dispose(): void;
-    getCachedPaths(): string[];
-    clearStale(): number;
-    resetStats(): void;
-}

package/src/lib/path-notifier.d.ts

@@ -1,4 +0,0 @@
-export type PathNotifierInterceptor = (value: unknown, prev: unknown, path: string) => {
-    block?: boolean;
-    transform?: unknown;
-};

package/src/lib/performance/diff-engine.d.ts

@@ -1,33 +0,0 @@
-import type { Path } from './path-index';
-export declare enum ChangeType {
-    ADD = "add",
-    UPDATE = "update",
-    DELETE = "delete",
-    REPLACE = "replace"
-}
-export interface Change {
-    type: ChangeType;
-    path: Path;
-    value?: unknown;
-    oldValue?: unknown;
-}
-export interface Diff {
-    changes: Change[];
-    hasChanges: boolean;
-}
-export interface DiffOptions {
-    maxDepth?: number;
-    detectDeletions?: boolean;
-    ignoreArrayOrder?: boolean;
-    equalityFn?: (a: unknown, b: unknown) => boolean;
-    keyValidator?: (key: string) => boolean;
-}
-export declare class DiffEngine {
-    private defaultOptions;
-    diff(current: unknown, updates: unknown, options?: DiffOptions): Diff;
-    private traverse;
-    private diffArrays;
-    private diffArraysOrdered;
-    private diffArraysUnordered;
-    private stringify;
-}

package/src/lib/performance/path-index.d.ts

@@ -1,25 +0,0 @@
-import type { WritableSignal } from '@angular/core';
-export type PathSegment = string | number;
-export type Path = PathSegment[];
-export declare class PathIndex<T extends object = WritableSignal<any>> {
-    private root;
-    private pathCache;
-    private stats;
-    set(path: Path, signal: T): void;
-    get(path: Path): T | null;
-    has(path: Path): boolean;
-    getByPrefix(prefix: Path): Map<string, T>;
-    delete(path: Path): boolean;
-    clear(): void;
-    getStats(): {
-        hits: number;
-        misses: number;
-        sets: number;
-        cleanups: number;
-        hitRate: number;
-        cacheSize: number;
-    };
-    buildFromTree(tree: unknown, path?: Path): void;
-    private pathToString;
-    private collectDescendants;
-}

package/src/lib/performance/update-engine.d.ts

@@ -1,32 +0,0 @@
-import { PathIndex } from './path-index';
-import type { DiffOptions } from './diff-engine';
-export interface UpdateOptions extends DiffOptions {
-    batch?: boolean;
-    batchSize?: number;
-}
-export interface UpdateResult {
-    changed: boolean;
-    duration: number;
-    changedPaths: string[];
-    stats?: {
-        totalPaths: number;
-        optimizedPaths: number;
-        batchedUpdates: number;
-    };
-}
-export declare class OptimizedUpdateEngine {
-    private pathIndex;
-    private diffEngine;
-    constructor(tree: unknown);
-    update(tree: unknown, updates: unknown, options?: UpdateOptions): UpdateResult;
-    rebuildIndex(tree: unknown): void;
-    getIndexStats(): ReturnType<PathIndex['getStats']>;
-    private createPatches;
-    private createPatch;
-    private calculatePriority;
-    private sortPatches;
-    private applyPatches;
-    private batchApplyPatches;
-    private applyPatch;
-    private isEqual;
-}

package/src/lib/security/security-validator.d.ts

@@ -1,33 +0,0 @@
-export type SecurityEventType = 'dangerous-key-blocked' | 'xss-attempt-blocked' | 'function-value-blocked' | 'validation-error';
-export interface SecurityEvent {
-    type: SecurityEventType;
-    key?: string;
-    value?: unknown;
-    reason: string;
-    timestamp: number;
-}
-export interface SecurityValidatorConfig {
-    preventPrototypePollution?: boolean;
-    preventXSS?: boolean;
-    preventFunctions?: boolean;
-    customDangerousKeys?: string[];
-    onSecurityEvent?: (event: SecurityEvent) => void;
-    sanitizationMode?: 'strict' | 'permissive';
-}
-export declare class SecurityValidator {
-    private readonly config;
-    private readonly dangerousKeys;
-    constructor(config?: SecurityValidatorConfig);
-    validateKey(key: string): void;
-    validateValue<T>(value: T): T;
-    private sanitize;
-    validateKeyValue<T>(key: string, value: T): T;
-    isDangerousKey(key: string): boolean;
-    getConfig(): Readonly<Required<SecurityValidatorConfig>>;
-}
-export declare const SecurityPresets: {
-    strict: () => SecurityValidator;
-    standard: () => SecurityValidator;
-    permissive: () => SecurityValidator;
-    disabled: () => SecurityValidator;
-};

package/src/lib/signal-tree.d.ts

@@ -1,8 +0,0 @@
-import type { SignalTree, TreeConfig, TreePreset, EnhancerWithMeta, NodeAccessor } from './types';
-export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
-export declare function signalTree<T>(obj: T): SignalTree<T>;
-export declare function signalTree<T>(obj: T, preset: TreePreset): SignalTree<T>;
-export declare function signalTree<T>(obj: T, config: TreeConfig): SignalTree<T>;
-export declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>, configOrPreset?: TreeConfig | TreePreset): SignalTree<Required<T>>;
-export declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset): SignalTree<T>;
-export declare function applyEnhancer<T, O>(tree: SignalTree<T>, enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;

package/src/lib/types.d.ts

@@ -1,278 +0,0 @@
-import { Signal, WritableSignal } from '@angular/core';
-import type { SecurityValidatorConfig } from './security/security-validator';
-export type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
-declare module '@angular/core' {
-    interface WritableSignal<T> {
-        (value: NotFn<T>): void;
-        (updater: (current: T) => T): void;
-    }
-}
-export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
-export 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;
-export type Unwrap<T> = [T] extends [WritableSignal<infer U>] ? U : [T] extends [Signal<infer U>] ? U : [T] extends [BuiltInObject] ? T : [T] extends [readonly unknown[]] ? T : [T] extends [EntityMapMarker<infer E, infer K>] ? EntitySignal<E, K> : [T] extends [object] ? {
-    [K in keyof T]: Unwrap<T[K]>;
-} : T;
-export interface NodeAccessor<T> {
-    (): T;
-    (value: T): void;
-    (updater: (current: T) => T): void;
-}
-export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
-export type CallableWritableSignal<T> = WritableSignal<T> & {
-    (value: NotFn<T>): void;
-    (updater: (current: T) => T): void;
-};
-export type TreeNode<T> = {
-    [K in keyof T]: [T[K]] extends [EntityMapMarker<infer E, infer Key>] ? EntitySignal<E, Key> : [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]>;
-};
-export type RemoveSignalMethods<T> = T extends infer U ? U : never;
-export type DeepPath<T, Prefix extends string = '', Depth extends readonly number[] = []> = Depth['length'] extends 5 ? never : {
-    [K in keyof T]: K extends string ? T[K] extends readonly unknown[] ? `${Prefix}${K}` : T[K] extends object ? T[K] extends Signal<unknown> ? never : T[K] extends BuiltInObject ? never : T[K] extends (...args: unknown[]) => unknown ? never : `${Prefix}${K}` | DeepPath<T[K], `${Prefix}${K}.`, [...Depth, 1]> : never : never;
-}[keyof T];
-export type DeepAccess<T, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? DeepAccess<T[First] & object, Rest> : never : Path extends keyof T ? T[Path] : never;
-export interface EnhancerMeta {
-    name?: string;
-    requires?: string[];
-    provides?: string[];
-}
-export type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
-export type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
-    metadata?: EnhancerMeta;
-};
-export declare const ENHANCER_META: unique symbol;
-export 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;
-export 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;
-}
-export type SignalTree<T> = NodeAccessor<T> & {
-    state: TreeNode<T>;
-    $: TreeNode<T>;
-    with: WithMethod<T>;
-    destroy(): void;
-    dispose?(): void;
-    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[];
-    };
-    optimize(): void;
-    clearCache(): void;
-    invalidatePattern(pattern: string): number;
-    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;
-    entities<E extends {
-        id: string | number;
-    }>(entityKey?: keyof T): EntityHelpers<E>;
-    undo(): void;
-    redo(): void;
-    getHistory(): TimeTravelEntry<T>[];
-    resetHistory(): void;
-    jumpTo?: (index: number) => void;
-    canUndo?: () => boolean;
-    canRedo?: () => boolean;
-    getCurrentIndex?: () => number;
-};
-export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
-export 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?: SecurityValidatorConfig;
-}
-export interface PerformanceMetrics {
-    updates: number;
-    computations: number;
-    cacheHits: number;
-    cacheMisses: number;
-    averageUpdateTime: number;
-}
-export interface EntityConfig<E, K extends string | number = string> {
-    selectId?: (entity: E) => K;
-    hooks?: {
-        beforeAdd?: (entity: E) => E | false;
-        beforeUpdate?: (id: K, changes: Partial<E>) => Partial<E> | false;
-        beforeRemove?: (id: K, entity: E) => boolean;
-    };
-}
-declare const ENTITY_MAP_BRAND: unique symbol;
-export interface EntityMapMarker<E, K extends string | number> {
-    readonly [ENTITY_MAP_BRAND]: {
-        __entity: E;
-        __key: K;
-    };
-    readonly __isEntityMap: true;
-    readonly __entityMapConfig?: EntityConfig<E, K>;
-}
-export declare function entityMap<E, K extends string | number = E extends {
-    id: infer I extends string | number;
-} ? I : string>(config?: EntityConfig<E, K>): EntityMapMarker<E, K>;
-export interface MutationOptions {
-    onError?: (error: Error) => void;
-}
-export interface AddOptions<E, K> extends MutationOptions {
-    selectId?: (entity: E) => K;
-}
-export interface AddManyOptions<E, K> extends AddOptions<E, K> {
-    mode?: 'strict' | 'skip' | 'overwrite';
-}
-export interface TapHandlers<E, K extends string | number> {
-    onAdd?: (entity: E, id: K) => void;
-    onUpdate?: (id: K, changes: Partial<E>, entity: E) => void;
-    onRemove?: (id: K, entity: E) => void;
-    onChange?: () => void;
-}
-export interface InterceptContext<T> {
-    block(reason?: string): void;
-    transform(value: T): void;
-    readonly blocked: boolean;
-    readonly blockReason: string | undefined;
-}
-export interface InterceptHandlers<E, K extends string | number> {
-    onAdd?: (entity: E, ctx: InterceptContext<E>) => void | Promise<void>;
-    onUpdate?: (id: K, changes: Partial<E>, ctx: InterceptContext<Partial<E>>) => void | Promise<void>;
-    onRemove?: (id: K, entity: E, ctx: InterceptContext<void>) => void | Promise<void>;
-}
-export type EntityNode<E> = {
-    (): E;
-    (value: E): void;
-    (updater: (current: E) => E): void;
-} & {
-    [P in keyof E]: E[P] extends object ? E[P] extends readonly unknown[] ? CallableWritableSignal<E[P]> : EntityNode<E[P]> : CallableWritableSignal<E[P]>;
-};
-export interface EntitySignal<E, K extends string | number = string> {
-    byId(id: K): EntityNode<E> | undefined;
-    byIdOrFail(id: K): EntityNode<E>;
-    all(): Signal<E[]>;
-    count(): Signal<number>;
-    ids(): Signal<K[]>;
-    has(id: K): Signal<boolean>;
-    isEmpty(): Signal<boolean>;
-    map(): Signal<ReadonlyMap<K, E>>;
-    where(predicate: (entity: E) => boolean): Signal<E[]>;
-    find(predicate: (entity: E) => boolean): Signal<E | undefined>;
-    addOne(entity: E, opts?: AddOptions<E, K>): K;
-    addMany(entities: E[], opts?: AddManyOptions<E, K>): K[];
-    updateOne(id: K, changes: Partial<E>, opts?: MutationOptions): void;
-    updateMany(ids: K[], changes: Partial<E>, opts?: MutationOptions): void;
-    updateWhere(predicate: (entity: E) => boolean, changes: Partial<E>): number;
-    upsertOne(entity: E, opts?: AddOptions<E, K>): K;
-    upsertMany(entities: E[], opts?: AddOptions<E, K>): K[];
-    removeOne(id: K, opts?: MutationOptions): void;
-    removeMany(ids: K[], opts?: MutationOptions): void;
-    removeWhere(predicate: (entity: E) => boolean): number;
-    clear(): void;
-    removeAll(): void;
-    setAll(entities: E[], opts?: AddOptions<E, K>): void;
-    tap(handlers: TapHandlers<E, K>): () => void;
-    intercept(handlers: InterceptHandlers<E, K>): () => void;
-}
-export 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;
-}
-export interface LoggingConfig {
-    name?: string;
-    filter?: (path: string) => boolean;
-    collapsed?: boolean;
-    onLog?: (entry: LogEntry) => void;
-}
-export interface LogEntry {
-    path: string;
-    prev: unknown;
-    value: unknown;
-    timestamp: number;
-}
-export interface ValidationConfig<T> {
-    validators: Array<{
-        match: (path: string) => boolean;
-        validate: (value: T, path: string) => void | never;
-    }>;
-    onError?: (error: Error, path: string) => void;
-}
-export interface PersistenceConfig {
-    key: string;
-    storage?: Storage;
-    debounceMs?: number;
-    filter?: (path: string) => boolean;
-    serialize?: (state: unknown) => string;
-    deserialize?: (json: string) => unknown;
-}
-export interface DevToolsConfig {
-    name?: string;
-    maxAge?: number;
-    features?: {
-        jump?: boolean;
-        skip?: boolean;
-        reorder?: boolean;
-    };
-}
-export type EntityType<T> = T extends EntitySignal<infer E, infer K extends string | number> ? E : never;
-export type EntityKeyType<T> = T extends EntitySignal<unknown, infer K extends string | number> ? K : never;
-export type IsEntityMap<T> = T extends EntityMapMarker<unknown, infer K extends string | number> ? true : false;
-export type EntityAwareTreeNode<T> = {
-    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends object ? EntityAwareTreeNode<T[K]> : CallableWritableSignal<T[K]>;
-};
-export type PathHandler = (value: unknown, prev: unknown, path: string) => void;
-export type PathInterceptor = (ctx: {
-    path: string;
-    value: unknown;
-    prev: unknown;
-    blocked: boolean;
-    blockReason?: string;
-}, next: () => void) => void | Promise<void>;
-export interface TimeTravelEntry<T> {
-    action: string;
-    timestamp: number;
-    state: T;
-    payload?: unknown;
-}
-export declare function isSignalTree<T>(value: unknown): value is SignalTree<T>;
-export {};