mobx 4.15.3 → 4.15.7

package/lib/types/observablemap.d.ts

@@ -1,83 +1,83 @@
-import { Lambda, IInterceptable, IListenable, IEnhancer, IInterceptor } from "../internal";
-export interface IKeyValueMap<V = any> {
-    [key: string]: V;
-}
-export declare type IMapEntry<K = any, V = any> = [K, V];
-export declare type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];
-export declare type IMapDidChange<K = any, V = any> = {
-    object: ObservableMap<K, V>;
-    name: K;
-    type: "update";
-    newValue: V;
-    oldValue: V;
-} | {
-    object: ObservableMap<K, V>;
-    name: K;
-    type: "add";
-    newValue: V;
-} | {
-    object: ObservableMap<K, V>;
-    name: K;
-    type: "delete";
-    oldValue: V;
-};
-export interface IMapWillChange<K = any, V = any> {
-    object: ObservableMap<K, V>;
-    type: "update" | "add" | "delete";
-    name: K;
-    newValue?: V;
-}
-export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
-export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
-    enhancer: IEnhancer<V>;
-    name: string;
-    $mobx: {};
-    private _data;
-    private _hasMap;
-    private _keys;
-    interceptors: any;
-    changeListeners: any;
-    dehancer: any;
-    [Symbol.iterator]: () => IterableIterator<[K, V]>;
-    [Symbol.toStringTag]: "Map";
-    constructor(initialData?: IObservableMapInitialValues<K, V>, enhancer?: IEnhancer<V>, name?: string);
-    private _has;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    delete(key: K): boolean;
-    private _updateHasMapEntry;
-    private _updateValue;
-    private _addValue;
-    get(key: K): V | undefined;
-    private dehanceValue;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    entries(): IterableIterator<IMapEntry<K, V>>;
-    forEach(callback: (value: V, key: K, object: Map<K, V>) => void, thisArg?: any): void;
-    /** Merge another object into this object, returns this. */
-    merge(other: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
-    clear(): void;
-    replace(values: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
-    readonly size: number;
-    /**
-     * Returns a plain object that represents this map.
-     * Note that all the keys being stringified.
-     * If there are duplicating keys after converting them to strings, behaviour is undetermined.
-     */
-    toPOJO(): IKeyValueMap<V>;
-    /**
-     * Returns a shallow non observable object clone of this map.
-     * Note that the values migth still be observable. For a deep clone use mobx.toJS.
-     */
-    toJS(): Map<K, V>;
-    toJSON(): IKeyValueMap<V>;
-    toString(): string;
-    /**
-     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
-     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
-     * for callback details
-     */
-    observe(listener: (changes: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
-    intercept(handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
-}
-export declare const isObservableMap: (thing: any) => thing is ObservableMap<any, any>;
+import { Lambda, IInterceptable, IListenable, IEnhancer, IInterceptor } from "../internal";
+export interface IKeyValueMap<V = any> {
+    [key: string]: V;
+}
+export declare type IMapEntry<K = any, V = any> = [K, V];
+export declare type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];
+export declare type IMapDidChange<K = any, V = any> = {
+    object: ObservableMap<K, V>;
+    name: K;
+    type: "update";
+    newValue: V;
+    oldValue: V;
+} | {
+    object: ObservableMap<K, V>;
+    name: K;
+    type: "add";
+    newValue: V;
+} | {
+    object: ObservableMap<K, V>;
+    name: K;
+    type: "delete";
+    oldValue: V;
+};
+export interface IMapWillChange<K = any, V = any> {
+    object: ObservableMap<K, V>;
+    type: "update" | "add" | "delete";
+    name: K;
+    newValue?: V;
+}
+export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
+export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
+    enhancer: IEnhancer<V>;
+    name: string;
+    $mobx: {};
+    private _data;
+    private _hasMap;
+    private _keysAtom;
+    interceptors: any;
+    changeListeners: any;
+    dehancer: any;
+    [Symbol.iterator]: () => IterableIterator<[K, V]>;
+    [Symbol.toStringTag]: "Map";
+    constructor(initialData?: IObservableMapInitialValues<K, V>, enhancer?: IEnhancer<V>, name?: string);
+    private _has;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    private _updateHasMapEntry;
+    private _updateValue;
+    private _addValue;
+    get(key: K): V | undefined;
+    private dehanceValue;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<IMapEntry<K, V>>;
+    forEach(callback: (value: V, key: K, object: Map<K, V>) => void, thisArg?: any): void;
+    /** Merge another object into this object, returns this. */
+    merge(other: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
+    clear(): void;
+    replace(values: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
+    get size(): number;
+    /**
+     * Returns a plain object that represents this map.
+     * Note that all the keys being stringified.
+     * If there are duplicating keys after converting them to strings, behaviour is undetermined.
+     */
+    toPOJO(): IKeyValueMap<V>;
+    /**
+     * Returns a shallow non observable object clone of this map.
+     * Note that the values migth still be observable. For a deep clone use mobx.toJS.
+     */
+    toJS(): Map<K, V>;
+    toJSON(): IKeyValueMap<V>;
+    toString(): string;
+    /**
+     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
+     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
+     * for callback details
+     */
+    observe(listener: (changes: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
+    intercept(handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
+}
+export declare const isObservableMap: (thing: any) => thing is ObservableMap<any, any>;

package/lib/types/observableobject.d.ts

@@ -1,65 +1,65 @@
-import { ObservableValue, IInterceptable, IListenable, ComputedValue, IObservableArray, IEnhancer, Lambda, IComputedValueOptions } from "../internal";
-export interface IObservableObject {
-    "observable-object": IObservableObject;
-}
-export declare type IObjectDidChange = {
-    name: string;
-    object: any;
-    type: "add";
-    newValue: any;
-} | {
-    name: string;
-    object: any;
-    type: "update";
-    oldValue: any;
-    newValue: any;
-} | {
-    name: string;
-    object: any;
-    type: "remove";
-    oldValue: any;
-};
-export declare type IObjectWillChange = {
-    object: any;
-    type: "update" | "add";
-    name: string;
-    newValue: any;
-} | {
-    object: any;
-    type: "remove";
-    name: string;
-};
-export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
-    target: any;
-    name: string;
-    defaultEnhancer: IEnhancer<any>;
-    values: {
-        [key: string]: ObservableValue<any> | ComputedValue<any>;
-    };
-    keys: undefined | IObservableArray<string>;
-    changeListeners: any;
-    interceptors: any;
-    constructor(target: any, name: string, defaultEnhancer: IEnhancer<any>);
-    read(owner: any, key: string): any;
-    write(owner: any, key: string, newValue: any): void;
-    remove(key: string): void;
-    illegalAccess(owner: any, propName: any): void;
-    /**
-     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
-     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
-     * for callback details
-     */
-    observe(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
-    intercept(handler: any): Lambda;
-    getKeys(): string[];
-}
-export interface IIsObservableObject {
-    $mobx: ObservableObjectAdministration;
-}
-export declare function asObservableObject(target: any, name?: string, defaultEnhancer?: IEnhancer<any>): ObservableObjectAdministration;
-export declare function defineObservableProperty(target: any, propName: string, newValue: any, enhancer: IEnhancer<any>): void;
-export declare function defineComputedProperty(target: any, // which objects holds the observable and provides `this` context?
-propName: string, options: IComputedValueOptions<any>): void;
-export declare function generateObservablePropConfig(propName: any): any;
-export declare function generateComputedPropConfig(propName: any): any;
-export declare function isObservableObject(thing: any): thing is IObservableObject;
+import { ObservableValue, IInterceptable, IListenable, ComputedValue, IObservableArray, IEnhancer, Lambda, IComputedValueOptions } from "../internal";
+export interface IObservableObject {
+    "observable-object": IObservableObject;
+}
+export declare type IObjectDidChange<T = any> = {
+    name: string;
+    object: T;
+    type: "add";
+    newValue: any;
+} | {
+    name: string;
+    object: T;
+    type: "update";
+    oldValue: any;
+    newValue: any;
+} | {
+    name: string;
+    object: T;
+    type: "remove";
+    oldValue: any;
+};
+export declare type IObjectWillChange<T = any> = {
+    object: T;
+    type: "update" | "add";
+    name: string;
+    newValue: any;
+} | {
+    object: T;
+    type: "remove";
+    name: string;
+};
+export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
+    target: any;
+    name: string;
+    defaultEnhancer: IEnhancer<any>;
+    values: {
+        [key: string]: ObservableValue<any> | ComputedValue<any>;
+    };
+    keys: undefined | IObservableArray<string>;
+    changeListeners: any;
+    interceptors: any;
+    constructor(target: any, name: string, defaultEnhancer: IEnhancer<any>);
+    read(owner: any, key: string): any;
+    write(owner: any, key: string, newValue: any): void;
+    remove(key: string): void;
+    illegalAccess(owner: any, propName: any): void;
+    /**
+     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
+     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
+     * for callback details
+     */
+    observe(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
+    intercept(handler: any): Lambda;
+    getKeys(): string[];
+}
+export interface IIsObservableObject {
+    $mobx: ObservableObjectAdministration;
+}
+export declare function asObservableObject(target: any, name?: string, defaultEnhancer?: IEnhancer<any>): ObservableObjectAdministration;
+export declare function defineObservableProperty(target: any, propName: string, newValue: any, enhancer: IEnhancer<any>): void;
+export declare function defineComputedProperty(target: any, // which objects holds the observable and provides `this` context?
+propName: string, options: IComputedValueOptions<any>): void;
+export declare function generateObservablePropConfig(propName: any): any;
+export declare function generateComputedPropConfig(propName: any): any;
+export declare function isObservableObject(thing: any): thing is IObservableObject;

package/lib/types/observableset.d.ts

@@ -1,49 +1,49 @@
-import { IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor } from "../internal";
-export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
-export declare type ISetDidChange<T = any> = {
-    object: ObservableSet<T>;
-    type: "add";
-    newValue: T;
-} | {
-    object: ObservableSet<T>;
-    type: "delete";
-    oldValue: T;
-};
-export declare type ISetWillChange<T = any> = {
-    type: "delete";
-    object: ObservableSet<T>;
-    oldValue: T;
-} | {
-    type: "add";
-    object: ObservableSet<T>;
-    newValue: T;
-};
-export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
-    name: string;
-    $mobx: {};
-    private _data;
-    private _atom;
-    changeListeners: any;
-    interceptors: any;
-    dehancer: any;
-    enhancer: (newV: any, oldV: any | undefined) => any;
-    [Symbol.iterator]: () => IterableIterator<T>;
-    [Symbol.toStringTag]: "Set";
-    constructor(initialData?: IObservableSetInitialValues<T>, enhancer?: IEnhancer<T>, name?: string);
-    private dehanceValue;
-    clear(): void;
-    forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
-    readonly size: number;
-    add(value: T): this;
-    delete(value: any): boolean;
-    has(value: any): boolean;
-    entries(): IterableIterator<[T, T]>;
-    keys(): IterableIterator<T>;
-    values(): IterableIterator<T>;
-    replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T>;
-    observe(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-    intercept(handler: IInterceptor<ISetWillChange<T>>): Lambda;
-    toJS(): Set<T>;
-    toString(): string;
-}
-export declare const isObservableSet: (thing: any) => thing is ObservableSet<any>;
+import { IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor } from "../internal";
+export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
+export declare type ISetDidChange<T = any> = {
+    object: ObservableSet<T>;
+    type: "add";
+    newValue: T;
+} | {
+    object: ObservableSet<T>;
+    type: "delete";
+    oldValue: T;
+};
+export declare type ISetWillChange<T = any> = {
+    type: "delete";
+    object: ObservableSet<T>;
+    oldValue: T;
+} | {
+    type: "add";
+    object: ObservableSet<T>;
+    newValue: T;
+};
+export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
+    name: string;
+    $mobx: {};
+    private _data;
+    private _atom;
+    changeListeners: any;
+    interceptors: any;
+    dehancer: any;
+    enhancer: (newV: any, oldV: any | undefined) => any;
+    [Symbol.iterator]: () => IterableIterator<T>;
+    [Symbol.toStringTag]: "Set";
+    constructor(initialData?: IObservableSetInitialValues<T>, enhancer?: IEnhancer<T>, name?: string);
+    private dehanceValue;
+    clear(): void;
+    forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+    add(value: T): this;
+    delete(value: any): boolean;
+    has(value: any): boolean;
+    entries(): IterableIterator<[T, T]>;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T>;
+    observe(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+    intercept(handler: IInterceptor<ISetWillChange<T>>): Lambda;
+    toJS(): Set<T>;
+    toString(): string;
+}
+export declare const isObservableSet: (thing: any) => thing is ObservableSet<any>;

package/lib/types/observablevalue.d.ts

@@ -1,37 +1,37 @@
-import { Lambda, IInterceptor, Atom, IInterceptable, IListenable, IEnhancer, IEqualsComparer } from "../internal";
-export interface IValueWillChange<T> {
-    object: any;
-    type: "update";
-    newValue: T;
-}
-export interface IValueDidChange<T> extends IValueWillChange<T> {
-    oldValue: T | undefined;
-}
-export interface IObservableValue<T> {
-    get(): T;
-    set(value: T): void;
-    intercept(handler: IInterceptor<IValueWillChange<T>>): Lambda;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-}
-export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
-    enhancer: IEnhancer<T>;
-    name: string;
-    private equals;
-    hasUnreportedChange: boolean;
-    interceptors: any;
-    changeListeners: any;
-    value: any;
-    dehancer: any;
-    constructor(value: T, enhancer: IEnhancer<T>, name?: string, notifySpy?: boolean, equals?: IEqualsComparer<any>);
-    private dehanceValue;
-    set(newValue: T): void;
-    private prepareNewValue;
-    setNewValue(newValue: T): void;
-    get(): T;
-    intercept(handler: IInterceptor<IValueWillChange<T>>): Lambda;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-    toJSON(): T;
-    toString(): string;
-    valueOf(): T;
-}
-export declare const isObservableValue: (x: any) => x is IObservableValue<any>;
+import { Lambda, IInterceptor, Atom, IInterceptable, IListenable, IEnhancer, IEqualsComparer } from "../internal";
+export interface IValueWillChange<T> {
+    object: any;
+    type: "update";
+    newValue: T;
+}
+export interface IValueDidChange<T> extends IValueWillChange<T> {
+    oldValue: T | undefined;
+}
+export interface IObservableValue<T> {
+    get(): T;
+    set(value: T): void;
+    intercept(handler: IInterceptor<IValueWillChange<T>>): Lambda;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+}
+export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
+    enhancer: IEnhancer<T>;
+    name: string;
+    private equals;
+    hasUnreportedChange: boolean;
+    interceptors: any;
+    changeListeners: any;
+    value: any;
+    dehancer: any;
+    constructor(value: T, enhancer: IEnhancer<T>, name?: string, notifySpy?: boolean, equals?: IEqualsComparer<any>);
+    private dehanceValue;
+    set(newValue: T): void;
+    private prepareNewValue;
+    setNewValue(newValue: T): void;
+    get(): T;
+    intercept(handler: IInterceptor<IValueWillChange<T>>): Lambda;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+    toJSON(): T;
+    toString(): string;
+    valueOf(): T;
+}
+export declare const isObservableValue: (x: any) => x is IObservableValue<any>;

package/lib/types/type-utils.d.ts

@@ -1,4 +1,4 @@
-import { IDepTreeNode } from "../internal";
-export declare function getAtom(thing: any, property?: string): IDepTreeNode;
-export declare function getAdministration(thing: any, property?: string): any;
-export declare function getDebugName(thing: any, property?: string): string;
+import { IDepTreeNode } from "../internal";
+export declare function getAtom(thing: any, property?: string): IDepTreeNode;
+export declare function getAdministration(thing: any, property?: string): any;
+export declare function getDebugName(thing: any, property?: string): string;

package/lib/utils/comparer.d.ts

@@ -1,14 +1,14 @@
-export interface IEqualsComparer<T> {
-    (a: T, b: T): boolean;
-}
-declare function identityComparer(a: any, b: any): boolean;
-declare function structuralComparer(a: any, b: any): boolean;
-declare function shallowComparer(a: any, b: any): boolean;
-declare function defaultComparer(a: any, b: any): boolean;
-export declare const comparer: {
-    identity: typeof identityComparer;
-    structural: typeof structuralComparer;
-    default: typeof defaultComparer;
-    shallow: typeof shallowComparer;
-};
-export {};
+export interface IEqualsComparer<T> {
+    (a: T, b: T): boolean;
+}
+declare function identityComparer(a: any, b: any): boolean;
+declare function structuralComparer(a: any, b: any): boolean;
+declare function shallowComparer(a: any, b: any): boolean;
+declare function defaultComparer(a: any, b: any): boolean;
+export declare const comparer: {
+    identity: typeof identityComparer;
+    structural: typeof structuralComparer;
+    default: typeof defaultComparer;
+    shallow: typeof shallowComparer;
+};
+export {};

package/lib/utils/decorators2.d.ts

@@ -1,7 +1,7 @@
-export declare type BabelDescriptor = PropertyDescriptor & {
-    initializer?: () => any;
-};
-export declare type PropertyCreator = (instance: any, propertyName: string, descriptor: BabelDescriptor | undefined, decoratorTarget: any, decoratorArgs: any[]) => void;
-export declare function initializeInstance(target: any): any;
-export declare function createPropDecorator(propertyInitiallyEnumerable: boolean, propertyCreator: PropertyCreator): Function;
-export declare function quacksLikeADecorator(args: IArguments): boolean;
+export declare type BabelDescriptor = PropertyDescriptor & {
+    initializer?: () => any;
+};
+export declare type PropertyCreator = (instance: any, propertyName: string, descriptor: BabelDescriptor | undefined, decoratorTarget: any, decoratorArgs: any[]) => void;
+export declare function initializeInstance(target: any): any;
+export declare function createPropDecorator(propertyInitiallyEnumerable: boolean, propertyCreator: PropertyCreator): Function;
+export declare function quacksLikeADecorator(args: IArguments): boolean;

package/lib/utils/eq.d.ts

@@ -1 +1 @@
-export declare function deepEqual(a: any, b: any, depth?: number): boolean;
+export declare function deepEqual(a: any, b: any, depth?: number): boolean;

package/lib/utils/iterable.d.ts

@@ -1,5 +1,5 @@
-export declare function iteratorSymbol(): any;
-export declare const IS_ITERATING_MARKER = "__$$iterating";
-export declare function declareIterator<T>(prototType: any, iteratorFactory: () => IterableIterator<T>): void;
-export declare function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
-export declare function toStringTagSymbol(): any;
+export declare function iteratorSymbol(): any;
+export declare const IS_ITERATING_MARKER = "__$$iterating";
+export declare function declareIterator<T>(prototType: any, iteratorFactory: () => IterableIterator<T>): void;
+export declare function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
+export declare function toStringTagSymbol(): any;

package/lib/utils/utils.d.ts

@@ -1,43 +1,42 @@
-import { ObservableMap, IObservableArray, IKeyValueMap } from "../internal";
-export declare const OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is an production build.";
-export declare const EMPTY_ARRAY: never[];
-export declare const EMPTY_OBJECT: {};
-export declare function getGlobal(): any;
-export interface Lambda {
-    (): void;
-    name?: string;
-}
-export declare function getNextId(): number;
-export declare function fail(message: string | boolean): never;
-export declare function invariant(check: false, message?: string | boolean): never;
-export declare function invariant(check: true, message?: string | boolean): void;
-export declare function invariant(check: any, message?: string | boolean): void;
-export declare function deprecated(msg: string): boolean;
-export declare function deprecated(thing: string, replacement: string): boolean;
-/**
- * Makes sure that the provided function is invoked at most once.
- */
-export declare function once(func: Lambda): Lambda;
-export declare const noop: () => void;
-export declare function unique<T>(list: T[]): T[];
-export declare function isObject(value: any): boolean;
-export declare function isPlainObject(value: any): boolean;
-export declare function convertToMap(dataStructure: any): any;
-export declare function makeNonEnumerable(object: any, propNames: string[]): void;
-export declare function addHiddenProp(object: any, propName: PropertyKey, value: any): void;
-export declare function addHiddenFinalProp(object: any, propName: string, value: any): void;
-export declare function isPropertyConfigurable(object: any, prop: string): boolean;
-export declare function assertPropertyConfigurable(object: any, prop: string): void;
-export declare function createInstanceofPredicate<T>(name: string, clazz: new (...args: any[]) => T): (x: any) => x is T;
-export declare function areBothNaN(a: any, b: any): boolean;
-/**
- * Returns whether the argument is an array, disregarding observability.
- */
-export declare function isArrayLike(x: any): x is Array<any> | IObservableArray<any>;
-export declare function isES6Map(thing: any): boolean;
-export declare function isES6Set(thing: any): thing is Set<any>;
-export declare function getMapLikeKeys<K, V>(map: ObservableMap<K, V>): ReadonlyArray<K>;
-export declare function getMapLikeKeys<V>(map: IKeyValueMap<V> | any): ReadonlyArray<string>;
-export declare function iteratorToArray<T>(it: Iterator<T>): Array<T>;
-export declare function primitiveSymbol(): any;
-export declare function toPrimitive(value: any): any;
+import { IObservableArray } from "../internal";
+export declare const OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is an production build.";
+export declare const EMPTY_ARRAY: never[];
+export declare const EMPTY_OBJECT: {};
+export declare function getGlobal(): any;
+export interface Lambda {
+    (): void;
+    name?: string;
+}
+export declare function getNextId(): number;
+export declare function fail(message: string | boolean): never;
+export declare function invariant(check: false, message?: string | boolean): never;
+export declare function invariant(check: true, message?: string | boolean): void;
+export declare function invariant(check: any, message?: string | boolean): void;
+export declare function deprecated(msg: string): boolean;
+export declare function deprecated(thing: string, replacement: string): boolean;
+/**
+ * Makes sure that the provided function is invoked at most once.
+ */
+export declare function once(func: Lambda): Lambda;
+export declare const noop: () => void;
+export declare function unique<T>(list: T[]): T[];
+export declare function isObject(value: any): boolean;
+export declare function isPlainObject(value: any): boolean;
+export declare function convertToMap(dataStructure: any): Map<any, any>;
+export declare function makeNonEnumerable(object: any, propNames: string[]): void;
+export declare function addHiddenProp(object: any, propName: PropertyKey, value: any): void;
+export declare function addHiddenFinalProp(object: any, propName: string, value: any): void;
+export declare function isPropertyConfigurable(object: any, prop: string): boolean;
+export declare function assertPropertyConfigurable(object: any, prop: string): void;
+export declare function createInstanceofPredicate<T>(name: string, clazz: new (...args: any[]) => T): (x: any) => x is T;
+export declare function areBothNaN(a: any, b: any): boolean;
+/**
+ * Returns whether the argument is an array, disregarding observability.
+ */
+export declare function isArrayLike(x: any): x is Array<any> | IObservableArray<any>;
+export declare function isES6Map(thing: any): boolean;
+export declare function isES6Set(thing: any): thing is Set<any>;
+export declare function iteratorToArray<T>(it: Iterator<T>): Array<T>;
+export declare function primitiveSymbol(): any;
+export declare function toPrimitive(value: any): any;
+export declare function forOf<T>(iter: Iterator<T>, callback: (entry: T) => void): void;