mobx 4.15.3 → 4.15.7

package/lib/api/observable.d.ts

@@ -1,54 +1,54 @@
-import { IEqualsComparer, IObservableDecorator, IEnhancer, IObservableArray, ObservableMap, IObservableObject, IObservableValue, IObservableSetInitialValues, ObservableSet, IObservableMapInitialValues } from "../internal";
-export declare type CreateObservableOptions = {
-    name?: string;
-    equals?: IEqualsComparer<any>;
-    deep?: boolean;
-    defaultDecorator?: IObservableDecorator;
-};
-export declare const defaultCreateObservableOptions: CreateObservableOptions;
-export declare const shallowCreateObservableOptions: {
-    deep: boolean;
-    name: undefined;
-    defaultDecorator: undefined;
-};
-export declare function asCreateObservableOptions(thing: any): CreateObservableOptions;
-export declare const deepDecorator: IObservableDecorator;
-export declare const refDecorator: IObservableDecorator;
-export interface IObservableFactory {
-    (value: number | string | null | undefined | boolean): never;
-    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): any;
-    <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>;
-    <T = any>(value: Set<T>, options?: CreateObservableOptions): ObservableSet<T>;
-    <K = any, V = any>(value: Map<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
-    <T extends Object>(value: T, decorators?: {
-        [K in keyof T]?: Function;
-    }, options?: CreateObservableOptions): T & IObservableObject;
-}
-export interface IObservableFactories {
-    box<T = any>(value?: T, options?: CreateObservableOptions): IObservableValue<T>;
-    shallowBox<T = any>(value?: T, options?: CreateObservableOptions): IObservableValue<T>;
-    array<T = any>(initialValues?: T[], options?: CreateObservableOptions): IObservableArray<T>;
-    shallowArray<T = any>(initialValues?: T[], options?: CreateObservableOptions): IObservableArray<T>;
-    set<T = any>(initialValues?: IObservableSetInitialValues<T>, options?: CreateObservableOptions): ObservableSet<T>;
-    map<K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
-    shallowMap<K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
-    object<T = any>(props: T, decorators?: {
-        [K in keyof T]?: Function;
-    }, options?: CreateObservableOptions): T & IObservableObject;
-    shallowObject<T = any>(props: T, decorators?: {
-        [K in keyof T]?: Function;
-    }, options?: CreateObservableOptions): T & IObservableObject;
-    /**
-     * Decorator that creates an observable that only observes the references, but doesn't try to turn the assigned value into an observable.ts.
-     */
-    ref: IObservableDecorator;
-    /**
-     * Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure
-     */
-    shallow: IObservableDecorator;
-    deep: IObservableDecorator;
-    struct: IObservableDecorator;
-}
-export declare const observable: IObservableFactory & IObservableFactories & {
-    enhancer: IEnhancer<any>;
-};
+import { IEqualsComparer, IObservableDecorator, IEnhancer, IObservableArray, ObservableMap, IObservableObject, IObservableValue, IObservableSetInitialValues, ObservableSet, IObservableMapInitialValues } from "../internal";
+export declare type CreateObservableOptions = {
+    name?: string;
+    equals?: IEqualsComparer<any>;
+    deep?: boolean;
+    defaultDecorator?: IObservableDecorator;
+};
+export declare const defaultCreateObservableOptions: CreateObservableOptions;
+export declare const shallowCreateObservableOptions: {
+    deep: boolean;
+    name: undefined;
+    defaultDecorator: undefined;
+};
+export declare function asCreateObservableOptions(thing: any): CreateObservableOptions;
+export declare const deepDecorator: IObservableDecorator;
+export declare const refDecorator: IObservableDecorator;
+export interface IObservableFactory {
+    (value: number | string | null | undefined | boolean): never;
+    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): any;
+    <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>;
+    <T = any>(value: Set<T>, options?: CreateObservableOptions): ObservableSet<T>;
+    <K = any, V = any>(value: Map<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
+    <T extends Object>(value: T, decorators?: {
+        [K in keyof T]?: Function;
+    }, options?: CreateObservableOptions): T & IObservableObject;
+}
+export interface IObservableFactories {
+    box: <T = any>(value?: T, options?: CreateObservableOptions) => IObservableValue<T>;
+    shallowBox: <T = any>(value?: T, options?: CreateObservableOptions) => IObservableValue<T>;
+    array: <T = any>(initialValues?: T[], options?: CreateObservableOptions) => IObservableArray<T>;
+    shallowArray: <T = any>(initialValues?: T[], options?: CreateObservableOptions) => IObservableArray<T>;
+    set: <T = any>(initialValues?: IObservableSetInitialValues<T>, options?: CreateObservableOptions) => ObservableSet<T>;
+    map: <K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions) => ObservableMap<K, V>;
+    shallowMap: <K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions) => ObservableMap<K, V>;
+    object: <T = any>(props: T, decorators?: {
+        [K in keyof T]?: Function;
+    }, options?: CreateObservableOptions) => T & IObservableObject;
+    shallowObject: <T = any>(props: T, decorators?: {
+        [K in keyof T]?: Function;
+    }, options?: CreateObservableOptions) => T & IObservableObject;
+    /**
+     * Decorator that creates an observable that only observes the references, but doesn't try to turn the assigned value into an observable.ts.
+     */
+    ref: IObservableDecorator;
+    /**
+     * Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure
+     */
+    shallow: IObservableDecorator;
+    deep: IObservableDecorator;
+    struct: IObservableDecorator;
+}
+export declare const observable: IObservableFactory & IObservableFactories & {
+    enhancer: IEnhancer<any>;
+};

package/lib/api/observabledecorator.d.ts

@@ -1,6 +1,6 @@
-import { IEnhancer } from "../internal";
-export declare type IObservableDecorator = {
-    (target: Object, property: string | symbol, descriptor?: PropertyDescriptor): void;
-    enhancer: IEnhancer<any>;
-};
-export declare function createDecoratorForEnhancer(enhancer: IEnhancer<any>): IObservableDecorator;
+import { IEnhancer } from "../internal";
+export declare type IObservableDecorator = {
+    (target: Object, property: string | symbol, descriptor?: PropertyDescriptor): void;
+    enhancer: IEnhancer<any>;
+};
+export declare function createDecoratorForEnhancer(enhancer: IEnhancer<any>): IObservableDecorator;

package/lib/api/observe.d.ts

@@ -1,8 +1,8 @@
-import { IObservableArray, IArrayChange, IArraySplice, IObservableValue, IComputedValue, IValueDidChange, Lambda, ObservableSet, ISetDidChange, ObservableMap, IMapDidChange, IObjectDidChange } from "../internal";
-export declare function observe<T>(value: IObservableValue<T> | IComputedValue<T>, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<T>(observableArray: IObservableArray<T>, listener: (change: IArrayChange<T> | IArraySplice<T>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<V>(observableMap: ObservableSet<V>, listener: (change: ISetDidChange<V>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<K, V>(observableMap: ObservableMap<K, V>, listener: (change: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<K, V>(observableMap: ObservableMap<K, V>, property: K, listener: (change: IValueDidChange<V>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe(object: Object, listener: (change: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<T, K extends keyof T>(object: T, property: K, listener: (change: IValueDidChange<T[K]>) => void, fireImmediately?: boolean): Lambda;
+import { IObservableArray, IArrayChange, IArraySplice, IObservableValue, IComputedValue, IValueDidChange, Lambda, ObservableSet, ISetDidChange, ObservableMap, IMapDidChange, IObjectDidChange } from "../internal";
+export declare function observe<T>(value: IObservableValue<T> | IComputedValue<T>, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<T>(observableArray: IObservableArray<T>, listener: (change: IArrayChange<T> | IArraySplice<T>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<V>(observableMap: ObservableSet<V>, listener: (change: ISetDidChange<V>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<K, V>(observableMap: ObservableMap<K, V>, listener: (change: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<K, V>(observableMap: ObservableMap<K, V>, property: K, listener: (change: IValueDidChange<V>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe(object: Object, listener: (change: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<T, K extends keyof T>(object: T, property: K, listener: (change: IValueDidChange<T[K]>) => void, fireImmediately?: boolean): Lambda;

package/lib/api/tojs.d.ts

@@ -1,11 +1,11 @@
-export declare type ToJSOptions = {
-    detectCycles?: boolean;
-    exportMapsAsObjects?: boolean;
-    recurseEverything?: boolean;
-};
-/**
- * Basically, a deep clone, so that no reactive property will exist anymore.
- */
-export declare function toJS<T>(source: T, options?: ToJSOptions): T;
-export declare function toJS(source: any, options?: ToJSOptions): any;
-export declare function toJS(source: any, options: ToJSOptions): any;
+export declare type ToJSOptions = {
+    detectCycles?: boolean;
+    exportMapsAsObjects?: boolean;
+    recurseEverything?: boolean;
+};
+/**
+ * Basically, a deep clone, so that no reactive property will exist anymore.
+ */
+export declare function toJS<T>(source: T, options?: ToJSOptions): T;
+export declare function toJS(source: any, options?: ToJSOptions): any;
+export declare function toJS(source: any, options: ToJSOptions): any;

package/lib/api/trace.d.ts

@@ -1,3 +1,3 @@
-export declare function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): void;
-export declare function trace(thing?: any, enterBreakPoint?: boolean): void;
-export declare function trace(enterBreakPoint?: boolean): void;
+export declare function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): void;
+export declare function trace(thing?: any, enterBreakPoint?: boolean): void;
+export declare function trace(enterBreakPoint?: boolean): void;

package/lib/api/transaction.d.ts

@@ -1,8 +1,8 @@
-/**
- * During a transaction no views are updated until the end of the transaction.
- * The transaction will be run synchronously nonetheless.
- *
- * @param action a function that updates some reactive state
- * @returns any value that was returned by the 'action' parameter.
- */
-export declare function transaction<T>(action: () => T, thisArg?: undefined): T;
+/**
+ * During a transaction no views are updated until the end of the transaction.
+ * The transaction will be run synchronously nonetheless.
+ *
+ * @param action a function that updates some reactive state
+ * @returns any value that was returned by the 'action' parameter.
+ */
+export declare function transaction<T>(action: () => T, thisArg?: undefined): T;

package/lib/api/when.d.ts

@@ -1,15 +1,15 @@
-import { Lambda, IReactionDisposer } from "../internal";
-export interface IWhenOptions {
-    name?: string;
-    timeout?: number;
-    /**
-     * Experimental.
-     * Warns if the view doesn't track observables
-     */
-    requiresObservable?: boolean;
-    onError?: (error: any) => void;
-}
-export declare function when(predicate: () => boolean, opts?: IWhenOptions): Promise<void> & {
-    cancel(): void;
-};
-export declare function when(predicate: () => boolean, effect: Lambda, opts?: IWhenOptions): IReactionDisposer;
+import { Lambda, IReactionDisposer } from "../internal";
+export interface IWhenOptions {
+    name?: string;
+    timeout?: number;
+    /**
+     * Experimental.
+     * Warns if the view doesn't track observables
+     */
+    requiresObservable?: boolean;
+    onError?: (error: any) => void;
+}
+export declare function when(predicate: () => boolean, opts?: IWhenOptions): Promise<void> & {
+    cancel(): void;
+};
+export declare function when(predicate: () => boolean, effect: Lambda, opts?: IWhenOptions): IReactionDisposer;

package/lib/core/action.d.ts

@@ -1,22 +1,22 @@
-import { IDerivation } from "../internal";
-export interface IAction {
-    isMobxAction: boolean;
-}
-export declare function createAction(actionName: string, fn: Function): Function & IAction;
-export declare function executeAction(actionName: string, fn: Function, scope?: any, args?: IArguments): any;
-export interface IActionRunInfo {
-    prevDerivation: IDerivation | null;
-    prevAllowStateChanges: boolean;
-    prevAllowStateReads: boolean;
-    notifySpy: boolean;
-    startTime: number;
-    error?: any;
-    parentActionId: number;
-    actionId: number;
-}
-export declare function _startAction(actionName: string, scope: any, args?: IArguments): IActionRunInfo;
-export declare function _endAction(runInfo: IActionRunInfo): void;
-export declare function allowStateChanges<T>(allowStateChanges: boolean, func: () => T): T;
-export declare function allowStateChangesStart(allowStateChanges: boolean): boolean;
-export declare function allowStateChangesEnd(prev: boolean): void;
-export declare function allowStateChangesInsideComputed<T>(func: () => T): T;
+import { IDerivation } from "../internal";
+export interface IAction {
+    isMobxAction: boolean;
+}
+export declare function createAction(actionName: string, fn: Function): Function & IAction;
+export declare function executeAction(actionName: string, fn: Function, scope?: any, args?: IArguments): any;
+export interface IActionRunInfo {
+    prevDerivation: IDerivation | null;
+    prevAllowStateChanges: boolean;
+    prevAllowStateReads: boolean;
+    notifySpy: boolean;
+    startTime: number;
+    error?: any;
+    parentActionId: number;
+    actionId: number;
+}
+export declare function _startAction(actionName: string, scope: any, args?: IArguments): IActionRunInfo;
+export declare function _endAction(runInfo: IActionRunInfo): void;
+export declare function allowStateChanges<T>(allowStateChanges: boolean, func: () => T): T;
+export declare function allowStateChangesStart(allowStateChanges: boolean): boolean;
+export declare function allowStateChangesEnd(prev: boolean): void;
+export declare function allowStateChangesInsideComputed<T>(func: () => T): T;

package/lib/core/atom.d.ts

@@ -1,40 +1,40 @@
-import { IObservable, IDerivationState } from "../internal";
-export interface IAtom extends IObservable {
-    reportObserved(): any;
-    reportChanged(): any;
-}
-/**
- * Anything that can be used to _store_ state is an Atom in mobx. Atoms have two important jobs
- *
- * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used
- * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.
- */
-export declare class Atom implements IAtom {
-    name: string;
-    isPendingUnobservation: boolean;
-    isBeingObserved: boolean;
-    observers: never[];
-    observersIndexes: {};
-    diffValue: number;
-    lastAccessedBy: number;
-    lowestObserverState: IDerivationState;
-    /**
-     * Create a new atom. For debugging purposes it is recommended to give it a name.
-     * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
-     */
-    constructor(name?: string);
-    onBecomeUnobserved(): void;
-    onBecomeObserved(): void;
-    /**
-     * Invoke this method to notify mobx that your atom has been used somehow.
-     * Returns true if there is currently a reactive context.
-     */
-    reportObserved(): boolean;
-    /**
-     * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.
-     */
-    reportChanged(): void;
-    toString(): string;
-}
-export declare const isAtom: (x: any) => x is Atom;
-export declare function createAtom(name: string, onBecomeObservedHandler?: () => void, onBecomeUnobservedHandler?: () => void): IAtom;
+import { IObservable, IDerivationState } from "../internal";
+export interface IAtom extends IObservable {
+    reportObserved(): any;
+    reportChanged(): any;
+}
+/**
+ * Anything that can be used to _store_ state is an Atom in mobx. Atoms have two important jobs
+ *
+ * 1) detect when they are being _used_ and report this (using reportObserved). This allows mobx to make the connection between running functions and the data they used
+ * 2) they should notify mobx whenever they have _changed_. This way mobx can re-run any functions (derivations) that are using this atom.
+ */
+export declare class Atom implements IAtom {
+    name: string;
+    isPendingUnobservation: boolean;
+    isBeingObserved: boolean;
+    observers: never[];
+    observersIndexes: {};
+    diffValue: number;
+    lastAccessedBy: number;
+    lowestObserverState: IDerivationState;
+    /**
+     * Create a new atom. For debugging purposes it is recommended to give it a name.
+     * The onBecomeObserved and onBecomeUnobserved callbacks can be used for resource management.
+     */
+    constructor(name?: string);
+    onBecomeUnobserved(): void;
+    onBecomeObserved(): void;
+    /**
+     * Invoke this method to notify mobx that your atom has been used somehow.
+     * Returns true if there is currently a reactive context.
+     */
+    reportObserved(): boolean;
+    /**
+     * Invoke this method _after_ this method has changed to signal mobx that all its observers should invalidate.
+     */
+    reportChanged(): void;
+    toString(): string;
+}
+export declare const isAtom: (x: any) => x is Atom;
+export declare function createAtom(name: string, onBecomeObservedHandler?: () => void, onBecomeUnobservedHandler?: () => void): IAtom;

package/lib/core/computedvalue.d.ts

@@ -1,93 +1,93 @@
-import { IObservable, IValueDidChange, Lambda, IEqualsComparer, IDerivation, IDerivationState, CaughtException, TraceMode } from "../internal";
-export interface IComputedValue<T> {
-    get(): T;
-    set(value: T): void;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-}
-export interface IComputedValueOptions<T> {
-    get?: () => T;
-    set?: (value: T) => void;
-    name?: string;
-    equals?: IEqualsComparer<T>;
-    context?: any;
-    requiresReaction?: boolean;
-    keepAlive?: boolean;
-}
-/**
- * A node in the state dependency root that observes other nodes, and can be observed itself.
- *
- * ComputedValue will remember the result of the computation for the duration of the batch, or
- * while being observed.
- *
- * During this time it will recompute only when one of its direct dependencies changed,
- * but only when it is being accessed with `ComputedValue.get()`.
- *
- * Implementation description:
- * 1. First time it's being accessed it will compute and remember result
- *    give back remembered result until 2. happens
- * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.
- * 3. When it's being accessed, recompute if any shallow dependency changed.
- *    if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.
- *    go to step 2. either way
- *
- * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
- */
-export declare class ComputedValue<T> implements IObservable, IComputedValue<T>, IDerivation {
-    dependenciesState: IDerivationState;
-    observing: IObservable[];
-    newObserving: null;
-    isBeingObserved: boolean;
-    isPendingUnobservation: boolean;
-    observers: never[];
-    observersIndexes: {};
-    diffValue: number;
-    runId: number;
-    lastAccessedBy: number;
-    lowestObserverState: IDerivationState;
-    unboundDepsCount: number;
-    __mapid: string;
-    protected value: T | undefined | CaughtException;
-    name: string;
-    triggeredBy?: string;
-    isComputing: boolean;
-    isRunningSetter: boolean;
-    derivation: () => T;
-    setter?: (value: T) => void;
-    isTracing: TraceMode;
-    scope: Object | undefined;
-    private equals;
-    private requiresReaction;
-    private keepAlive;
-    /**
-     * Create a new computed value based on a function expression.
-     *
-     * The `name` property is for debug purposes only.
-     *
-     * The `equals` property specifies the comparer function to use to determine if a newly produced
-     * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`
-     * compares based on identity comparison (===), and `structualComparer` deeply compares the structure.
-     * Structural comparison can be convenient if you always produce a new aggregated object and
-     * don't want to notify observers if it is structurally the same.
-     * This is useful for working with vectors, mouse coordinates etc.
-     */
-    constructor(options: IComputedValueOptions<T>);
-    onBecomeStale(): void;
-    onBecomeUnobserved(): void;
-    onBecomeObserved(): void;
-    /**
-     * Returns the current value of this computed value.
-     * Will evaluate its computation first if needed.
-     */
-    get(): T;
-    peek(): T;
-    set(value: T): void;
-    private trackAndCompute;
-    computeValue(track: boolean): T | CaughtException;
-    suspend(): void;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-    warnAboutUntrackedRead(): void;
-    toJSON(): T;
-    toString(): string;
-    valueOf(): T;
-}
-export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;
+import { IObservable, IValueDidChange, Lambda, IEqualsComparer, IDerivation, IDerivationState, CaughtException, TraceMode } from "../internal";
+export interface IComputedValue<T> {
+    get(): T;
+    set(value: T): void;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+}
+export interface IComputedValueOptions<T> {
+    get?: () => T;
+    set?: (value: T) => void;
+    name?: string;
+    equals?: IEqualsComparer<T>;
+    context?: any;
+    requiresReaction?: boolean;
+    keepAlive?: boolean;
+}
+/**
+ * A node in the state dependency root that observes other nodes, and can be observed itself.
+ *
+ * ComputedValue will remember the result of the computation for the duration of the batch, or
+ * while being observed.
+ *
+ * During this time it will recompute only when one of its direct dependencies changed,
+ * but only when it is being accessed with `ComputedValue.get()`.
+ *
+ * Implementation description:
+ * 1. First time it's being accessed it will compute and remember result
+ *    give back remembered result until 2. happens
+ * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.
+ * 3. When it's being accessed, recompute if any shallow dependency changed.
+ *    if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.
+ *    go to step 2. either way
+ *
+ * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
+ */
+export declare class ComputedValue<T> implements IObservable, IComputedValue<T>, IDerivation {
+    dependenciesState: IDerivationState;
+    observing: IObservable[];
+    newObserving: null;
+    isBeingObserved: boolean;
+    isPendingUnobservation: boolean;
+    observers: never[];
+    observersIndexes: {};
+    diffValue: number;
+    runId: number;
+    lastAccessedBy: number;
+    lowestObserverState: IDerivationState;
+    unboundDepsCount: number;
+    __mapid: string;
+    protected value: T | undefined | CaughtException;
+    name: string;
+    triggeredBy?: string;
+    isComputing: boolean;
+    isRunningSetter: boolean;
+    derivation: () => T;
+    setter?: (value: T) => void;
+    isTracing: TraceMode;
+    scope: Object | undefined;
+    private equals;
+    private requiresReaction;
+    private keepAlive;
+    /**
+     * Create a new computed value based on a function expression.
+     *
+     * The `name` property is for debug purposes only.
+     *
+     * The `equals` property specifies the comparer function to use to determine if a newly produced
+     * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`
+     * compares based on identity comparison (===), and `structualComparer` deeply compares the structure.
+     * Structural comparison can be convenient if you always produce a new aggregated object and
+     * don't want to notify observers if it is structurally the same.
+     * This is useful for working with vectors, mouse coordinates etc.
+     */
+    constructor(options: IComputedValueOptions<T>);
+    onBecomeStale(): void;
+    onBecomeUnobserved(): void;
+    onBecomeObserved(): void;
+    /**
+     * Returns the current value of this computed value.
+     * Will evaluate its computation first if needed.
+     */
+    get(): T;
+    peek(): T;
+    set(value: T): void;
+    private trackAndCompute;
+    computeValue(track: boolean): T | CaughtException;
+    suspend(): void;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+    warnAboutUntrackedRead(): void;
+    toJSON(): T;
+    toString(): string;
+    valueOf(): T;
+}
+export declare const isComputedValue: (x: any) => x is ComputedValue<unknown>;