mutts 1.0.6 → 1.0.8

package/dist/browser.d.ts

@@ -0,0 +1,1655 @@
+/**
+ * Error thrown when decorator operations fail
+ */
+declare class DecoratorError extends Error {
+    constructor(message: string);
+}
+/**
+ * Legacy property decorator type for methods, getters, and setters
+ */
+type LegacyPropertyDecorator<T> = (target: T, name: string | symbol, descriptor: PropertyDescriptor) => any;
+/**
+ * Legacy class decorator type
+ */
+type LegacyClassDecorator<T> = (target: T) => any;
+/**
+ * Modern method decorator type
+ */
+type ModernMethodDecorator<T> = (target: T, context: ClassMethodDecoratorContext) => any;
+/**
+ * Modern getter decorator type
+ */
+type ModernGetterDecorator<T> = (target: T, context: ClassGetterDecoratorContext) => any;
+/**
+ * Modern setter decorator type
+ */
+type ModernSetterDecorator<T> = (target: T, context: ClassSetterDecoratorContext) => any;
+/**
+ * Modern accessor decorator type
+ */
+type ModernAccessorDecorator<T> = (target: T, context: ClassAccessorDecoratorContext) => any;
+/**
+ * Modern class decorator type
+ */
+type ModernClassDecorator<T> = (target: T, context: ClassDecoratorContext) => any;
+type DDMethod<T> = (original: (this: T, ...args: any[]) => any, target: any, name: PropertyKey) => ((this: T, ...args: any[]) => any) | void;
+type DDGetter<T> = (original: (this: T) => any, target: any, name: PropertyKey) => ((this: T) => any) | void;
+type DDSetter<T> = (original: (this: T, value: any) => void, target: any, name: PropertyKey) => ((this: T, value: any) => void) | void;
+type DDClass<T> = <Ctor extends new (...args: any[]) => T = new (...args: any[]) => T>(target: Ctor) => Ctor | void;
+/**
+ * Description object for creating decorators that work with both Legacy and Modern decorator proposals
+ */
+interface DecoratorDescription<T> {
+    /** Handler for method decorators */
+    method?: DDMethod<T>;
+    /** Handler for class decorators */
+    class?: DDClass<T>;
+    /** Handler for getter decorators */
+    getter?: DDGetter<T>;
+    /** Handler for setter decorators */
+    setter?: DDSetter<T>;
+    /** Default handler for any decorator type not explicitly defined */
+    default?: (...args: any[]) => any;
+}
+/**
+ * Type for decorators that work with both Legacy and Modern decorator proposals
+ * Automatically infers the correct decorator type based on the description
+ */
+type Decorator<T, Description extends DecoratorDescription<T>> = (Description extends {
+    method: DDMethod<T>;
+} ? LegacyPropertyDecorator<T> & ModernMethodDecorator<T> : unknown) & (Description extends {
+    class: DDClass<new (...args: any[]) => T>;
+} ? LegacyClassDecorator<new (...args: any[]) => T> & ModernClassDecorator<new (...args: any[]) => T> : unknown) & (Description extends {
+    getter: DDGetter<T>;
+} ? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
+    setter: DDSetter<T>;
+} ? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
+    default: infer Signature;
+} ? Signature : unknown);
+/**
+ * Factory type for creating decorators that work with both Legacy and Modern decorator proposals
+ */
+type DecoratorFactory<T> = <Description extends DecoratorDescription<T>>(description: Description) => (Description extends {
+    method: DDMethod<T>;
+} ? LegacyPropertyDecorator<T> & ModernMethodDecorator<T> : unknown) & (Description extends {
+    class: DDClass<new (...args: any[]) => T>;
+} ? LegacyClassDecorator<new (...args: any[]) => T> & ModernClassDecorator<new (...args: any[]) => T> : unknown) & (Description extends {
+    getter: DDGetter<T>;
+} ? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
+    setter: DDSetter<T>;
+} ? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
+    default: infer Signature;
+} ? Signature : unknown);
+/**
+ * Creates a decorator that works with Legacy decorator proposals
+ * @param description - The decorator description object
+ * @returns A decorator function compatible with Legacy decorators
+ */
+declare function legacyDecorator<T = any>(description: DecoratorDescription<T>): any;
+/**
+ * Creates a decorator that works with Modern decorator proposals
+ * @param description - The decorator description object
+ * @returns A decorator function compatible with Modern decorators
+ */
+declare function modernDecorator<T = any>(description: DecoratorDescription<T>): any;
+/**
+ * Main decorator factory that automatically detects and works with both Legacy and Modern decorator proposals
+ * @param description - The decorator description object
+ * @returns A decorator that works in both Legacy and Modern environments
+ */
+declare const decorator: DecoratorFactory<any>;
+/**
+ * Generic class decorator type that works with both Legacy and Modern decorator proposals
+ */
+type GenericClassDecorator<T> = LegacyClassDecorator<abstract new (...args: any[]) => T> & ModernClassDecorator<abstract new (...args: any[]) => T>;
+
+/**
+ * Symbol for marking destructor methods
+ */
+declare const destructor: unique symbol;
+/**
+ * Symbol for accessing allocated values in destroyable objects
+ */
+declare const allocatedValues: unique symbol;
+/**
+ * Error thrown when attempting to access a destroyed object
+ */
+declare class DestructionError extends Error {
+    static throw<_T = void>(msg: string): () => never;
+    constructor(msg: string);
+}
+declare abstract class AbstractDestroyable<Allocated> {
+    abstract [destructor](allocated: Allocated): void;
+    [Symbol.dispose](): void;
+}
+interface Destructor<Allocated> {
+    destructor(allocated: Allocated): void;
+}
+/**
+ * Creates a destroyable class with a base class and destructor object
+ * @param base - The base class to extend
+ * @param destructorObj - Object containing the destructor method
+ * @returns A destroyable class with static destroy and isDestroyable methods
+ */
+declare function Destroyable<T extends new (...args: any[]) => any, Allocated extends Partial<InstanceType<T>>>(base: T, destructorObj: Destructor<Allocated>): (new (...args: ConstructorParameters<T>) => InstanceType<T> & {
+    [allocatedValues]: Allocated;
+}) & {
+    destroy(obj: InstanceType<T>): boolean;
+    isDestroyable(obj: InstanceType<T>): boolean;
+};
+/**
+ * Creates a destroyable class with only a destructor object (no base class)
+ * @param destructorObj - Object containing the destructor method
+ * @returns A destroyable class with static destroy and isDestroyable methods
+ */
+declare function Destroyable<Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(destructorObj: Destructor<Allocated>): (new () => {
+    [allocatedValues]: Allocated;
+}) & {
+    destroy(obj: any): boolean;
+    isDestroyable(obj: any): boolean;
+};
+/**
+ * Creates a destroyable class with a base class (requires [destructor] method)
+ * @param base - The base class to extend
+ * @returns A destroyable class with static destroy and isDestroyable methods
+ */
+declare function Destroyable<T extends new (...args: any[]) => any, Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(base: T): (new (...args: ConstructorParameters<T>) => AbstractDestroyable<Allocated> & InstanceType<T> & {
+    [allocatedValues]: Allocated;
+}) & {
+    destroy(obj: InstanceType<T>): boolean;
+    isDestroyable(obj: InstanceType<T>): boolean;
+};
+/**
+ * Creates an abstract destroyable base class
+ * @returns An abstract destroyable class with static destroy and isDestroyable methods
+ */
+declare function Destroyable<Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(): abstract new () => (AbstractDestroyable<Allocated> & {
+    [allocatedValues]: Allocated;
+}) & {
+    destroy(obj: any): boolean;
+    isDestroyable(obj: any): boolean;
+};
+/**
+ * Decorator that marks properties to be stored in the allocated object and passed to the destructor
+ * Use with accessor properties or explicit get/set pairs
+ */
+declare const allocated: LegacyPropertyDecorator<any> & ModernSetterDecorator<any> & ModernAccessorDecorator<any>;
+/**
+ * Registers a callback to be called when an object is garbage collected
+ * @param cb - The callback function to execute on garbage collection
+ * @returns The object whose reference can be collected
+ */
+declare function callOnGC(cb: () => void): () => void;
+/**
+ * Context Manager Protocol for `using` statement integration
+ * Provides automatic resource cleanup when used with the `using` statement
+ */
+interface ContextManager<T = any> {
+    [Symbol.dispose](): void;
+    value?: T;
+}
+
+/**
+ * Base type for event maps - all event handlers must be functions
+ */
+type EventsBase = Record<string, (...args: any[]) => void>;
+/**
+ * A type-safe event system that provides a clean API for event handling
+ * @template Events - The event map defining event names and their handler signatures
+ */
+declare class Eventful<Events extends EventsBase> {
+    #private;
+    hook(cb: <EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void): () => void;
+    on(events: Partial<Events>): void;
+    on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void;
+    off(events: Partial<Events>): void;
+    off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void;
+    emit<EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>): void;
+}
+
+/**
+ * Symbol for defining custom getter logic for numeric index access
+ */
+declare const getAt: unique symbol;
+/**
+ * Symbol for defining custom setter logic for numeric index access
+ */
+declare const setAt: unique symbol;
+interface IndexingAt<Items = any> {
+    [getAt](index: number): Items;
+}
+interface Accessor<T, Items> {
+    get(this: T, index: number): Items;
+    set?(this: T, index: number, value: Items): void;
+    getLength?(this: T): number;
+    setLength?(this: T, value: number): void;
+}
+declare abstract class AbstractGetAt<Items = any> {
+    abstract [getAt](index: number): Items;
+}
+/**
+ * Creates an indexable class with a base class and accessor object
+ * @param base - The base class to extend
+ * @param accessor - Object containing get/set methods for numeric index access
+ * @returns A class that supports numeric index access
+ */
+declare function Indexable<Items, Base extends abstract new (...args: any[]) => any>(base: Base, accessor: Accessor<InstanceType<Base>, Items>): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
+    [x: number]: Items;
+};
+/**
+ * Creates an indexable class with only an accessor object (no base class)
+ * @param accessor - Object containing get/set methods for numeric index access
+ * @returns A class that supports numeric index access
+ */
+declare function Indexable<Items>(accessor: Accessor<any, Items>): new () => {
+    [x: number]: Items;
+};
+/**
+ * Creates an indexable class with a base class that has [getAt] method
+ * @param base - The base class that implements [getAt] method
+ * @returns A class that supports numeric index access using the base class's [getAt] method
+ */
+declare function Indexable<Base extends new (...args: any[]) => IndexingAt>(base: Base): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
+    [x: number]: AtReturnType<InstanceType<Base>>;
+};
+/**
+ * Creates an abstract indexable base class
+ * @returns An abstract class that supports numeric index access
+ */
+declare function Indexable<Items>(): abstract new (...args: any[]) => AbstractGetAt & {
+    [x: number]: Items;
+};
+type AtReturnType<T> = T extends {
+    [getAt](index: number): infer R;
+} ? R : never;
+/**
+ * Symbol for accessing the forwarded array in ArrayReadForward
+ */
+declare const forwardArray: unique symbol;
+/**
+ * A read-only array forwarder that implements all reading/iterating methods of Array
+ * but does not implement modification methods.
+ *
+ * The constructor takes a callback that returns an array, and all methods forward
+ * their behavior to the result of that callback.
+ */
+declare class ArrayReadForward<T> {
+    protected get [forwardArray](): readonly T[];
+    /**
+     * Get the length of the array
+     */
+    get length(): number;
+    /**
+     * Get an element at a specific index
+     */
+    [index: number]: T | undefined;
+    /**
+     * Iterator protocol support
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     */
+    map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+    /**
+     * Creates a new array with all elements that pass the test implemented by the provided function
+     */
+    filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
+    filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+    /**
+     * Executes a reducer function on each element of the array, resulting in a single output value
+     */
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+    /**
+     * Executes a reducer function on each element of the array (right-to-left), resulting in a single output value
+     */
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+    /**
+     * Executes a provided function once for each array element
+     */
+    forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+    /**
+     * Returns the value of the first element in the array that satisfies the provided testing function
+     */
+    find<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    find(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    /**
+     * Returns the index of the first element in the array that satisfies the provided testing function
+     */
+    findIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    /**
+     * Returns the value of the last element in the array that satisfies the provided testing function
+     */
+    findLast<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    findLast(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    /**
+     * Returns the index of the last element in the array that satisfies the provided testing function
+     */
+    findLastIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    /**
+     * Determines whether an array includes a certain value among its entries
+     */
+    includes(searchElement: T, fromIndex?: number): boolean;
+    /**
+     * Returns the first index at which a given element can be found in the array
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns the last index at which a given element can be found in the array
+     */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns a shallow copy of a portion of an array into a new array object
+     */
+    slice(start?: number, end?: number): T[];
+    /**
+     * Returns a new array comprised of this array joined with other array(s) and/or value(s)
+     */
+    concat(...items: ConcatArray<T>[]): T[];
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    /**
+     * Tests whether all elements in the array pass the test implemented by the provided function
+     */
+    every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+    /**
+     * Tests whether at least one element in the array passes the test implemented by the provided function
+     */
+    some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+    /**
+     * Joins all elements of an array into a string
+     */
+    join(separator?: string): string;
+    /**
+     * Returns a new array iterator that contains the keys for each index in the array
+     */
+    keys(): IterableIterator<number>;
+    /**
+     * Returns a new array iterator that contains the values for each index in the array
+     */
+    values(): IterableIterator<T>;
+    /**
+     * Returns a new array iterator that contains the key/value pairs for each index in the array
+     */
+    entries(): IterableIterator<[number, T]>;
+    /**
+     * Returns a string representation of the array
+     */
+    toString(): string;
+    /**
+     * Returns a localized string representing the array
+     */
+    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions): string;
+    /**
+     * Returns the element at the specified index, or undefined if the index is out of bounds
+     */
+    at(index: number): T | undefined;
+    /**
+     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
+     */
+    flat(depth?: number): T[];
+    /**
+     * Returns a new array formed by applying a given callback function to each element of the array,
+     * and then flattening the result by one level
+     */
+    flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: readonly T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
+    /**
+     * Returns a new array with elements in reversed order (ES2023)
+     */
+    toReversed(): T[];
+    /**
+     * Returns a new array with elements sorted (ES2023)
+     */
+    toSorted(compareFn?: ((a: T, b: T) => number) | undefined): T[];
+    /**
+     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
+     */
+    toSpliced(start: number, deleteCount?: number, ...items: T[]): T[];
+    /**
+     * Returns a new array with the element at the given index replaced with the given value (ES2023)
+     */
+    with(index: number, value: T): T[];
+    get [Symbol.unscopables](): {
+        readonly [x: number]: boolean;
+        readonly length?: boolean;
+        toString?: boolean;
+        toLocaleString?: boolean;
+        concat?: boolean;
+        join?: boolean;
+        slice?: boolean;
+        indexOf?: boolean;
+        lastIndexOf?: boolean;
+        every?: boolean;
+        some?: boolean;
+        forEach?: boolean;
+        map?: boolean;
+        filter?: boolean;
+        reduce?: boolean;
+        reduceRight?: boolean;
+        find?: boolean;
+        findIndex?: boolean;
+        entries?: boolean;
+        keys?: boolean;
+        values?: boolean;
+        includes?: boolean;
+        flatMap?: boolean;
+        flat?: boolean;
+        at?: boolean;
+        findLast?: boolean;
+        findLastIndex?: boolean;
+        toReversed?: boolean;
+        toSorted?: boolean;
+        toSpliced?: boolean;
+        with?: boolean;
+        [Symbol.iterator]?: boolean;
+        readonly [Symbol.unscopables]?: boolean;
+    };
+}
+
+/**
+ * Uses weak references but still may iterate through them
+ * Note: The behavior is highly dependant on the garbage collector - some entries are perhaps deemed to be collected: don't resuscitate them
+ */
+declare class IterableWeakMap<K extends WeakKey, V> implements Map<K, V> {
+    private uuids;
+    private refs;
+    private readonly registry;
+    constructor(entries?: Iterable<[K, V]>);
+    private createIterator;
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    get size(): number;
+    entries(): MapIterator<[K, V]>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    readonly [Symbol.toStringTag]: string;
+}
+/**
+ * Uses weak references but still may iterate through them
+ * Note: The behavior is highly dependant on the garbage collector - some entries are perhaps deemed to be collected: don't resuscitate them
+ */
+declare class IterableWeakSet<K extends WeakKey> implements Set<K> {
+    private uuids;
+    private refs;
+    private readonly registry;
+    constructor(entries?: Iterable<K>);
+    private createIterator;
+    clear(): void;
+    add(value: K): this;
+    delete(value: K): boolean;
+    forEach(callbackfn: (value: K, value2: K, set: Set<K>) => void, thisArg?: any): void;
+    has(value: K): boolean;
+    get size(): number;
+    entries(): SetIterator<[K, K]>;
+    keys(): SetIterator<K>;
+    values(): SetIterator<K>;
+    [Symbol.iterator](): SetIterator<K>;
+    readonly [Symbol.toStringTag]: string;
+    union<U>(other: ReadonlySetLike<U>): Set<K | U>;
+    intersection<U>(other: ReadonlySetLike<U>): Set<K & U>;
+    difference<U>(other: ReadonlySetLike<U>): Set<K>;
+    symmetricDifference<U>(other: ReadonlySetLike<U>): Set<K | U>;
+    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
+}
+
+/**
+ * A mixin function that takes a base class and returns a new class with mixed-in functionality
+ * @template Mixed - The functionality to be mixed in
+ */
+type MixinFunction<Mixed> = <Base>(base: new (...args: any[]) => Base) => new (...args: any[]) => Base & Mixed;
+/**
+ * A mixin class that can be used both as a base class and as a mixin function
+ * @template Mixed - The functionality to be mixed in
+ */
+type MixinClass<Mixed> = new (...args: any[]) => Mixed;
+/**
+ * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
+ *
+ * This function supports:
+ * - Using mixins as base classes: `class MyClass extends MyMixin`
+ * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
+ * - Composing mixins: `const Composed = MixinA(MixinB)`
+ * - Type-safe property inference for all patterns
+ *
+ * @param mixinFunction - The function that creates the mixin
+ * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
+ * @returns A mixin that can be used both as a class and as a function
+ */
+declare function mixin<MixinFn extends (base: any) => new (...args: any[]) => any>(mixinFunction: MixinFn, unwrapFunction?: (obj: any) => any): (new (...args: any[]) => InstanceType<ReturnType<MixinFn>>) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => InstanceType<ReturnType<MixinFn>> & Base);
+
+type Resolved<T> = T extends Promise<infer U> ? Resolved<U> : T extends (...args: infer Args) => infer R ? (...args: Args) => Resolved<R> : T extends object ? {
+    [k in keyof T]: k extends 'then' | 'catch' | 'finally' ? T[k] : Resolved<T[k]>;
+} : T;
+type PromiseAnd<T> = Resolved<T> & Promise<Resolved<T>>;
+/**
+ * Type that transforms promises into chainable objects
+ * Allows calling methods directly on promise results without awaiting them first
+ */
+type PromiseChain<T> = T extends (...args: infer Args) => infer R ? PromiseAnd<(...args: Args) => PromiseChain<Resolved<R>>> : T extends object ? PromiseAnd<{
+    [k in keyof T]: k extends 'then' | 'catch' | 'finally' ? T[k] : PromiseChain<Resolved<T[k]>>;
+}> : Promise<Resolved<T>>;
+/**
+ * Transforms a promise or value into a chainable object
+ * Allows calling methods directly on promise results without awaiting them first
+ * @param given - The promise or value to make chainable
+ * @returns A chainable version of the input
+ */
+declare function chainPromise<T>(given: Promise<T> | T): PromiseChain<T>;
+
+declare abstract class AZone<T> {
+    abstract active?: T;
+    protected enter(value?: T): unknown;
+    protected leave(entered: unknown): void;
+    with<R>(value: T, fn: () => R): R;
+    root<R>(fn: () => R): R;
+    get zoned(): FunctionWrapper;
+}
+type FunctionWrapper = <R>(fn?: () => R) => R;
+declare class Zone<T> extends AZone<T> {
+    active: T | undefined;
+}
+type HistoryValue<T> = {
+    present: T | undefined;
+    history: Set<T>;
+};
+declare class ZoneHistory<T> extends AZone<HistoryValue<T>> {
+    private controlled;
+    private history;
+    readonly present: AZone<T>;
+    has(value: T): boolean;
+    some(predicate: (value: T) => boolean): boolean;
+    constructor(controlled?: AZone<T>);
+    get active(): HistoryValue<T> | undefined;
+    set active(value: HistoryValue<T> | undefined);
+}
+declare class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
+    #private;
+    constructor(...zones: AZone<unknown>[]);
+    get active(): Map<AZone<unknown>, unknown> | undefined;
+    set active(value: Map<AZone<unknown>, unknown> | undefined);
+    enter(value?: Map<AZone<unknown>, unknown> | undefined): Map<AZone<unknown>, unknown>;
+    leave(entered: Map<AZone<unknown>, unknown>): void;
+    add(z: AZone<unknown>): void;
+    delete(z: AZone<unknown>): void;
+    clear(): void;
+}
+declare const asyncZone: ZoneAggregator;
+
+/**
+ * Dependency access passed to user callbacks within effects/watch
+ * Provides functions to track dependencies and information about the effect execution
+ */
+interface DependencyAccess {
+    /**
+     * Tracks dependencies in the current effect context
+     * Use this for normal dependency tracking within the effect
+     * @example
+     * ```typescript
+     * effect(({ tracked }) => {
+     *   // In async context, use tracked to restore dependency tracking
+     *   await someAsyncOperation()
+     *   const value = tracked(() => state.count) // Tracks state.count in this effect
+     * })
+     * ```
+     */
+    tracked: FunctionWrapper;
+    /**
+     * Tracks dependencies in the parent effect context
+     * Use this when child effects should track dependencies in the parent,
+     * allowing parent cleanup to manage child effects while dependencies trigger the parent
+     * @example
+     * ```typescript
+     * effect(({ ascend }) => {
+     *   const length = inputs.length
+     *   if (length > 0) {
+     *     ascend(() => {
+     *       // Dependencies here are tracked in the parent effect
+     *       inputs.forEach(item => console.log(item))
+     *     })
+     *   }
+     * })
+     * ```
+     */
+    ascend: FunctionWrapper;
+    /**
+     * Indicates whether the effect is running as a reaction (i.e. not the first call)
+     * - `false`: First execution when the effect is created
+     * - `true`: Subsequent executions triggered by dependency changes
+     * @example
+     * ```typescript
+     * effect(({ reaction }) => {
+     *   if (!reaction) {
+     *     console.log('Effect initialized')
+     *     // Setup code that should only run once
+     *   } else {
+     *     console.log('Effect re-ran due to dependency change')
+     *     // Code that runs on every update
+     *   }
+     * })
+     * ```
+     */
+    reaction: boolean;
+}
+/**
+ * Type for effect cleanup functions
+ */
+type ScopedCallback = () => void;
+/**
+ * Async execution mode for effects
+ * - `cancel`: Cancel previous async execution when dependencies change (default)
+ * - `queue`: Queue next execution to run after current completes
+ * - `ignore`: Ignore new executions while async work is running
+ */
+type AsyncExecutionMode = 'cancel' | 'queue' | 'ignore';
+/**
+ * Options for effect creation
+ */
+interface EffectOptions {
+    /**
+     * How to handle async effect executions when dependencies change
+     * @default 'cancel'
+     */
+    asyncMode?: AsyncExecutionMode;
+    /**
+     * If true, this effect is "opaque" to deep optimizations: it sees the object reference itself
+     * and must be notified when it changes, regardless of deep content similarity.
+     * Use this for effects that depend on object identity (like memoize).
+     */
+    opaque?: boolean;
+}
+/**
+ * Type for property evolution events
+ */
+type PropEvolution = {
+    type: 'set' | 'del' | 'add' | 'invalidate';
+    prop: any;
+};
+/**
+ * Type for collection operation evolution events
+ */
+type BunchEvolution = {
+    type: 'bunch';
+    method: string;
+};
+type Evolution = PropEvolution | BunchEvolution;
+type State = {
+    evolution: Evolution;
+    next: State;
+} | {};
+/**
+ * Symbol to check if an effect is stopped
+ */
+declare const stopped: unique symbol;
+/**
+ * Symbol to access effect cleanup function
+ */
+declare const cleanup$1: unique symbol;
+/**
+ * Context for a running projection item effect
+ */
+interface ProjectionContext {
+    source: any;
+    key?: any;
+    target: any;
+    depth: number;
+    parent?: ProjectionContext;
+}
+/**
+ * Structured error codes for machine-readable diagnosis
+ */
+declare enum ReactiveErrorCode {
+    CycleDetected = "CYCLE_DETECTED",
+    MaxDepthExceeded = "MAX_DEPTH_EXCEEDED",
+    MaxReactionExceeded = "MAX_REACTION_EXCEEDED",
+    WriteInComputed = "WRITE_IN_COMPUTED",
+    TrackingError = "TRACKING_ERROR",
+    BrokenEffects = "BROKEN_EFFECTS"
+}
+type CycleDebugInfo = {
+    code: ReactiveErrorCode.CycleDetected;
+    cycle: string[];
+    details?: string;
+};
+type MaxDepthDebugInfo = {
+    code: ReactiveErrorCode.MaxDepthExceeded;
+    depth: number;
+    chain: string[];
+};
+type MaxReactionDebugInfo = {
+    code: ReactiveErrorCode.MaxReactionExceeded;
+    count: number;
+    effect: string;
+};
+type BrokenEffectsDebugInfo = {
+    code: ReactiveErrorCode.BrokenEffects;
+    cause: any;
+};
+type GenericDebugInfo = {
+    code: ReactiveErrorCode;
+    causalChain?: string[];
+    creationStack?: string;
+    [key: string]: any;
+};
+type ReactiveDebugInfo = CycleDebugInfo | MaxDepthDebugInfo | MaxReactionDebugInfo | BrokenEffectsDebugInfo | GenericDebugInfo;
+/**
+ * Error class for reactive system errors
+ */
+declare class ReactiveError extends Error {
+    debugInfo?: ReactiveDebugInfo;
+    constructor(message: string, debugInfo?: ReactiveDebugInfo);
+    get code(): ReactiveErrorCode | undefined;
+    get cause(): any;
+}
+/**
+ * Global options for the reactive system
+ */
+declare const options: {
+    /**
+     * Debug purpose: called when an effect is entered
+     * @param effect - The effect that is entered
+     */
+    enter: (_effect: Function) => void;
+    /**
+     * Debug purpose: called when an effect is left
+     * @param effect - The effect that is left
+     */
+    leave: (_effect: Function) => void;
+    /**
+     * Debug purpose: called when an effect is chained
+     * @param target - The effect that is being triggered
+     * @param caller - The effect that is calling the target
+     */
+    chain: (_targets: Function[], _caller?: Function) => void;
+    /**
+     * Debug purpose: called when an effect chain is started
+     * @param target - The effect that is being triggered
+     */
+    beginChain: (_targets: Function[]) => void;
+    /**
+     * Debug purpose: called when an effect chain is ended
+     */
+    endChain: () => void;
+    garbageCollected: (_fn: Function) => void;
+    /**
+     * Debug purpose: called when an object is touched
+     * @param obj - The object that is touched
+     * @param evolution - The type of change
+     * @param props - The properties that changed
+     * @param deps - The dependencies that changed
+     */
+    touched: (_obj: any, _evolution: Evolution, _props?: any[], _deps?: Set<ScopedCallback>) => void;
+    /**
+     * Debug purpose: called when an effect is skipped because it's already running
+     * @param effect - The effect that is already running
+     * @param runningChain - The array of effects from the detected one to the currently running one
+     */
+    skipRunningEffect: (_effect: ScopedCallback) => void;
+    /**
+     * Debug purpose: maximum effect chain (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 100
+     */
+    maxEffectChain: number;
+    /**
+     * Maximum number of times an effect can be triggered by the same cause in a single batch
+     * Used to detect aggressive re-computation or infinite loops
+     * @default 10
+     */
+    maxTriggerPerBatch: number;
+    /**
+     * Debug purpose: maximum effect reaction (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 'throw'
+     */
+    maxEffectReaction: "throw" | "debug" | "warn";
+    /**
+     * Callback called when a memoization discrepancy is detected (debug only)
+     * When defined, memoized functions will run a second time (untracked) to verify consistency.
+     * If the untracked run returns a different value than the cached one, this callback is triggered.
+     *
+     * This is the primary tool for detecting missing reactive dependencies in computed values.
+     *
+     * @param cached - The value currently in the memoization cache
+     * @param fresh - The value obtained by re-running the function untracked
+     * @param fn - The memoized function itself
+     * @param args - Arguments passed to the function
+     *
+     * @example
+     * ```typescript
+     * reactiveOptions.onMemoizationDiscrepancy = (cached, fresh, fn, args) => {
+     *   throw new Error(`Memoization discrepancy in ${fn.name}!`);
+     * };
+     * ```
+     */
+    onMemoizationDiscrepancy: ((cached: any, fresh: any, fn: Function, args: any[], cause: "calculation" | "comparison") => void) | undefined;
+    /**
+     * How to handle cycles detected in effect batches.
+     *
+     * - `'none'` (Default): High-performance mode. Disables dependency graph maintenance and
+     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
+     *   Cycle detection is heuristic (uses execution counts).
+     *
+     * - `'throw'`: Traditional Topological Sorting. Guarantees dependency order and catches
+     *   circular dependencies mathematically before execution.
+     *
+     * - `'warn'`: Topological sorting, but logs a warning instead of throwing on cycles.
+     * - `'break'`: Topological sorting, but silently breaks cycles.
+     * - `'strict'`: Prevents cycle creation by checking the graph *during* dependency discovery.
+     *
+     * @default 'none'
+     */
+    cycleHandling: "none" | "throw" | "warn" | "break" | "strict";
+    /**
+     * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
+     * @warning Do not modify this flag manually, this flag is given by the engine
+     */
+    isVerificationRun: boolean;
+    /**
+     * Maximum depth for deep watching traversal
+     * Used to prevent infinite recursion in circular references
+     * @default 100
+     */
+    maxDeepWatchDepth: number;
+    /**
+     * Only react on instance members modification (not inherited properties)
+     * For instance, do not track class methods
+     * @default true
+     */
+    instanceMembers: boolean;
+    /**
+     * Ignore accessors (getters and setters) and only track direct properties
+     * @default true
+     */
+    ignoreAccessors: boolean;
+    /**
+     * Enable recursive touching when objects with the same prototype are replaced
+     * When enabled, replacing an object with another of the same prototype triggers
+     * recursive diffing instead of notifying parent effects
+     * @default true
+     */
+    recursiveTouching: boolean;
+    /**
+     * Default async execution mode for effects that return Promises
+     * - 'cancel': Cancel previous async execution when dependencies change (default, enables async zone)
+     * - 'queue': Queue next execution to run after current completes (enables async zone)
+     * - 'ignore': Ignore new executions while async work is running (enables async zone)
+     * - false: Disable async zone and async mode handling (effects run concurrently)
+     *
+     * **When truthy:** Enables async zone (Promise.prototype wrapping) for automatic context
+     * preservation in Promise callbacks. Warning: This modifies Promise.prototype globally.
+     * Only enable if no other library modifies Promise.prototype.
+     *
+     * **When false:** Async zone is disabled. Use `tracked()` manually in Promise callbacks.
+     *
+     * Can be overridden per-effect via EffectOptions
+     * @default 'cancel'
+     */
+    asyncMode: AsyncExecutionMode | false;
+    warn: (...args: any[]) => void;
+    /**
+     * Configuration for the introspection system
+     */
+    introspection: {
+        /**
+         * Whether to keep a history of mutations for debugging
+         * @default false
+         */
+        enableHistory: boolean;
+        /**
+         * Number of mutations to keep in history
+         * @default 50
+         */
+        historySize: number;
+    };
+    /**
+     * Configuration for zone hooks - control which async APIs are hooked
+     * Each option controls whether the corresponding async API is wrapped to preserve effect context
+     * Only applies when asyncMode is enabled (truthy)
+     * @deprecated Should take all when we made sure PIXI.create, Game.create, ... are -> .root()
+     */
+    zones: {
+        /**
+         * Hook setTimeout to preserve effect context
+         * @default true
+         */
+        setTimeout: boolean;
+        /**
+         * Hook setInterval to preserve effect context
+         * @default true
+         */
+        setInterval: boolean;
+        /**
+         * Hook requestAnimationFrame (runs in untracked context when hooked)
+         * @default true
+         */
+        requestAnimationFrame: boolean;
+        /**
+         * Hook queueMicrotask to preserve effect context
+         * @default true
+         */
+        queueMicrotask: boolean;
+    };
+};
+
+/**
+ * Gets the current state of a reactive object for evolution tracking
+ * @param obj - The reactive object
+ * @returns The current state object
+ */
+declare function getState(obj: any): State;
+/**
+ * Triggers effects for a single property change
+ * @param obj - The object that changed
+ * @param evolution - The type of change
+ * @param prop - The property that changed
+ */
+declare function touched1(obj: any, evolution: Evolution, prop: any): void;
+/**
+ * Triggers effects for property changes
+ * @param obj - The object that changed
+ * @param evolution - The type of change
+ * @param props - The properties that changed
+ */
+declare function touched(obj: any, evolution: Evolution, props?: Iterable<any>): void;
+
+/**
+ * Debug utilities for the reactivity system
+ * - Captures effect metadata (names, parent relationships)
+ * - Records cause → consequence edges with object/prop labels
+ * - Provides graph data for tooling (DevTools panel, etc.)
+ */
+
+type NodeKind = 'effect' | 'external' | 'state';
+type EdgeKind = 'cause' | 'dependency' | 'trigger';
+interface EffectNode {
+    id: string;
+    label: string;
+    type: NodeKind;
+    depth: number;
+    parentId?: string;
+    debugName?: string;
+}
+interface ObjectNode {
+    id: string;
+    label: string;
+    type: NodeKind;
+    debugName?: string;
+}
+interface GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: EdgeKind;
+    label: string;
+    count?: number;
+}
+interface ReactivityGraph {
+    nodes: Array<EffectNode | ObjectNode>;
+    edges: GraphEdge[];
+    meta: {
+        generatedAt: number;
+        devtoolsEnabled: boolean;
+    };
+}
+/**
+ * Assign a debug-friendly name to an effect (shown in DevTools)
+ */
+declare function setEffectName(effect: ScopedCallback, name: string): void;
+/**
+ * Assign a debug-friendly name to a reactive object
+ */
+declare function setObjectName(obj: object, name: string): void;
+/**
+ * Register an effect so it appears in the DevTools graph
+ */
+declare function registerEffectForDebug(effect: ScopedCallback): void;
+/**
+ * Register a reactive object so it appears in the DevTools graph
+ */
+declare function registerObjectForDebug(obj: object): void;
+/**
+ * Builds a graph representing current reactive state (effects, objects, and trigger edges)
+ */
+declare function buildReactivityGraph(): ReactivityGraph;
+/**
+ * Enables the DevTools bridge and exposes the debug API on window.
+ * Call as early as possible in development builds.
+ */
+declare function enableDevTools(): void;
+declare function isDevtoolsEnabled(): boolean;
+
+/**
+ * Deep watch an object and all its nested properties
+ * @param target - The object to watch deeply
+ * @param callback - The callback to call when any nested property changes
+ * @param options - Options for the deep watch
+ * @returns A cleanup function to stop watching
+ */
+/**
+ * Sets up deep watching for an object, tracking all nested property changes
+ * @param target - The object to watch
+ * @param callback - The callback to call when changes occur
+ * @param options - Options for deep watching
+ * @returns A cleanup function to stop deep watching
+ */
+declare function deepWatch<T extends object>(target: T, callback: (value: T) => void, { immediate }?: {
+    immediate?: boolean;
+}): (() => void) | undefined;
+
+type EffectTracking = (obj: any, evolution: Evolution, prop: any) => void;
+interface ActivationRecord {
+    effect: ScopedCallback;
+    obj: any;
+    evolution: Evolution;
+    prop: any;
+    batchId: number;
+}
+declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
+/**
+ * Registers a debug callback that is called when the current effect is triggered by a dependency change
+ *
+ * This function is useful for debugging purposes as it pin-points exactly which reactive property
+ * change triggered the effect. The callback receives information about:
+ * - The object that changed
+ * - The type of change (evolution)
+ * - The specific property that changed
+ *
+ * **Note:** The tracker callback is automatically removed after being called once. If you need
+ * to track multiple triggers, call `trackEffect` again within the effect.
+ *
+ * @param onTouch - Callback function that receives (obj, evolution, prop) when the effect is triggered
+ * @throws {Error} If called outside of an effect context
+ *
+ * @example
+ * ```typescript
+ * const state = reactive({ count: 0, name: 'John' })
+ *
+ * effect(() => {
+ *   // Register a tracker to see what triggers this effect
+ *   trackEffect((obj, evolution, prop) => {
+ *     console.log(`Effect triggered by:`, {
+ *       object: obj,
+ *       change: evolution.type,
+ *       property: prop
+ *     })
+ *   })
+ *
+ *   // Access reactive properties
+ *   console.log(state.count, state.name)
+ * })
+ *
+ * state.count = 5
+ * // Logs: Effect triggered by: { object: state, change: 'set', property: 'count' }
+ * ```
+ */
+declare function trackEffect(onTouch: EffectTracking): void;
+/**
+ * Adds a cleanup function to be called when the current batch of effects completes
+ * @param cleanup - The cleanup function to add
+ */
+declare function addBatchCleanup(cleanup: ScopedCallback): void;
+/**
+ * Semantic alias for `addBatchCleanup` - defers work to the end of the current reactive batch.
+ *
+ * Use this when an effect needs to perform an action that would modify state the effect depends on,
+ * which would create a reactive cycle. The deferred callback runs after all effects complete.
+ *
+ * @param callback - The callback to defer until after the current batch completes
+ *
+ * @example
+ * ```typescript
+ * effect(() => {
+ *   processData()
+ *
+ *   // Defer to avoid cycle (createMovement modifies state this effect reads)
+ *   defer(() => {
+ *     createMovement(data)
+ *   })
+ * })
+ * ```
+ */
+declare const defer: typeof addBatchCleanup;
+/**
+ * Decorator that makes methods atomic - batches all effects triggered within the method
+ */
+declare const atomic: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & (<Args extends any[], Return>(original: (...args: Args) => Return) => (...args: Args) => Return);
+/**
+ * @param fn - The effect function to run - provides the cleaner
+ * @returns The cleanup function
+ */
+/**
+ * Creates a reactive effect that automatically re-runs when dependencies change
+ * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
+ * @param options - Options for effect execution
+ * @returns A cleanup function to stop the effect
+ */
+declare function effect(fn: (access: DependencyAccess) => ScopedCallback | undefined | void | Promise<any>, effectOptions?: EffectOptions): ScopedCallback & {
+    [stopped]: boolean;
+    [cleanup$1]: () => void;
+};
+/**
+ * Executes a function without tracking dependencies but maintains parent cleanup relationship
+ * Effects created inside will still be cleaned up when the parent effect is destroyed
+ * @param fn - The function to execute
+ */
+declare function untracked<T>(fn: () => T): T;
+/**
+ * Executes a function from a virgin/root context - no parent effect, no tracking
+ * Creates completely independent effects that won't be cleaned up by any parent
+ * @param fn - The function to execute
+ */
+declare function root<T>(fn: () => T): T;
+
+/**
+ * Creates a bidirectional binding between a reactive value and a non-reactive external value
+ * Prevents infinite loops by automatically suppressing circular notifications
+ *
+ * @param received - Function called when the reactive value changes (external setter)
+ * @param get - Getter for the reactive value OR an object with `{ get, set }` properties
+ * @param set - Setter for the reactive value (required if `get` is a function)
+ * @returns A function to manually provide updates from the external side
+ *
+ * @example
+ * ```typescript
+ * const model = reactive({ value: '' })
+ * const input = { value: '' }
+ *
+ * // Bidirectional binding
+ * const provide = biDi(
+ *   (v) => input.value = v,  // external setter
+ *   () => model.value,        // reactive getter
+ *   (v) => model.value = v    // reactive setter
+ * )
+ *
+ * // External notification (e.g., from input event)
+ * provide('new value')  // Updates model.value, doesn't trigger circular loop
+ * ```
+ *
+ * @example Using object syntax
+ * ```typescript
+ * const provide = biDi(
+ *   (v) => setHTMLValue(v),
+ *   { get: () => reactiveObj.value, set: (v) => reactiveObj.value = v }
+ * )
+ * ```
+ */
+declare function biDi<T>(received: (value: T) => void, value: {
+    get: () => T;
+    set: (value: T) => void;
+}): (value: T) => void;
+declare function biDi<T>(received: (value: T) => void, get: () => T, set: (value: T) => void): (value: T) => void;
+
+/**
+ * Symbol for accessing the cleanup function on cleaned objects
+ */
+declare const cleanup: unique symbol;
+/**
+ * Options for the watch function
+ */
+interface WatchOptions {
+    /** Whether to call the callback immediately */
+    immediate?: boolean;
+    /** Whether to watch nested properties */
+    deep?: boolean;
+}
+/**
+ * Watches a reactive value and calls a callback when it changes
+ * @param value - Function that returns the value to watch
+ * @param changed - Callback to call when the value changes
+ * @param options - Watch options
+ * @returns Cleanup function to stop watching
+ */
+declare function watch<T>(value: (dep: DependencyAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep?: false;
+}): ScopedCallback;
+/**
+ * Watches a reactive value with deep watching enabled
+ * @param value - Function that returns the value to watch
+ * @param changed - Callback to call when the value changes
+ * @param options - Watch options with deep watching enabled
+ * @returns Cleanup function to stop watching
+ */
+declare function watch<T extends object | any[]>(value: (dep: DependencyAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep: true;
+}): ScopedCallback;
+/**
+ * Watches a reactive object directly
+ * @param value - The reactive object to watch
+ * @param changed - Callback to call when the object changes
+ * @param options - Watch options
+ * @returns Cleanup function to stop watching
+ */
+declare function watch<T extends object | any[]>(value: T, changed: (value: T) => void, options?: WatchOptions): ScopedCallback;
+declare function unreactiveApplication<T extends object>(...args: (keyof T)[]): GenericClassDecorator<T>;
+declare function unreactiveApplication<T extends object>(obj: T): T;
+/**
+ * Decorator that marks classes or properties as non-reactive
+ * Prevents objects from being made reactive
+ */
+declare const unreactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof unreactiveApplication;
+declare function cleanedBy<T extends object>(obj: T, cleanupFn: ScopedCallback): T & {
+    [cleanup]: ScopedCallback;
+};
+/**
+ * Creates a derived value that automatically recomputes when dependencies change
+ * @param compute - Function that computes the derived value
+ * @returns Object with value and cleanup function
+ */
+declare function derived<T>(compute: (dep: DependencyAccess) => T): {
+    value: T;
+    [cleanup]: ScopedCallback;
+};
+
+type Memoizable = object | any[] | symbol | ((...args: any[]) => any);
+declare function memoizeFunction<Result, Args extends Memoizable[]>(fn: (...args: Args) => Result): (...args: Args) => Result;
+declare const memoize: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & typeof memoizeFunction;
+
+declare const immutables: Set<(tested: any) => boolean>;
+declare function isNonReactive(obj: any): boolean;
+declare function registerNativeReactivity(originalClass: new (...args: any[]) => any, reactiveClass: new (...args: any[]) => any): void;
+
+type KeyFunction<T, K extends PropertyKey> = (item: T) => K;
+interface RegisterInstance<T> extends ArrayReadForward<T> {
+    [index: number]: T;
+}
+declare const RegisterClass_base: new () => ArrayReadForward<any> & {
+    [x: number]: any;
+    toArray(): any[];
+};
+declare class RegisterClass<T, K extends PropertyKey = PropertyKey> extends RegisterClass_base implements RegisterInstance<T> {
+    #private;
+    protected get [forwardArray](): readonly T[];
+    constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>);
+    private ensureKey;
+    private assertValidKey;
+    private setKeyValue;
+    private cleanupValue;
+    private disposeKeyEffects;
+    private incrementUsage;
+    private decrementUsage;
+    private normalizeIndex;
+    private assignAt;
+    private insertKeyValue;
+    private rebuildFrom;
+    get length(): number;
+    [getAt](index: number): T | undefined;
+    [setAt](index: number, value: T): void;
+    push(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    unshift(...items: T[]): number;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    clear(): void;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    remove(key: K): void;
+    removeAt(index: number): T | undefined;
+    /**
+     * Keep only the items for which the predicate returns true.
+     * Items for which the predicate returns false are removed.
+     *
+     * The predicate is evaluated once per distinct key; duplicate keys
+     * will follow the same keep/remove decision.
+     */
+    keep(predicate: (value: T) => boolean): void;
+    hasKey(key: K): boolean;
+    indexOfKey(key: K): number;
+    mapKeys(): IterableIterator<K>;
+    update(...values: T[]): void;
+    upsert(insert: (value: T) => void, ...values: T[]): void;
+    entries(): IterableIterator<[number, T]>;
+    [Symbol.iterator](): IterableIterator<T>;
+    toString(): string;
+    at(index: number): T | undefined;
+    reverse(): this;
+    sort(compareFn?: ((a: T, b: T) => number) | undefined): this;
+    fill(value: T, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
+}
+type Register<T, K extends PropertyKey = PropertyKey> = RegisterClass<T, K> & T[];
+declare const Register: new <T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>) => Register<T, K>;
+declare function register<T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>): Register<T, K>;
+
+/**
+ * Returns the projection context of the currently running effect, if any.
+ */
+declare function getActiveProjection(): ProjectionContext | undefined;
+type ProjectOldValue<Target> = Target extends readonly (infer Item)[] ? Item : Target extends Map<any, infer Item> ? Item : Target extends Record<PropertyKey, infer Item> ? Item : unknown;
+type ProjectAccess<SourceValue, Key, SourceType, Target> = {
+    readonly key: Key;
+    get(): SourceValue;
+    set(value: SourceValue): boolean;
+    readonly source: SourceType;
+    readonly old?: ProjectOldValue<Target>;
+    value: SourceValue;
+};
+type ProjectCallback<SourceValue, Key, Target extends object, SourceType, Result> = (access: ProjectAccess<SourceValue, Key, SourceType, Target>, target: Target) => Result;
+type ProjectResult<Target extends object> = Target & {
+    [cleanup]: ScopedCallback;
+};
+declare function projectArray<SourceValue, ResultValue>(source: readonly SourceValue[], apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>): ProjectResult<ResultValue[]>;
+declare function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(source: Register<SourceValue, Key>, apply: ProjectCallback<SourceValue, Key, Map<Key, ResultValue>, Register<SourceValue, Key>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+declare function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(source: Source, apply: ProjectCallback<Source[keyof Source], keyof Source, Record<keyof Source, ResultValue>, Source, ResultValue>): ProjectResult<Record<keyof Source, ResultValue>>;
+declare function projectMap<Key, Value, ResultValue>(source: Map<Key, Value>, apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+type ProjectOverload = {
+    <SourceValue, ResultValue>(source: readonly SourceValue[], apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>): ProjectResult<ResultValue[]>;
+    <Key extends PropertyKey, SourceValue, ResultValue>(source: Register<SourceValue, Key>, apply: ProjectCallback<SourceValue, Key, Map<Key, ResultValue>, Register<SourceValue, Key>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+    <Source extends Record<PropertyKey, any>, ResultValue>(source: Source, apply: ProjectCallback<Source[keyof Source], keyof Source, Record<keyof Source, ResultValue>, Source, ResultValue>): ProjectResult<Record<keyof Source, ResultValue>>;
+    <Key, Value, ResultValue>(source: Map<Key, Value>, apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+    array: typeof projectArray;
+    register: typeof projectRegister;
+    record: typeof projectRecord;
+    map: typeof projectMap;
+};
+declare const project: ProjectOverload;
+
+declare function unwrap<T>(obj: T): T;
+declare function isReactive(obj: any): boolean;
+
+/**
+ * Base mixin for reactive classes that provides proper constructor reactivity
+ * Solves constructor reactivity issues in complex inheritance trees
+ */
+declare const ReactiveBase: (new (...args: any[]) => {
+    [x: string]: any;
+}) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => {
+    [x: string]: any;
+} & Base);
+declare function reactiveObject<T>(anyTarget: T): T;
+/**
+ * Main decorator for making classes reactive
+ * Automatically makes class instances reactive when created
+ */
+declare const reactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
+
+/**
+ * Provides type-safe access to a source object's property within the organized callback.
+ * @template Source - The type of the source object
+ * @template Key - The type of the property key in the source object
+ */
+type OrganizedAccess<Source extends Record<PropertyKey, any>, Key extends keyof Source> = {
+    /** The property key being accessed */
+    readonly key: Key;
+    /**
+     * Gets the current value of the property from the source object
+     * @returns The current value of the property
+     */
+    get(): Source[Key];
+    /**
+     * Updates the property value in the source object
+     * @param value - The new value to set
+     * @returns {boolean} True if the update was successful
+     */
+    set(value: Source[Key]): boolean;
+    /**
+     * The current value of the property (equivalent to using get()/set() directly)
+     */
+    value: Source[Key];
+};
+/**
+ * Callback function type for the organized function that processes each source property.
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object
+ */
+type OrganizedCallback<Source extends Record<PropertyKey, any>, Target extends object> = <Key extends keyof Source>(
+/**
+ * Accessor object for the current source property
+ */
+access: OrganizedAccess<Source, Key>, 
+/**
+ * The target object where organized data will be stored
+ */
+target: Target) => ScopedCallback | undefined;
+/**
+ * The result type of the organized function, combining the target object with cleanup capability.
+ * @template Target - The type of the target object
+ */
+type OrganizedResult<Target extends object> = Target & {
+    /**
+     * Cleanup function to dispose of all reactive bindings created by organized().
+     * This is automatically called when the effect that created the organized binding is disposed.
+     */
+    [cleanup]: ScopedCallback;
+};
+/**
+ * Organizes a source object's properties into a target object using a callback function.
+ * This creates a reactive mapping between source properties and a target object,
+ * automatically handling property additions, updates, and removals.
+ *
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
+ *
+ * @param {Source} source - The source object to organize
+ * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
+ * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
+ *
+ * @returns {OrganizedResult<Target>} The target object with cleanup capability
+ *
+ * @example
+ * // Organize user permissions into role-based access
+ * const user = reactive({ isAdmin: true, canEdit: false });
+ * const permissions = organized(
+ *   user,
+ *   (access, target) => {
+ *     if (access.key === 'isAdmin') {
+ *       target.hasFullAccess = access.value;
+ *     }
+ *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
+ *   }
+ * );
+ *
+ * @example
+ * // Transform object structure with cleanup
+ * const source = reactive({ firstName: 'John', lastName: 'Doe' });
+ * const formatted = organized(
+ *   source,
+ *   (access, target) => {
+ *     if (access.key === 'firstName' || access.key === 'lastName') {
+ *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
+ *     }
+ *   }
+ * );
+ *
+ * @example
+ * // Using with cleanup in a component
+ * effect(() => {
+ *   const data = fetchData();
+ *   const organizedData = organized(data, (access, target) => {
+ *     // Transform data
+ *   });
+ *
+ *   // The cleanup will be called automatically when the effect is disposed
+ *   return () => organizedData[cleanup]();
+ * });
+ */
+declare function organized<Source extends Record<PropertyKey, any>, Target extends object = Record<PropertyKey, any>>(source: Source, apply: OrganizedCallback<Source, Target>, baseTarget?: Target): OrganizedResult<Target>;
+/**
+ * Organizes a property on a target object
+ * Shortcut for defineProperty/delete with touched signal
+ * @param target - The target object
+ * @param property - The property to organize
+ * @param access - The access object
+ * @returns The property descriptor
+ */
+declare function organize<T>(target: object, property: PropertyKey, access: {
+    get?(): T;
+    set?(value: T): boolean;
+}): () => boolean;
+
+/**
+ * Result of a reactive scan, which is a reactive array of accumulated values
+ * with an attached cleanup function.
+ */
+type ScanResult<Output> = readonly Output[] & {
+    [cleanup]: ScopedCallback;
+};
+/**
+ * Perform a reactive scan over an array of items.
+ *
+ * This implementation is highly optimized for performance and fine-grained reactivity:
+ * - **Incremental Updates**: Changes to an item only trigger re-computation from that
+ *   point onwards in the result chain.
+ * - **Move Optimization**: If items are moved within the array, their accumulated
+ *   values are reused as long as their predecessor remains the same.
+ * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
+ *   instance using an internal occurrence tracking mechanism.
+ * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
+ *   automatically cleared when source items are garbage collected.
+ *
+ * @example
+ * ```typescript
+ * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
+ * const sum = scan(source, (acc, item) => acc + item.val, 0)
+ *
+ * expect([...sum]).toEqual([1, 3, 6])
+ *
+ * // Modifying an item only re-computes subsequent sums
+ * source[1].val = 10
+ * expect([...sum]).toEqual([1, 11, 14])
+ * ```
+ *
+ * @param source The source array of objects (will be made reactive)
+ * @param callback The accumulator function called with (accumulator, currentItem)
+ * @param initialValue The starting value for the accumulation
+ * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
+ */
+declare function scan<Input extends object, Output>(source: readonly Input[], callback: (acc: Output, val: Input) => Output, initialValue: Output): ScanResult<Output>;
+declare function resolve<Output>(cb: () => Output[]): Output[] & {
+    [cleanup]: ScopedCallback;
+};
+
+declare const effectAggregator: ZoneAggregator;
+declare function getActiveEffect(): ScopedCallback;
+
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+declare const profileInfo: any;
+
+/**
+ * Decorator that caches the result of a getter method and only recomputes when dependencies change
+ * Prevents circular dependencies and provides automatic cache invalidation
+ */
+declare const cached: LegacyPropertyDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any>;
+/**
+ * Checks if a property is cached (has a cached value)
+ * @param object - The object to check
+ * @param propertyKey - The property key to check
+ * @returns True if the property has a cached value
+ */
+declare function isCached(object: Object, propertyKey: PropertyKey): boolean;
+/**
+ * Caches a value for a property on an object
+ * @param object - The object to cache the value on
+ * @param propertyKey - The property key to cache
+ * @param value - The value to cache
+ */
+declare function cache(object: Object, propertyKey: PropertyKey, value: any): void;
+/**
+ * Creates a decorator that modifies property descriptors for specified properties
+ * @param descriptor - The descriptor properties to apply
+ * @returns A class decorator that applies the descriptor to specified properties
+ */
+declare function describe(descriptor: {
+    enumerable?: boolean;
+    configurable?: boolean;
+    writable?: boolean;
+}): <T>(...properties: (keyof T)[]) => GenericClassDecorator<T>;
+/**
+ * Decorator that marks methods, properties, or classes as deprecated
+ * Provides warning messages when deprecated items are used
+ */
+declare const deprecated: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & ModernSetterDecorator<any> & ((message: string) => LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & ModernSetterDecorator<any>) & {
+    warn: (target: any, propertyKey: PropertyKey, message?: string) => void;
+};
+/**
+ * Creates a debounced method decorator that delays execution until after the delay period has passed
+ * @param delay - The delay in milliseconds
+ * @returns A method decorator that debounces method calls
+ */
+declare function debounce(delay: number): LegacyPropertyDecorator<any> & ModernMethodDecorator<any>;
+/**
+ * Creates a throttled method decorator that limits execution to once per delay period
+ * @param delay - The delay in milliseconds
+ * @returns A method decorator that throttles method calls
+ */
+declare function throttle(delay: number): LegacyPropertyDecorator<any> & ModernMethodDecorator<any>;
+
+type ElementTypes<T extends readonly unknown[]> = {
+    [K in keyof T]: T[K] extends readonly (infer U)[] ? U : T[K];
+};
+/**
+ * Combines multiple arrays into an array of tuples, stopping at the shortest array length
+ * @param args - Arrays to zip together
+ * @returns Array of tuples containing elements from each input array
+ */
+declare function zip<T extends (readonly unknown[])[]>(...args: T): ElementTypes<T>[];
+/**
+ * Checks if two arrays are strictly equal (shallow comparison)
+ * @param a - First value
+ * @param b - Second value
+ * @returns True if arrays are equal or values are strictly equal
+ */
+declare function arrayEquals(a: any, b: any): boolean;
+/**
+ * Checks if a function is a constructor (class or constructor function)
+ * @param fn - The function to check
+ * @returns True if the function is a constructor
+ */
+declare function isConstructor(fn: Function): boolean;
+/**
+ * Renames a function with a new name
+ * @param fct - The function to rename
+ * @param name - The new name for the function
+ * @returns The function with the new name
+ */
+declare function renamed<F extends Function>(fct: F, name: string): F;
+declare const FoolProof: {
+    get(obj: any, prop: any, receiver: any): any;
+    set(obj: any, prop: any, value: any, receiver: any): boolean;
+};
+declare function isOwnAccessor(obj: any, prop: any): boolean;
+/**
+ * Deeply compares two values.
+ * For objects, compares prototypes with === and then own properties recursively.
+ * Uses a cache to handle circular references.
+ * @param a - First value
+ * @param b - Second value
+ * @param cache - Map for circular reference protection (internal use)
+ * @returns True if values are deeply equal
+ */
+declare function deepCompare(a: any, b: any, cache?: Map<object, Set<object>>): boolean;
+declare function contentRef(container: object): any;
+declare function tag<T extends object>(name: string, obj: T): T;
+declare function named<T extends Function>(name: string, fn: T): T;
+
+type Restorer = () => () => void;
+type Hook = () => Restorer;
+declare const asyncHooks: {
+    addHook(_hook: Hook): () => void;
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p: any): any;
+};
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+declare const asyncHook: (hook: Hook) => () => void;
+
+export { AZone, ArrayReadForward, DecoratorError, Destroyable, DestructionError, Eventful, FoolProof, Indexable, IterableWeakMap, IterableWeakSet, ReactiveBase, ReactiveError, ReactiveErrorCode, Register, Zone, ZoneAggregator, ZoneHistory, addBatchCleanup, allocated, allocatedValues, arrayEquals, asyncHook, asyncHooks, asyncZone, atomic, biDi, buildReactivityGraph, cache, cached, callOnGC, chainPromise, cleanedBy, cleanup, contentRef, debounce, decorator, deepCompare, deepWatch, defer, deprecated, derived, describe, destructor, effect, effectAggregator, enableDevTools, forwardArray, getActivationLog, getActiveEffect, getActiveProjection, getAt, getState, immutables, isCached, isConstructor, isDevtoolsEnabled, isNonReactive, isOwnAccessor, isReactive, legacyDecorator, memoize, mixin, modernDecorator, named, organize, organized, profileInfo, project, reactive, options as reactiveOptions, register, registerEffectForDebug, registerNativeReactivity, registerObjectForDebug, renamed, resolve, root, scan, setAt, setEffectName, setObjectName, tag, throttle, touched, touched1, trackEffect, unreactive, untracked, unwrap, watch, zip };
+export type { ContextManager, Decorator, DecoratorDescription, DecoratorFactory, DependencyAccess, EventsBase, Evolution, FunctionWrapper, GenericClassDecorator, Hook, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactivityGraph, Restorer, ScanResult, ScopedCallback };