mobx 6.10.2 → 6.11.0

package/dist/core/globalstate.d.ts

@@ -1,121 +1,121 @@
-import { IDerivation, IObservable, Reaction } from "../internal";
-import { ComputedValue } from "./computedvalue";
-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;
-    /**
-     * Currently running reaction. This determines if we currently have a reactive context.
-     * (Tracking derivation is also set for temporal tracking of computed values inside actions,
-     * but trackingReaction can only be set by a form of Reaction)
-     */
-    trackingContext: Reaction | ComputedValue<any> | null;
-    /**
-     * 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;
-    /**
-     * ID of the latest batch. Used to suppress reportChanged of newly created atoms.
-     * Note the value persists even after batch ended.
-     */
-    batchId: 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 | "always";
-    /**
-     * 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;
-    disableErrorBoundaries: boolean;
-    suppressReactionErrors: boolean;
-    useProxies: boolean;
-    verifyProxies: boolean;
-    /**
-     * False forces all object's descriptors to
-     * writable: true
-     * configurable: true
-     */
-    safeDescriptors: boolean;
-    /**
-     * Changes with each state update, used by useSyncExternalStore
-     */
-    stateVersion: number;
-}
-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";
+import { ComputedValue } from "./computedvalue";
+export 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;
+    /**
+     * Currently running reaction. This determines if we currently have a reactive context.
+     * (Tracking derivation is also set for temporal tracking of computed values inside actions,
+     * but trackingReaction can only be set by a form of Reaction)
+     */
+    trackingContext: Reaction | ComputedValue<any> | null;
+    /**
+     * 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;
+    /**
+     * ID of the latest batch. Used to suppress reportChanged of newly created atoms.
+     * Note the value persists even after batch ended.
+     */
+    batchId: 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 | "always";
+    /**
+     * 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;
+    disableErrorBoundaries: boolean;
+    suppressReactionErrors: boolean;
+    useProxies: boolean;
+    verifyProxies: boolean;
+    /**
+     * False forces all object's descriptors to
+     * writable: true
+     * configurable: true
+     */
+    safeDescriptors: boolean;
+    /**
+     * Changes with each state update, used by useSyncExternalStore
+     */
+    stateVersion: number;
+}
+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/dist/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>;
-    onBUO(): void;
-    onBO(): void;
-    onBUOL: Set<Lambda> | undefined;
-    onBOL: 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>;
+    onBUO(): void;
+    onBO(): void;
+    onBUOL: Set<Lambda> | undefined;
+    onBOL: 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/dist/core/reaction.d.ts

@@ -1,62 +1,62 @@
-import { IDerivation, IDerivationState_, IObservable, Lambda, TraceMode, GenericAbortSignal } 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_?: any;
-    observing_: IObservable[];
-    newObserving_: IObservable[];
-    dependenciesState_: IDerivationState_;
-    diffValue_: number;
-    runId_: number;
-    unboundDepsCount_: number;
-    isDisposed_: boolean;
-    isScheduled_: boolean;
-    isTrackPending_: boolean;
-    isRunning_: boolean;
-    isTracing_: TraceMode;
-    constructor(name_: string, onInvalidate_: () => void, errorHandler_?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable_?: any);
-    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_(abortSignal?: GenericAbortSignal): 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, GenericAbortSignal } 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_?: any;
+    observing_: IObservable[];
+    newObserving_: IObservable[];
+    dependenciesState_: IDerivationState_;
+    diffValue_: number;
+    runId_: number;
+    unboundDepsCount_: number;
+    isDisposed_: boolean;
+    isScheduled_: boolean;
+    isTrackPending_: boolean;
+    isRunning_: boolean;
+    isTracing_: TraceMode;
+    constructor(name_: string, onInvalidate_: () => void, errorHandler_?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable_?: any);
+    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_(abortSignal?: GenericAbortSignal): 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/dist/core/spy.d.ts

@@ -1,37 +1,37 @@
-import { IComputedDidChange } from "./computedvalue";
-import { IValueDidChange, IBoxDidChange } from "./../types/observablevalue";
-import { IObjectDidChange } from "./../types/observableobject";
-import { IArrayDidChange } from "./../types/observablearray";
-import { Lambda, ISetDidChange, IMapDidChange } from "../internal";
-export declare function isSpyEnabled(): boolean;
-export declare type PureSpyEvent = {
-    type: "action";
-    name: string;
-    object: unknown;
-    arguments: unknown[];
-} | {
-    type: "scheduled-reaction";
-    name: string;
-} | {
-    type: "reaction";
-    name: string;
-} | {
-    type: "error";
-    name: string;
-    message: string;
-    error: string;
-} | IComputedDidChange<unknown> | IObjectDidChange<unknown> | IArrayDidChange<unknown> | IMapDidChange<unknown, unknown> | ISetDidChange<unknown> | IValueDidChange<unknown> | IBoxDidChange<unknown> | {
-    type: "report-end";
-    spyReportEnd: true;
-    time?: number;
-};
-declare type SpyEvent = PureSpyEvent & {
-    spyReportStart?: true;
-};
-export declare function spyReport(event: SpyEvent): void;
-export declare function spyReportStart(event: PureSpyEvent): void;
-export declare function spyReportEnd(change?: {
-    time?: number;
-}): void;
-export declare function spy(listener: (change: SpyEvent) => void): Lambda;
-export {};
+import { IComputedDidChange } from "./computedvalue";
+import { IValueDidChange, IBoxDidChange } from "./../types/observablevalue";
+import { IObjectDidChange } from "./../types/observableobject";
+import { IArrayDidChange } from "./../types/observablearray";
+import { Lambda, ISetDidChange, IMapDidChange } from "../internal";
+export declare function isSpyEnabled(): boolean;
+export type PureSpyEvent = {
+    type: "action";
+    name: string;
+    object: unknown;
+    arguments: unknown[];
+} | {
+    type: "scheduled-reaction";
+    name: string;
+} | {
+    type: "reaction";
+    name: string;
+} | {
+    type: "error";
+    name: string;
+    message: string;
+    error: string;
+} | IComputedDidChange<unknown> | IObjectDidChange<unknown> | IArrayDidChange<unknown> | IMapDidChange<unknown, unknown> | ISetDidChange<unknown> | IValueDidChange<unknown> | IBoxDidChange<unknown> | {
+    type: "report-end";
+    spyReportEnd: true;
+    time?: number;
+};
+type SpyEvent = PureSpyEvent & {
+    spyReportStart?: true;
+};
+export declare function spyReport(event: SpyEvent): void;
+export declare function spyReportStart(event: PureSpyEvent): void;
+export declare function spyReportEnd(change?: {
+    time?: number;
+}): void;
+export declare function spy(listener: (change: SpyEvent) => void): Lambda;
+export {};

package/dist/errors.d.ts

@@ -1,42 +1,42 @@
-declare const niceErrors: {
-    readonly 0: "Invalid value for configuration 'enforceActions', expected 'never', 'always' or 'observed'";
-    readonly 1: (annotationType: any, key: PropertyKey) => string;
-    readonly 5: "'keys()' can only be used on observable objects, arrays, sets and maps";
-    readonly 6: "'values()' can only be used on observable objects, arrays, sets and maps";
-    readonly 7: "'entries()' can only be used on observable objects, arrays and maps";
-    readonly 8: "'set()' can only be used on observable objects, arrays and maps";
-    readonly 9: "'remove()' can only be used on observable objects, arrays and maps";
-    readonly 10: "'has()' can only be used on observable objects, arrays and maps";
-    readonly 11: "'get()' can only be used on observable objects, arrays and maps";
-    readonly 12: "Invalid annotation";
-    readonly 13: "Dynamic observable objects cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)";
-    readonly 14: "Intercept handlers should return nothing or a change object";
-    readonly 15: "Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)";
-    readonly 16: "Modification exception: the internal structure of an observable array was changed.";
-    readonly 17: (index: any, length: any) => string;
-    readonly 18: "mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js";
-    readonly 19: (other: any) => string;
-    readonly 20: (other: any) => string;
-    readonly 21: (dataStructure: any) => string;
-    readonly 22: "mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js";
-    readonly 23: "It is not possible to get index atoms from arrays";
-    readonly 24: (thing: any) => string;
-    readonly 25: (property: any, name: any) => string;
-    readonly 26: "please specify a property";
-    readonly 27: (property: any, name: any) => string;
-    readonly 28: (thing: any) => string;
-    readonly 29: "Expecting some object";
-    readonly 30: "invalid action stack. did you forget to finish an action?";
-    readonly 31: "missing option for computed: get";
-    readonly 32: (name: any, derivation: any) => string;
-    readonly 33: (name: any) => string;
-    readonly 34: (name: any) => string;
-    readonly 35: "There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`";
-    readonly 36: "isolateGlobalState should be called before MobX is running any reactions";
-    readonly 37: (method: any) => string;
-    readonly 38: "'ownKeys()' can only be used on observable objects";
-    readonly 39: "'defineProperty()' can only be used on observable objects";
-};
-declare const errors: typeof niceErrors;
-export declare function die(error: string | keyof typeof errors, ...args: any[]): never;
-export {};
+declare const niceErrors: {
+    readonly 0: "Invalid value for configuration 'enforceActions', expected 'never', 'always' or 'observed'";
+    readonly 1: (annotationType: any, key: PropertyKey) => string;
+    readonly 5: "'keys()' can only be used on observable objects, arrays, sets and maps";
+    readonly 6: "'values()' can only be used on observable objects, arrays, sets and maps";
+    readonly 7: "'entries()' can only be used on observable objects, arrays and maps";
+    readonly 8: "'set()' can only be used on observable objects, arrays and maps";
+    readonly 9: "'remove()' can only be used on observable objects, arrays and maps";
+    readonly 10: "'has()' can only be used on observable objects, arrays and maps";
+    readonly 11: "'get()' can only be used on observable objects, arrays and maps";
+    readonly 12: "Invalid annotation";
+    readonly 13: "Dynamic observable objects cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)";
+    readonly 14: "Intercept handlers should return nothing or a change object";
+    readonly 15: "Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)";
+    readonly 16: "Modification exception: the internal structure of an observable array was changed.";
+    readonly 17: (index: any, length: any) => string;
+    readonly 18: "mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js";
+    readonly 19: (other: any) => string;
+    readonly 20: (other: any) => string;
+    readonly 21: (dataStructure: any) => string;
+    readonly 22: "mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js";
+    readonly 23: "It is not possible to get index atoms from arrays";
+    readonly 24: (thing: any) => string;
+    readonly 25: (property: any, name: any) => string;
+    readonly 26: "please specify a property";
+    readonly 27: (property: any, name: any) => string;
+    readonly 28: (thing: any) => string;
+    readonly 29: "Expecting some object";
+    readonly 30: "invalid action stack. did you forget to finish an action?";
+    readonly 31: "missing option for computed: get";
+    readonly 32: (name: any, derivation: any) => string;
+    readonly 33: (name: any) => string;
+    readonly 34: (name: any) => string;
+    readonly 35: "There are multiple, different versions of MobX active. Make sure MobX is loaded only once or use `configure({ isolateGlobalState: true })`";
+    readonly 36: "isolateGlobalState should be called before MobX is running any reactions";
+    readonly 37: (method: any) => string;
+    readonly 38: "'ownKeys()' can only be used on observable objects";
+    readonly 39: "'defineProperty()' can only be used on observable objects";
+};
+declare const errors: typeof niceErrors;
+export declare function die(error: string | keyof typeof errors, ...args: any[]): never;
+export {};