mobx 4.15.0 → 4.15.4

package/lib/api/computed.d.ts

@@ -1,14 +1,14 @@
-import { IComputedValueOptions, IComputedValue } from "../internal";
-export interface IComputed {
-    <T>(options: IComputedValueOptions<T>): any;
-    <T>(func: () => T, setter: (v: T) => void): IComputedValue<T>;
-    <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>;
-    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
-    struct(target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
-}
-export declare const computedDecorator: Function;
-/**
- * Decorator for class properties: @computed get value() { return expr; }.
- * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
- */
-export declare const computed: IComputed;
+import { IComputedValueOptions, IComputedValue } from "../internal";
+export interface IComputed {
+    <T>(options: IComputedValueOptions<T>): any;
+    <T>(func: () => T, setter: (v: T) => void): IComputedValue<T>;
+    <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>;
+    (target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
+    struct(target: Object, key: string | symbol, baseDescriptor?: PropertyDescriptor): void;
+}
+export declare const computedDecorator: Function;
+/**
+ * Decorator for class properties: @computed get value() { return expr; }.
+ * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
+ */
+export declare const computed: IComputed;

package/lib/api/configure.d.ts

@@ -1,19 +1,19 @@
-export declare function configure(options: {
-    enforceActions?: boolean | "strict" | "never" | "always" | "observed";
-    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;
-    computedConfigurable?: boolean;
-    isolateGlobalState?: boolean;
-    disableErrorBoundaries?: boolean;
-    arrayBuffer?: number;
-    reactionScheduler?: (f: () => void) => void;
-}): void;
+export declare function configure(options: {
+    enforceActions?: boolean | "strict" | "never" | "always" | "observed";
+    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;
+    computedConfigurable?: boolean;
+    isolateGlobalState?: boolean;
+    disableErrorBoundaries?: boolean;
+    arrayBuffer?: number;
+    reactionScheduler?: (f: () => void) => void;
+}): void;

package/lib/api/decorate.d.ts

@@ -1,6 +1,6 @@
-export declare function decorate<T>(clazz: new (...args: any[]) => T, decorators: {
-    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
-}): void;
-export declare function decorate<T>(object: T, decorators: {
-    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
-}): T;
+export declare function decorate<T>(clazz: new (...args: any[]) => T, decorators: {
+    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
+}): void;
+export declare function decorate<T>(object: T, decorators: {
+    [P in keyof T]?: MethodDecorator | PropertyDecorator | Array<MethodDecorator> | Array<PropertyDecorator>;
+}): T;

package/lib/api/extendobservable.d.ts

@@ -1,7 +1,7 @@
-import { CreateObservableOptions } from "../internal";
-export declare function extendShallowObservable<A extends Object, B extends Object>(target: A, properties: B, decorators?: {
-    [K in keyof B]?: Function;
-}): A & B;
-export declare function extendObservable<A extends Object, B extends Object>(target: A, properties: B, decorators?: {
-    [K in keyof B]?: Function;
-}, options?: CreateObservableOptions): A & B;
+import { CreateObservableOptions } from "../internal";
+export declare function extendShallowObservable<A extends Object, B extends Object>(target: A, properties: B, decorators?: {
+    [K in keyof B]?: Function;
+}): A & B;
+export declare function extendObservable<A extends Object, B extends Object>(target: A, properties: B, decorators?: {
+    [K in keyof B]?: Function;
+}, options?: CreateObservableOptions): A & B;

package/lib/api/extras.d.ts

@@ -1,10 +1,10 @@
-export interface IDependencyTree {
-    name: string;
-    dependencies?: IDependencyTree[];
-}
-export interface IObserverTree {
-    name: string;
-    observers?: IObserverTree[];
-}
-export declare function getDependencyTree(thing: any, property?: string): IDependencyTree;
-export declare function getObserverTree(thing: any, property?: string): IObserverTree;
+export interface IDependencyTree {
+    name: string;
+    dependencies?: IDependencyTree[];
+}
+export interface IObserverTree {
+    name: string;
+    observers?: IObserverTree[];
+}
+export declare function getDependencyTree(thing: any, property?: string): IDependencyTree;
+export declare function getObserverTree(thing: any, property?: string): IObserverTree;

package/lib/api/flow.d.ts

@@ -1,9 +1,9 @@
-export declare function FlowCancellationError(): void;
-export declare namespace FlowCancellationError {
-    var prototype: any;
-}
-export declare function isFlowCancellationError(error: Error): boolean;
-export declare type CancellablePromise<T> = Promise<T> & {
-    cancel(): void;
-};
-export declare function flow<R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;
+export declare function FlowCancellationError(): void;
+export declare namespace FlowCancellationError {
+    var prototype: any;
+}
+export declare function isFlowCancellationError(error: Error): boolean;
+export declare type CancellablePromise<T> = Promise<T> & {
+    cancel(): void;
+};
+export declare function flow<R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;

package/lib/api/intercept-read.d.ts

@@ -1,8 +1,8 @@
-import { Lambda, IObservableValue, IObservableArray, ObservableMap, ObservableSet } from "../internal";
-export declare type ReadInterceptor<T> = (value: any) => T;
-/** Experimental feature right now, tested indirectly via Mobx-State-Tree */
-export declare function interceptReads<T>(value: IObservableValue<T>, handler: ReadInterceptor<T>): Lambda;
-export declare function interceptReads<T>(observableArray: IObservableArray<T>, handler: ReadInterceptor<T>): Lambda;
-export declare function interceptReads<K, V>(observableMap: ObservableMap<K, V>, handler: ReadInterceptor<V>): Lambda;
-export declare function interceptReads<V>(observableSet: ObservableSet<V>, handler: ReadInterceptor<V>): Lambda;
-export declare function interceptReads(object: Object, property: string, handler: ReadInterceptor<any>): Lambda;
+import { Lambda, IObservableValue, IObservableArray, ObservableMap, ObservableSet } from "../internal";
+export declare type ReadInterceptor<T> = (value: any) => T;
+/** Experimental feature right now, tested indirectly via Mobx-State-Tree */
+export declare function interceptReads<T>(value: IObservableValue<T>, handler: ReadInterceptor<T>): Lambda;
+export declare function interceptReads<T>(observableArray: IObservableArray<T>, handler: ReadInterceptor<T>): Lambda;
+export declare function interceptReads<K, V>(observableMap: ObservableMap<K, V>, handler: ReadInterceptor<V>): Lambda;
+export declare function interceptReads<V>(observableSet: ObservableSet<V>, handler: ReadInterceptor<V>): Lambda;
+export declare function interceptReads(object: Object, property: string, handler: ReadInterceptor<any>): Lambda;

package/lib/api/intercept.d.ts

@@ -1,8 +1,8 @@
-import { IInterceptor, IValueWillChange, IObservableValue, Lambda, IObservableArray, IArrayWillChange, IArrayWillSplice, ObservableMap, IMapWillChange, ObservableSet, ISetWillChange, IObjectWillChange } from "../internal";
-export declare function intercept<T>(value: IObservableValue<T>, handler: IInterceptor<IValueWillChange<T>>): Lambda;
-export declare function intercept<T>(observableArray: IObservableArray<T>, handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
-export declare function intercept<K, V>(observableMap: ObservableMap<K, V>, handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
-export declare function intercept<V>(observableMap: ObservableSet<V>, handler: IInterceptor<ISetWillChange<V>>): Lambda;
-export declare function intercept<K, V>(observableMap: ObservableMap<K, V>, property: K, handler: IInterceptor<IValueWillChange<V>>): Lambda;
-export declare function intercept(object: Object, handler: IInterceptor<IObjectWillChange>): Lambda;
-export declare function intercept<T extends Object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<any>>): Lambda;
+import { IInterceptor, IValueWillChange, IObservableValue, Lambda, IObservableArray, IArrayWillChange, IArrayWillSplice, ObservableMap, IMapWillChange, ObservableSet, ISetWillChange, IObjectWillChange } from "../internal";
+export declare function intercept<T>(value: IObservableValue<T>, handler: IInterceptor<IValueWillChange<T>>): Lambda;
+export declare function intercept<T>(observableArray: IObservableArray<T>, handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
+export declare function intercept<K, V>(observableMap: ObservableMap<K, V>, handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
+export declare function intercept<V>(observableMap: ObservableSet<V>, handler: IInterceptor<ISetWillChange<V>>): Lambda;
+export declare function intercept<K, V>(observableMap: ObservableMap<K, V>, property: K, handler: IInterceptor<IValueWillChange<V>>): Lambda;
+export declare function intercept(object: Object, handler: IInterceptor<IObjectWillChange>): Lambda;
+export declare function intercept<T extends Object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<any>>): Lambda;

package/lib/api/iscomputed.d.ts

@@ -1,3 +1,3 @@
-export declare function _isComputed(value: any, property?: string): boolean;
-export declare function isComputed(value: any): boolean;
-export declare function isComputedProp(value: any, propName: string): boolean;
+export declare function _isComputed(value: any, property?: string): boolean;
+export declare function isComputed(value: any): boolean;
+export declare function isComputedProp(value: any, propName: string): boolean;

package/lib/api/isobservable.d.ts

@@ -1,2 +1,2 @@
-export declare function isObservable(value: any): boolean;
-export declare function isObservableProp(value: any, propName: string): boolean;
+export declare function isObservable(value: any): boolean;
+export declare function isObservableProp(value: any, propName: string): boolean;

package/lib/api/object-api.d.ts

@@ -1,34 +1,34 @@
-import { ObservableMap, IObservableArray, ObservableSet } from "../internal";
-export declare function keys<K>(map: ObservableMap<K, any>): ReadonlyArray<K>;
-export declare function keys<T>(ar: IObservableArray<T>): ReadonlyArray<number>;
-export declare function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>;
-export declare function keys<T extends Object>(obj: T): ReadonlyArray<string>;
-export declare function values<K, T>(map: ObservableMap<K, T>): ReadonlyArray<T>;
-export declare function values<T>(set: ObservableSet<T>): ReadonlyArray<T>;
-export declare function values<T>(ar: IObservableArray<T>): ReadonlyArray<T>;
-export declare function values<T = any>(obj: T): ReadonlyArray<any>;
-export declare function entries<K, T>(map: ObservableMap<K, T>): ReadonlyArray<[K, T]>;
-export declare function entries<T>(set: ObservableSet<T>): ReadonlyArray<[T, T]>;
-export declare function entries<T>(ar: IObservableArray<T>): ReadonlyArray<[number, T]>;
-export declare function entries<T = any>(obj: T): ReadonlyArray<[string, any]>;
-export declare function set<V>(obj: ObservableMap<string, V>, values: {
-    [key: string]: V;
-}): any;
-export declare function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
-export declare function set<T>(obj: ObservableSet<T>, value: T): any;
-export declare function set<T>(obj: IObservableArray<T>, index: number, value: T): any;
-export declare function set<T extends Object>(obj: T, values: {
-    [key: string]: any;
-}): any;
-export declare function set<T extends Object>(obj: T, key: string, value: any): any;
-export declare function remove<K, V>(obj: ObservableMap<K, V>, key: K): any;
-export declare function remove<T>(obj: ObservableSet<T>, key: T): any;
-export declare function remove<T>(obj: IObservableArray<T>, index: number): any;
-export declare function remove<T extends Object>(obj: T, key: string): any;
-export declare function has<K>(obj: ObservableMap<K, any>, key: K): boolean;
-export declare function has<T>(obj: ObservableSet<T>, key: T): boolean;
-export declare function has<T>(obj: IObservableArray<T>, index: number): boolean;
-export declare function has<T extends Object>(obj: T, key: string): boolean;
-export declare function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined;
-export declare function get<T>(obj: IObservableArray<T>, index: number): T | undefined;
-export declare function get<T extends Object>(obj: T, key: string): any;
+import { ObservableMap, IObservableArray, ObservableSet } from "../internal";
+export declare function keys<K>(map: ObservableMap<K, any>): ReadonlyArray<K>;
+export declare function keys<T>(ar: IObservableArray<T>): ReadonlyArray<number>;
+export declare function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>;
+export declare function keys<T extends Object>(obj: T): ReadonlyArray<string>;
+export declare function values<K, T>(map: ObservableMap<K, T>): ReadonlyArray<T>;
+export declare function values<T>(set: ObservableSet<T>): ReadonlyArray<T>;
+export declare function values<T>(ar: IObservableArray<T>): ReadonlyArray<T>;
+export declare function values<T = any>(obj: T): ReadonlyArray<any>;
+export declare function entries<K, T>(map: ObservableMap<K, T>): ReadonlyArray<[K, T]>;
+export declare function entries<T>(set: ObservableSet<T>): ReadonlyArray<[T, T]>;
+export declare function entries<T>(ar: IObservableArray<T>): ReadonlyArray<[number, T]>;
+export declare function entries<T = any>(obj: T): ReadonlyArray<[string, any]>;
+export declare function set<V>(obj: ObservableMap<string, V>, values: {
+    [key: string]: V;
+}): any;
+export declare function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
+export declare function set<T>(obj: ObservableSet<T>, value: T): any;
+export declare function set<T>(obj: IObservableArray<T>, index: number, value: T): any;
+export declare function set<T extends Object>(obj: T, values: {
+    [key: string]: any;
+}): any;
+export declare function set<T extends Object>(obj: T, key: string, value: any): any;
+export declare function remove<K, V>(obj: ObservableMap<K, V>, key: K): any;
+export declare function remove<T>(obj: ObservableSet<T>, key: T): any;
+export declare function remove<T>(obj: IObservableArray<T>, index: number): any;
+export declare function remove<T extends Object>(obj: T, key: string): any;
+export declare function has<K>(obj: ObservableMap<K, any>, key: K): boolean;
+export declare function has<T>(obj: ObservableSet<T>, key: T): boolean;
+export declare function has<T>(obj: IObservableArray<T>, index: number): boolean;
+export declare function has<T extends Object>(obj: T, key: string): boolean;
+export declare function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined;
+export declare function get<T>(obj: IObservableArray<T>, index: number): T | undefined;
+export declare function get<T extends Object>(obj: T, key: string): any;

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;