mobx 5.15.3 → 5.15.7

package/lib/core/globalstate.d.ts

@@ -1,107 +1,107 @@
-import { IDerivation, IObservable, Reaction } from "../internal";
-export declare type IUNCHANGED = {};
-export declare class MobXGlobals {
-    /**
-     * MobXGlobals version.
-     * MobX compatiblity with other versions loaded in memory as long as this version matches.
-     * It indicates that the global state still stores similar information
-     *
-     * N.B: this version is unrelated to the package version of MobX, and is only the version of the
-     * internal state storage of MobX, and can be the same across many different package versions
-     */
-    version: number;
-    /**
-     * globally unique token to signal unchanged
-     */
-    UNCHANGED: IUNCHANGED;
-    /**
-     * Currently running derivation
-     */
-    trackingDerivation: IDerivation | null;
-    /**
-     * Are we running a computation currently? (not a reaction)
-     */
-    computationDepth: number;
-    /**
-     * Each time a derivation is tracked, it is assigned a unique run-id
-     */
-    runId: number;
-    /**
-     * 'guid' for general purpose. Will be persisted amongst resets.
-     */
-    mobxGuid: number;
-    /**
-     * Are we in a batch block? (and how many of them)
-     */
-    inBatch: number;
-    /**
-     * Observables that don't have observers anymore, and are about to be
-     * suspended, unless somebody else accesses it in the same batch
-     *
-     * @type {IObservable[]}
-     */
-    pendingUnobservations: IObservable[];
-    /**
-     * List of scheduled, not yet executed, reactions.
-     */
-    pendingReactions: Reaction[];
-    /**
-     * Are we currently processing reactions?
-     */
-    isRunningReactions: boolean;
-    /**
-     * Is it allowed to change observables at this point?
-     * In general, MobX doesn't allow that when running computations and React.render.
-     * To ensure that those functions stay pure.
-     */
-    allowStateChanges: boolean;
-    /**
-     * Is it allowed to read observables at this point?
-     * Used to hold the state needed for `observableRequiresReaction`
-     */
-    allowStateReads: boolean;
-    /**
-     * If strict mode is enabled, state changes are by default not allowed
-     */
-    enforceActions: boolean | "strict";
-    /**
-     * Spy callbacks
-     */
-    spyListeners: {
-        (change: any): void;
-    }[];
-    /**
-     * Globally attached error handlers that react specifically to errors in reactions
-     */
-    globalReactionErrorHandlers: ((error: any, derivation: IDerivation) => void)[];
-    /**
-     * Warn if computed values are accessed outside a reactive context
-     */
-    computedRequiresReaction: boolean;
-    /**
-     * (Experimental)
-     * Warn if you try to create to derivation / reactive context without accessing any observable.
-     */
-    reactionRequiresObservable: boolean;
-    /**
-     * (Experimental)
-     * Warn if observables are accessed outside a reactive context
-     */
-    observableRequiresReaction: boolean;
-    /**
-     * Allows overwriting of computed properties, useful in tests but not prod as it can cause
-     * memory leaks. See https://github.com/mobxjs/mobx/issues/1867
-     */
-    computedConfigurable: boolean;
-    disableErrorBoundaries: boolean;
-    suppressReactionErrors: boolean;
-}
-export declare function getGlobal(): any;
-export declare let globalState: MobXGlobals;
-export declare function isolateGlobalState(): void;
-export declare function getGlobalState(): any;
-/**
- * For testing purposes only; this will break the internal state of existing observables,
- * but can be used to get back at a stable state after throwing errors
- */
-export declare function resetGlobalState(): void;
+import { IDerivation, IObservable, Reaction } from "../internal";
+export declare type IUNCHANGED = {};
+export declare class MobXGlobals {
+    /**
+     * MobXGlobals version.
+     * MobX compatiblity with other versions loaded in memory as long as this version matches.
+     * It indicates that the global state still stores similar information
+     *
+     * N.B: this version is unrelated to the package version of MobX, and is only the version of the
+     * internal state storage of MobX, and can be the same across many different package versions
+     */
+    version: number;
+    /**
+     * globally unique token to signal unchanged
+     */
+    UNCHANGED: IUNCHANGED;
+    /**
+     * Currently running derivation
+     */
+    trackingDerivation: IDerivation | null;
+    /**
+     * Are we running a computation currently? (not a reaction)
+     */
+    computationDepth: number;
+    /**
+     * Each time a derivation is tracked, it is assigned a unique run-id
+     */
+    runId: number;
+    /**
+     * 'guid' for general purpose. Will be persisted amongst resets.
+     */
+    mobxGuid: number;
+    /**
+     * Are we in a batch block? (and how many of them)
+     */
+    inBatch: number;
+    /**
+     * Observables that don't have observers anymore, and are about to be
+     * suspended, unless somebody else accesses it in the same batch
+     *
+     * @type {IObservable[]}
+     */
+    pendingUnobservations: IObservable[];
+    /**
+     * List of scheduled, not yet executed, reactions.
+     */
+    pendingReactions: Reaction[];
+    /**
+     * Are we currently processing reactions?
+     */
+    isRunningReactions: boolean;
+    /**
+     * Is it allowed to change observables at this point?
+     * In general, MobX doesn't allow that when running computations and React.render.
+     * To ensure that those functions stay pure.
+     */
+    allowStateChanges: boolean;
+    /**
+     * Is it allowed to read observables at this point?
+     * Used to hold the state needed for `observableRequiresReaction`
+     */
+    allowStateReads: boolean;
+    /**
+     * If strict mode is enabled, state changes are by default not allowed
+     */
+    enforceActions: boolean | "strict";
+    /**
+     * Spy callbacks
+     */
+    spyListeners: {
+        (change: any): void;
+    }[];
+    /**
+     * Globally attached error handlers that react specifically to errors in reactions
+     */
+    globalReactionErrorHandlers: ((error: any, derivation: IDerivation) => void)[];
+    /**
+     * Warn if computed values are accessed outside a reactive context
+     */
+    computedRequiresReaction: boolean;
+    /**
+     * (Experimental)
+     * Warn if you try to create to derivation / reactive context without accessing any observable.
+     */
+    reactionRequiresObservable: boolean;
+    /**
+     * (Experimental)
+     * Warn if observables are accessed outside a reactive context
+     */
+    observableRequiresReaction: boolean;
+    /**
+     * Allows overwriting of computed properties, useful in tests but not prod as it can cause
+     * memory leaks. See https://github.com/mobxjs/mobx/issues/1867
+     */
+    computedConfigurable: boolean;
+    disableErrorBoundaries: boolean;
+    suppressReactionErrors: boolean;
+}
+export declare function getGlobal(): any;
+export declare let globalState: MobXGlobals;
+export declare function isolateGlobalState(): void;
+export declare function getGlobalState(): any;
+/**
+ * For testing purposes only; this will break the internal state of existing observables,
+ * but can be used to get back at a stable state after throwing errors
+ */
+export declare function resetGlobalState(): void;

package/lib/core/observable.d.ts

@@ -1,45 +1,45 @@
-import { Lambda, IDerivation, IDerivationState } from "../internal";
-export interface IDepTreeNode {
-    name: string;
-    observing?: IObservable[];
-}
-export interface IObservable extends IDepTreeNode {
-    diffValue: number;
-    /**
-     * Id of the derivation *run* that last accessed this observable.
-     * If this id equals the *run* id of the current derivation,
-     * the dependency is already established
-     */
-    lastAccessedBy: number;
-    isBeingObserved: boolean;
-    lowestObserverState: IDerivationState;
-    isPendingUnobservation: boolean;
-    observers: Set<IDerivation>;
-    onBecomeUnobserved(): void;
-    onBecomeObserved(): void;
-    onBecomeUnobservedListeners: Set<Lambda> | undefined;
-    onBecomeObservedListeners: Set<Lambda> | undefined;
-}
-export declare function hasObservers(observable: IObservable): boolean;
-export declare function getObservers(observable: IObservable): Set<IDerivation>;
-export declare function addObserver(observable: IObservable, node: IDerivation): void;
-export declare function removeObserver(observable: IObservable, node: IDerivation): void;
-export declare function queueForUnobservation(observable: IObservable): void;
-/**
- * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.
- * During a batch `onBecomeUnobserved` will be called at most once per observable.
- * Avoids unnecessary recalculations.
- */
-export declare function startBatch(): void;
-export declare function endBatch(): void;
-export declare function reportObserved(observable: IObservable): boolean;
-/**
- * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly
- * It will propagate changes to observers from previous run
- * It's hard or maybe impossible (with reasonable perf) to get it right with current approach
- * Hopefully self reruning autoruns aren't a feature people should depend on
- * Also most basic use cases should be ok
- */
-export declare function propagateChanged(observable: IObservable): void;
-export declare function propagateChangeConfirmed(observable: IObservable): void;
-export declare function propagateMaybeChanged(observable: IObservable): void;
+import { Lambda, IDerivation, IDerivationState } from "../internal";
+export interface IDepTreeNode {
+    name: string;
+    observing?: IObservable[];
+}
+export interface IObservable extends IDepTreeNode {
+    diffValue: number;
+    /**
+     * Id of the derivation *run* that last accessed this observable.
+     * If this id equals the *run* id of the current derivation,
+     * the dependency is already established
+     */
+    lastAccessedBy: number;
+    isBeingObserved: boolean;
+    lowestObserverState: IDerivationState;
+    isPendingUnobservation: boolean;
+    observers: Set<IDerivation>;
+    onBecomeUnobserved(): void;
+    onBecomeObserved(): void;
+    onBecomeUnobservedListeners: Set<Lambda> | undefined;
+    onBecomeObservedListeners: Set<Lambda> | undefined;
+}
+export declare function hasObservers(observable: IObservable): boolean;
+export declare function getObservers(observable: IObservable): Set<IDerivation>;
+export declare function addObserver(observable: IObservable, node: IDerivation): void;
+export declare function removeObserver(observable: IObservable, node: IDerivation): void;
+export declare function queueForUnobservation(observable: IObservable): void;
+/**
+ * Batch starts a transaction, at least for purposes of memoizing ComputedValues when nothing else does.
+ * During a batch `onBecomeUnobserved` will be called at most once per observable.
+ * Avoids unnecessary recalculations.
+ */
+export declare function startBatch(): void;
+export declare function endBatch(): void;
+export declare function reportObserved(observable: IObservable): boolean;
+/**
+ * NOTE: current propagation mechanism will in case of self reruning autoruns behave unexpectedly
+ * It will propagate changes to observers from previous run
+ * It's hard or maybe impossible (with reasonable perf) to get it right with current approach
+ * Hopefully self reruning autoruns aren't a feature people should depend on
+ * Also most basic use cases should be ok
+ */
+export declare function propagateChanged(observable: IObservable): void;
+export declare function propagateChangeConfirmed(observable: IObservable): void;
+export declare function propagateMaybeChanged(observable: IObservable): void;

package/lib/core/reaction.d.ts

@@ -1,63 +1,63 @@
-import { IDerivation, IDerivationState, IObservable, Lambda, TraceMode } from "../internal";
-/**
- * Reactions are a special kind of derivations. Several things distinguishes them from normal reactive computations
- *
- * 1) They will always run, whether they are used by other computations or not.
- * This means that they are very suitable for triggering side effects like logging, updating the DOM and making network requests.
- * 2) They are not observable themselves
- * 3) They will always run after any 'normal' derivations
- * 4) They are allowed to change the state and thereby triggering themselves again, as long as they make sure the state propagates to a stable state in a reasonable amount of iterations.
- *
- * The state machine of a Reaction is as follows:
- *
- * 1) after creating, the reaction should be started by calling `runReaction` or by scheduling it (see also `autorun`)
- * 2) the `onInvalidate` handler should somehow result in a call to `this.track(someFunction)`
- * 3) all observables accessed in `someFunction` will be observed by this reaction.
- * 4) as soon as some of the dependencies has changed the Reaction will be rescheduled for another run (after the current mutation or transaction). `isScheduled` will yield true once a dependency is stale and during this period
- * 5) `onInvalidate` will be called, and we are back at step 1.
- *
- */
-export interface IReactionPublic {
-    dispose(): void;
-    trace(enterBreakPoint?: boolean): void;
-}
-export interface IReactionDisposer {
-    (): void;
-    $mobx: Reaction;
-}
-export declare class Reaction implements IDerivation, IReactionPublic {
-    name: string;
-    private onInvalidate;
-    private errorHandler?;
-    requiresObservable: boolean;
-    observing: IObservable[];
-    newObserving: IObservable[];
-    dependenciesState: IDerivationState;
-    diffValue: number;
-    runId: number;
-    unboundDepsCount: number;
-    __mapid: string;
-    isDisposed: boolean;
-    _isScheduled: boolean;
-    _isTrackPending: boolean;
-    _isRunning: boolean;
-    isTracing: TraceMode;
-    constructor(name: string, onInvalidate: () => void, errorHandler?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable?: boolean);
-    onBecomeStale(): void;
-    schedule(): void;
-    isScheduled(): boolean;
-    /**
-     * internal, use schedule() if you intend to kick off a reaction
-     */
-    runReaction(): void;
-    track(fn: () => void): void;
-    reportExceptionInDerivation(error: any): void;
-    dispose(): void;
-    getDisposer(): IReactionDisposer;
-    toString(): string;
-    trace(enterBreakPoint?: boolean): void;
-}
-export declare function onReactionError(handler: (error: any, derivation: IDerivation) => void): Lambda;
-export declare function runReactions(): void;
-export declare const isReaction: (x: any) => x is Reaction;
-export declare function setReactionScheduler(fn: (f: () => void) => void): void;
+import { IDerivation, IDerivationState, IObservable, Lambda, TraceMode } from "../internal";
+/**
+ * Reactions are a special kind of derivations. Several things distinguishes them from normal reactive computations
+ *
+ * 1) They will always run, whether they are used by other computations or not.
+ * This means that they are very suitable for triggering side effects like logging, updating the DOM and making network requests.
+ * 2) They are not observable themselves
+ * 3) They will always run after any 'normal' derivations
+ * 4) They are allowed to change the state and thereby triggering themselves again, as long as they make sure the state propagates to a stable state in a reasonable amount of iterations.
+ *
+ * The state machine of a Reaction is as follows:
+ *
+ * 1) after creating, the reaction should be started by calling `runReaction` or by scheduling it (see also `autorun`)
+ * 2) the `onInvalidate` handler should somehow result in a call to `this.track(someFunction)`
+ * 3) all observables accessed in `someFunction` will be observed by this reaction.
+ * 4) as soon as some of the dependencies has changed the Reaction will be rescheduled for another run (after the current mutation or transaction). `isScheduled` will yield true once a dependency is stale and during this period
+ * 5) `onInvalidate` will be called, and we are back at step 1.
+ *
+ */
+export interface IReactionPublic {
+    dispose(): void;
+    trace(enterBreakPoint?: boolean): void;
+}
+export interface IReactionDisposer {
+    (): void;
+    $mobx: Reaction;
+}
+export declare class Reaction implements IDerivation, IReactionPublic {
+    name: string;
+    private onInvalidate;
+    private errorHandler?;
+    requiresObservable: boolean;
+    observing: IObservable[];
+    newObserving: IObservable[];
+    dependenciesState: IDerivationState;
+    diffValue: number;
+    runId: number;
+    unboundDepsCount: number;
+    __mapid: string;
+    isDisposed: boolean;
+    _isScheduled: boolean;
+    _isTrackPending: boolean;
+    _isRunning: boolean;
+    isTracing: TraceMode;
+    constructor(name: string, onInvalidate: () => void, errorHandler?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable?: boolean);
+    onBecomeStale(): void;
+    schedule(): void;
+    isScheduled(): boolean;
+    /**
+     * internal, use schedule() if you intend to kick off a reaction
+     */
+    runReaction(): void;
+    track(fn: () => void): void;
+    reportExceptionInDerivation(error: any): void;
+    dispose(): void;
+    getDisposer(): IReactionDisposer;
+    toString(): string;
+    trace(enterBreakPoint?: boolean): void;
+}
+export declare function onReactionError(handler: (error: any, derivation: IDerivation) => void): Lambda;
+export declare function runReactions(): void;
+export declare const isReaction: (x: any) => x is Reaction;
+export declare function setReactionScheduler(fn: (f: () => void) => void): void;

package/lib/core/spy.d.ts

@@ -1,6 +1,6 @@
-import { Lambda } from "../internal";
-export declare function isSpyEnabled(): boolean;
-export declare function spyReport(event: any): void;
-export declare function spyReportStart(event: any): void;
-export declare function spyReportEnd(change?: any): void;
-export declare function spy(listener: (change: any) => void): Lambda;
+import { Lambda } from "../internal";
+export declare function isSpyEnabled(): boolean;
+export declare function spyReport(event: any): void;
+export declare function spyReportStart(event: any): void;
+export declare function spyReportEnd(change?: any): void;
+export declare function spy(listener: (change: any) => void): Lambda;

package/lib/index.js

@@ -0,0 +1,7 @@
+
+if (typeof process !== 'undefined' && process.env.NODE_ENV === 'production') {
+    module.exports = require('./mobx.min.js');
+} else {
+    module.exports = require('./mobx.js');
+}
+        

package/lib/internal.d.ts

@@ -1,45 +1,45 @@
-export * from "./utils/utils";
-export * from "./core/atom";
-export * from "./utils/comparer";
-export * from "./utils/decorators";
-export * from "./types/modifiers";
-export * from "./api/observabledecorator";
-export * from "./api/observable";
-export * from "./api/computed";
-export * from "./core/action";
-export * from "./types/observablevalue";
-export * from "./core/computedvalue";
-export * from "./core/derivation";
-export * from "./core/globalstate";
-export * from "./core/observable";
-export * from "./core/reaction";
-export * from "./core/spy";
-export * from "./api/actiondecorator";
-export * from "./api/action";
-export * from "./api/autorun";
-export * from "./api/become-observed";
-export * from "./api/configure";
-export * from "./api/decorate";
-export * from "./api/extendobservable";
-export * from "./api/extras";
-export * from "./api/flow";
-export * from "./api/intercept-read";
-export * from "./api/intercept";
-export * from "./api/iscomputed";
-export * from "./api/isobservable";
-export * from "./api/object-api";
-export * from "./api/observe";
-export * from "./api/tojs";
-export * from "./api/trace";
-export * from "./api/transaction";
-export * from "./api/when";
-export * from "./types/dynamicobject";
-export * from "./types/intercept-utils";
-export * from "./types/listen-utils";
-export * from "./types/observablearray";
-export * from "./types/observablemap";
-export * from "./types/observableset";
-export * from "./types/observableobject";
-export * from "./types/type-utils";
-export * from "./utils/eq";
-export * from "./utils/iterable";
+export * from "./utils/utils";
+export * from "./core/atom";
+export * from "./utils/comparer";
+export * from "./utils/decorators";
+export * from "./types/modifiers";
+export * from "./api/observabledecorator";
+export * from "./api/observable";
+export * from "./api/computed";
+export * from "./core/action";
+export * from "./types/observablevalue";
+export * from "./core/computedvalue";
+export * from "./core/derivation";
+export * from "./core/globalstate";
+export * from "./core/observable";
+export * from "./core/reaction";
+export * from "./core/spy";
+export * from "./api/actiondecorator";
+export * from "./api/action";
+export * from "./api/autorun";
+export * from "./api/become-observed";
+export * from "./api/configure";
+export * from "./api/decorate";
+export * from "./api/extendobservable";
+export * from "./api/extras";
+export * from "./api/flow";
+export * from "./api/intercept-read";
+export * from "./api/intercept";
+export * from "./api/iscomputed";
+export * from "./api/isobservable";
+export * from "./api/object-api";
+export * from "./api/observe";
+export * from "./api/tojs";
+export * from "./api/trace";
+export * from "./api/transaction";
+export * from "./api/when";
+export * from "./types/dynamicobject";
+export * from "./types/intercept-utils";
+export * from "./types/listen-utils";
+export * from "./types/observablearray";
+export * from "./types/observablemap";
+export * from "./types/observableset";
+export * from "./types/observableobject";
+export * from "./types/type-utils";
+export * from "./utils/eq";
+export * from "./utils/iterable";

package/lib/mobx.d.ts

@@ -1,18 +1,18 @@
-/**
- * (c) Michel Weststrate 2015 - 2018
- * MIT Licensed
- *
- * Welcome to the mobx sources! To get an global overview of how MobX internally works,
- * this is a good place to start:
- * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
- *
- * Source folders:
- * ===============
- *
- * - api/     Most of the public static methods exposed by the module can be found here.
- * - core/    Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.
- * - types/   All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.
- * - utils/   Utility stuff.
- *
- */
-export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, IDerivation, untracked, IDerivationState, IAtom, createAtom, IAction, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, IObservableObject, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, FlowCancellationError, isFlowCancellationError, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, Lambda, isArrayLike, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd } from "./internal";
+/**
+ * (c) Michel Weststrate 2015 - 2018
+ * MIT Licensed
+ *
+ * Welcome to the mobx sources! To get an global overview of how MobX internally works,
+ * this is a good place to start:
+ * https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
+ *
+ * Source folders:
+ * ===============
+ *
+ * - api/     Most of the public static methods exposed by the module can be found here.
+ * - core/    Implementation of the MobX algorithm; atoms, derivations, reactions, dependency trees, optimizations. Cool stuff can be found here.
+ * - types/   All the magic that is need to have observable objects, arrays and values is in this folder. Including the modifiers like `asFlat`.
+ * - utils/   Utility stuff.
+ *
+ */
+export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, IDerivation, untracked, IDerivationState, IAtom, createAtom, IAction, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, IObservableObject, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArrayChange, IArraySplice, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, IObservableFactories, computed, IComputed, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, decorate, configure, onBecomeObserved, onBecomeUnobserved, flow, FlowCancellationError, isFlowCancellationError, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, allowStateChangesInsideComputed as _allowStateChangesInsideComputed, Lambda, isArrayLike, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd } from "./internal";