mobx

  • Version 6.3.8
  • Published
  • 3.86 MB
  • No dependencies
  • MIT license

Install

npm i mobx
yarn add mobx
pnpm add mobx

Overview

Simple, scalable state management.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable $mobx

const $mobx: Symbol;

    variable action

    const action: IActionFactory;

      variable comparer

      const comparer: {
      identity: (a: any, b: any) => boolean;
      structural: (a: any, b: any) => boolean;
      default: (a: any, b: any) => boolean;
      shallow: (a: any, b: any) => boolean;
      };

        variable computed

        const computed: IComputedFactory;
        • Decorator for class properties: get value() { return expr; }. For legacy purposes also invokable as ES5 observable created: computed(() => expr);

        variable flow

        const flow: Flow;

          variable FlowCancellationError

          const FlowCancellationError: typeof FlowCancellationError;

            variable isBoxedObservable

            const isBoxedObservable: (x: any) => x is IObservableValue<any>;

              variable isObservableMap

              var isObservableMap: (thing: any) => thing is ObservableMap<any, any>;

                variable isObservableSet

                var isObservableSet: (thing: any) => thing is ObservableSet<any>;

                  variable observable

                  var observable: IObservableFactory;

                    variable override

                    const override: Annotation & PropertyDecorator;

                      Functions

                      function autorun

                      autorun: (
                      view: (r: IReactionPublic) => any,
                      opts?: IAutorunOptions
                      ) => IReactionDisposer;
                      • Creates a named reactive view and keeps it alive, so that the view is always updated if one of the dependencies changes, even when the view is not further used by something else.

                        Parameter view

                        The reactive view

                        Returns

                        disposer function, which can be used to stop the view from being updated in the future.

                      function configure

                      configure: (options: {
                      enforceActions?: 'never' | 'always' | 'observed';
                      computedRequiresReaction?: boolean;
                      reactionRequiresObservable?: boolean;
                      observableRequiresReaction?: boolean;
                      isolateGlobalState?: boolean;
                      disableErrorBoundaries?: boolean;
                      safeDescriptors?: boolean;
                      reactionScheduler?: (f: () => void) => void;
                      useProxies?: 'always' | 'never' | 'ifavailable';
                      }) => void;

                        function createAtom

                        createAtom: (
                        name: string,
                        onBecomeObservedHandler?: () => void,
                        onBecomeUnobservedHandler?: () => void
                        ) => IAtom;

                          function defineProperty

                          defineProperty: (
                          obj: Object,
                          key: PropertyKey,
                          descriptor: PropertyDescriptor
                          ) => any;

                            function entries

                            entries: {
                            <K, T>(map: ObservableMap<K, T>): readonly [K, T][];
                            <T>(set: ObservableSet<T>): readonly [T, T][];
                            <T>(ar: IObservableArray<T>): readonly [number, T][];
                            <T = any>(obj: T): readonly [string, T extends object ? T[keyof T] : any][];
                            };

                              function extendObservable

                              extendObservable: <A extends Object, B extends Object>(
                              target: A,
                              properties: B,
                              annotations?: AnnotationsMap<B, never>,
                              options?: CreateObservableOptions
                              ) => A & B;

                                function FlowCancellationError

                                FlowCancellationError: typeof FlowCancellationError;

                                  function flowResult

                                  flowResult: <T>(
                                  result: T
                                  ) => T extends Generator<any, infer R, any>
                                  ? CancellablePromise<R>
                                  : T extends CancellablePromise<any>
                                  ? T
                                  : never;

                                    function get

                                    get: {
                                    <K, V>(obj: ObservableMap<K, V>, key: K): V;
                                    <T>(obj: IObservableArray<T>, index: number): T;
                                    <T extends Object>(obj: T, key: string): any;
                                    };

                                      function getAtom

                                      getAtom: (thing: any, property?: PropertyKey) => IDepTreeNode;

                                        function getDebugName

                                        getDebugName: (thing: any, property?: string) => string;

                                          function getDependencyTree

                                          getDependencyTree: (thing: any, property?: string) => IDependencyTree;

                                            function getObserverTree

                                            getObserverTree: (thing: any, property?: string) => IObserverTree;

                                              function has

                                              has: {
                                              <K>(obj: ObservableMap<K, any>, key: K): boolean;
                                              <T>(obj: ObservableSet<T>, key: T): boolean;
                                              <T>(obj: IObservableArray<T>, index: number): boolean;
                                              <T extends Object>(obj: T, key: string): boolean;
                                              };

                                                function intercept

                                                intercept: {
                                                <T>(
                                                value: IObservableValue<T>,
                                                handler: IInterceptor<IValueWillChange<T>>
                                                ): Lambda;
                                                <T>(
                                                observableArray: IObservableArray<T>,
                                                handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>
                                                ): Lambda;
                                                <K, V>(
                                                observableMap: ObservableMap<K, V> | Map<K, V>,
                                                handler: IInterceptor<IMapWillChange<K, V>>
                                                ): Lambda;
                                                <V>(
                                                observableSet: ObservableSet<V> | Set<V>,
                                                handler: IInterceptor<ISetWillChange<V>>
                                                ): Lambda;
                                                <K, V>(
                                                observableMap: ObservableMap<K, V> | Map<K, V>,
                                                property: K,
                                                handler: IInterceptor<IValueWillChange<V>>
                                                ): Lambda;
                                                (object: object, handler: IInterceptor<IObjectWillChange<any>>): Lambda;
                                                <T extends object, K extends keyof T>(
                                                object: T,
                                                property: K,
                                                handler: IInterceptor<IValueWillChange<T[K]>>
                                                ): Lambda;
                                                };

                                                  function isAction

                                                  isAction: (thing: any) => boolean;

                                                    function isComputed

                                                    isComputed: (value: any) => boolean;

                                                      function isComputedProp

                                                      isComputedProp: (value: any, propName: PropertyKey) => boolean;

                                                        function isFlow

                                                        isFlow: (fn: any) => boolean;

                                                          function isFlowCancellationError

                                                          isFlowCancellationError: (error: Error) => boolean;

                                                            function isObservable

                                                            isObservable: (value: any) => boolean;

                                                              function isObservableArray

                                                              isObservableArray: (thing: any) => thing is IObservableArray<any>;

                                                                function isObservableObject

                                                                isObservableObject: (thing: any) => boolean;

                                                                  function isObservableProp

                                                                  isObservableProp: (value: any, propName: PropertyKey) => boolean;

                                                                    function keys

                                                                    keys: {
                                                                    <K>(map: ObservableMap<K, any>): readonly K[];
                                                                    <T>(ar: IObservableArray<T>): readonly number[];
                                                                    <T>(set: ObservableSet<T>): readonly T[];
                                                                    <T extends Object>(obj: T): readonly PropertyKey[];
                                                                    };

                                                                      function makeAutoObservable

                                                                      makeAutoObservable: <
                                                                      T extends object,
                                                                      AdditionalKeys extends PropertyKey = never
                                                                      >(
                                                                      target: T,
                                                                      overrides?: AnnotationsMap<T, NoInfer<AdditionalKeys>>,
                                                                      options?: CreateObservableOptions
                                                                      ) => T;

                                                                        function makeObservable

                                                                        makeObservable: <T extends object, AdditionalKeys extends PropertyKey = never>(
                                                                        target: T,
                                                                        annotations?: AnnotationsMap<T, NoInfer<AdditionalKeys>>,
                                                                        options?: CreateObservableOptions
                                                                        ) => T;

                                                                          function observe

                                                                          observe: {
                                                                          <T>(
                                                                          value: IObservableValue<T> | IComputedValue<T>,
                                                                          listener: (change: IValueDidChange<T>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          <T>(
                                                                          observableArray: IObservableArray<T>,
                                                                          listener: (change: IArrayDidChange<T>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          <V>(
                                                                          observableSet: ObservableSet<V> | Set<V>,
                                                                          listener: (change: ISetDidChange<V>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          <K, V>(
                                                                          observableMap: ObservableMap<K, V> | Map<K, V>,
                                                                          listener: (change: IMapDidChange<K, V>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          <K, V>(
                                                                          observableMap: ObservableMap<K, V> | Map<K, V>,
                                                                          property: K,
                                                                          listener: (change: IValueDidChange<V>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          (
                                                                          object: Object,
                                                                          listener: (change: IObjectDidChange<any>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          <T, K extends keyof T>(
                                                                          object: T,
                                                                          property: K,
                                                                          listener: (change: IValueDidChange<T[K]>) => void,
                                                                          fireImmediately?: boolean
                                                                          ): Lambda;
                                                                          };

                                                                            function onBecomeObserved

                                                                            onBecomeObserved: {
                                                                            (
                                                                            value:
                                                                            | IObservable
                                                                            | IObservableValue<any>
                                                                            | IObservableArray<any>
                                                                            | ObservableMap<any, any>
                                                                            | ObservableSet<any>
                                                                            | IComputedValue<any>,
                                                                            listener: Lambda
                                                                            ): Lambda;
                                                                            <K, V = any>(
                                                                            value: Object | ObservableMap<K, V>,
                                                                            property: K,
                                                                            listener: Lambda
                                                                            ): Lambda;
                                                                            };

                                                                              function onBecomeUnobserved

                                                                              onBecomeUnobserved: {
                                                                              (
                                                                              value:
                                                                              | IObservable
                                                                              | IObservableValue<any>
                                                                              | IObservableArray<any>
                                                                              | ObservableMap<any, any>
                                                                              | ObservableSet<any>
                                                                              | IComputedValue<any>,
                                                                              listener: Lambda
                                                                              ): Lambda;
                                                                              <K, V = any>(
                                                                              value: Object | ObservableMap<K, V>,
                                                                              property: K,
                                                                              listener: Lambda
                                                                              ): Lambda;
                                                                              };

                                                                                function onReactionError

                                                                                onReactionError: (
                                                                                handler: (error: any, derivation: IDerivation) => void
                                                                                ) => Lambda;

                                                                                  function ownKeys

                                                                                  ownKeys: (obj: Object) => any;

                                                                                    function reaction

                                                                                    reaction: <T, FireImmediately extends boolean = false>(
                                                                                    expression: (r: IReactionPublic) => T,
                                                                                    effect: (
                                                                                    arg: T,
                                                                                    prev: FireImmediately extends true ? T | undefined : T,
                                                                                    r: IReactionPublic
                                                                                    ) => void,
                                                                                    opts?: IReactionOptions<T, FireImmediately>
                                                                                    ) => IReactionDisposer;

                                                                                      function remove

                                                                                      remove: {
                                                                                      <K, V>(obj: ObservableMap<K, V>, key: K): any;
                                                                                      <T>(obj: ObservableSet<T>, key: T): any;
                                                                                      <T>(obj: IObservableArray<T>, index: number): any;
                                                                                      <T extends Object>(obj: T, key: string): any;
                                                                                      };

                                                                                        function runInAction

                                                                                        runInAction: <T>(fn: () => T) => T;

                                                                                          function set

                                                                                          set: {
                                                                                          <V>(obj: ObservableMap<PropertyKey, V>, values: { [key: string]: V }): any;
                                                                                          <K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
                                                                                          <T>(obj: ObservableSet<T>, value: T): any;
                                                                                          <T>(obj: IObservableArray<T>, index: number, value: T): any;
                                                                                          <T extends Object>(obj: T, values: { [key: string]: any }): any;
                                                                                          <T extends Object>(obj: T, key: PropertyKey, value: any): any;
                                                                                          };

                                                                                            function spy

                                                                                            spy: (listener: (change: SpyEvent) => void) => Lambda;

                                                                                              function toJS

                                                                                              toJS: <T>(source: T, options?: any) => T;
                                                                                              • Basically, a deep clone, so that no reactive property will exist anymore.

                                                                                              function trace

                                                                                              trace: {
                                                                                              (thing?: any, prop?: string, enterBreakPoint?: boolean): void;
                                                                                              (thing?: any, enterBreakPoint?: boolean): void;
                                                                                              (enterBreakPoint?: boolean): void;
                                                                                              };

                                                                                                function transaction

                                                                                                transaction: <T>(action: () => T, thisArg?: any) => T;
                                                                                                • During a transaction no views are updated until the end of the transaction. The transaction will be run synchronously nonetheless.

                                                                                                  Parameter action

                                                                                                  a function that updates some reactive state

                                                                                                  Returns

                                                                                                  any value that was returned by the 'action' parameter.

                                                                                                function untracked

                                                                                                untracked: <T>(action: () => T) => T;

                                                                                                  function values

                                                                                                  values: {
                                                                                                  <K, T>(map: ObservableMap<K, T>): readonly T[];
                                                                                                  <T>(set: ObservableSet<T>): readonly T[];
                                                                                                  <T>(ar: IObservableArray<T>): readonly T[];
                                                                                                  <T = any>(obj: T): readonly (T extends object ? T[keyof T] : any)[];
                                                                                                  };

                                                                                                    function when

                                                                                                    when: {
                                                                                                    (predicate: () => boolean, opts?: IWhenOptions): Promise<void> & {
                                                                                                    cancel(): void;
                                                                                                    };
                                                                                                    (
                                                                                                    predicate: () => boolean,
                                                                                                    effect: Lambda,
                                                                                                    opts?: IWhenOptions
                                                                                                    ): IReactionDisposer;
                                                                                                    };

                                                                                                      Classes

                                                                                                      class ObservableMap

                                                                                                      class ObservableMap<K = any, V = any>
                                                                                                      implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {}

                                                                                                        constructor

                                                                                                        constructor(
                                                                                                        initialData?: IObservableMapInitialValues<K, V>,
                                                                                                        enhancer_?: IEnhancer<V>,
                                                                                                        name_?: string
                                                                                                        );

                                                                                                          property [$mobx]

                                                                                                          [$mobx]: {};

                                                                                                            property [Symbol.toStringTag]

                                                                                                            readonly [Symbol.toStringTag]: string;

                                                                                                              property changeListeners_

                                                                                                              changeListeners_: any;

                                                                                                                property data_

                                                                                                                data_: Map<K, ObservableValue<V>>;

                                                                                                                  property dehancer

                                                                                                                  dehancer: any;

                                                                                                                    property enhancer_

                                                                                                                    enhancer_: IEnhancer<V>;

                                                                                                                      property hasMap_

                                                                                                                      hasMap_: Map<K, ObservableValue<boolean>>;

                                                                                                                        property interceptors_

                                                                                                                        interceptors_: any;

                                                                                                                          property keysAtom_

                                                                                                                          keysAtom_: IAtom;

                                                                                                                            property name_

                                                                                                                            name_: string;

                                                                                                                              property size

                                                                                                                              readonly size: number;

                                                                                                                                method [Symbol.iterator]

                                                                                                                                [Symbol.iterator]: () => IterableIterator<IMapEntry<K, V>>;

                                                                                                                                  method clear

                                                                                                                                  clear: () => void;

                                                                                                                                    method delete

                                                                                                                                    delete: (key: K) => boolean;

                                                                                                                                      method entries

                                                                                                                                      entries: () => IterableIterator<IMapEntry<K, V>>;

                                                                                                                                        method forEach

                                                                                                                                        forEach: (
                                                                                                                                        callback: (value: V, key: K, object: Map<K, V>) => void,
                                                                                                                                        thisArg?: any
                                                                                                                                        ) => void;

                                                                                                                                          method get

                                                                                                                                          get: (key: K) => V | undefined;

                                                                                                                                            method has

                                                                                                                                            has: (key: K) => boolean;

                                                                                                                                              method intercept_

                                                                                                                                              intercept_: (handler: IInterceptor<IMapWillChange<K, V>>) => Lambda;

                                                                                                                                                method keys

                                                                                                                                                keys: () => IterableIterator<K>;

                                                                                                                                                  method merge

                                                                                                                                                  merge: (
                                                                                                                                                  other: ObservableMap<K, V> | IKeyValueMap<V> | any
                                                                                                                                                  ) => ObservableMap<K, V>;
                                                                                                                                                  • Merge another object into this object, returns this.

                                                                                                                                                  method observe_

                                                                                                                                                  observe_: (
                                                                                                                                                  listener: (changes: IMapDidChange<K, V>) => void,
                                                                                                                                                  fireImmediately?: boolean
                                                                                                                                                  ) => Lambda;
                                                                                                                                                  • 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

                                                                                                                                                  method replace

                                                                                                                                                  replace: (
                                                                                                                                                  values: ObservableMap<K, V> | IKeyValueMap<V> | any
                                                                                                                                                  ) => ObservableMap<K, V>;

                                                                                                                                                    method set

                                                                                                                                                    set: (key: K, value: V) => this;

                                                                                                                                                      method toJSON

                                                                                                                                                      toJSON: () => [K, V][];

                                                                                                                                                        method toString

                                                                                                                                                        toString: () => string;

                                                                                                                                                          method values

                                                                                                                                                          values: () => IterableIterator<V>;

                                                                                                                                                            class ObservableSet

                                                                                                                                                            class ObservableSet<T = any>
                                                                                                                                                            implements Set<T>, IInterceptable<ISetWillChange>, IListenable {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(
                                                                                                                                                              initialData?: IObservableSetInitialValues<T>,
                                                                                                                                                              enhancer?: IEnhancer<T>,
                                                                                                                                                              name_?: string
                                                                                                                                                              );

                                                                                                                                                                property [$mobx]

                                                                                                                                                                [$mobx]: {};

                                                                                                                                                                  property [Symbol.toStringTag]

                                                                                                                                                                  readonly [Symbol.toStringTag]: string;

                                                                                                                                                                    property changeListeners_

                                                                                                                                                                    changeListeners_: any;

                                                                                                                                                                      property dehancer

                                                                                                                                                                      dehancer: any;

                                                                                                                                                                        property enhancer_

                                                                                                                                                                        enhancer_: (newV: any, oldV: any | undefined) => any;

                                                                                                                                                                          property interceptors_

                                                                                                                                                                          interceptors_: any;

                                                                                                                                                                            property name_

                                                                                                                                                                            name_: string;

                                                                                                                                                                              property size

                                                                                                                                                                              readonly size: number;

                                                                                                                                                                                method [Symbol.iterator]

                                                                                                                                                                                [Symbol.iterator]: () => IterableIterator<T>;

                                                                                                                                                                                  method add

                                                                                                                                                                                  add: (value: T) => this;

                                                                                                                                                                                    method clear

                                                                                                                                                                                    clear: () => void;

                                                                                                                                                                                      method delete

                                                                                                                                                                                      delete: (value: any) => boolean;

                                                                                                                                                                                        method entries

                                                                                                                                                                                        entries: () => IterableIterator<[T, T]>;

                                                                                                                                                                                          method forEach

                                                                                                                                                                                          forEach: (
                                                                                                                                                                                          callbackFn: (value: T, value2: T, set: Set<T>) => void,
                                                                                                                                                                                          thisArg?: any
                                                                                                                                                                                          ) => void;

                                                                                                                                                                                            method has

                                                                                                                                                                                            has: (value: any) => boolean;

                                                                                                                                                                                              method intercept_

                                                                                                                                                                                              intercept_: (handler: IInterceptor<ISetWillChange<T>>) => Lambda;

                                                                                                                                                                                                method keys

                                                                                                                                                                                                keys: () => IterableIterator<T>;

                                                                                                                                                                                                  method observe_

                                                                                                                                                                                                  observe_: (
                                                                                                                                                                                                  listener: (changes: ISetDidChange<T>) => void,
                                                                                                                                                                                                  fireImmediately?: boolean
                                                                                                                                                                                                  ) => Lambda;

                                                                                                                                                                                                    method replace

                                                                                                                                                                                                    replace: (
                                                                                                                                                                                                    other: ObservableSet<T> | IObservableSetInitialValues<T>
                                                                                                                                                                                                    ) => ObservableSet<T>;

                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                      toJSON: () => T[];

                                                                                                                                                                                                        method toString

                                                                                                                                                                                                        toString: () => string;

                                                                                                                                                                                                          method values

                                                                                                                                                                                                          values: () => IterableIterator<T>;

                                                                                                                                                                                                            class Reaction

                                                                                                                                                                                                            class Reaction implements IDerivation, IReactionPublic {}

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                              name_?: string,
                                                                                                                                                                                                              onInvalidate_: () => void,
                                                                                                                                                                                                              errorHandler_?: (error: any, derivation: IDerivation) => void,
                                                                                                                                                                                                              requiresObservable_?: boolean
                                                                                                                                                                                                              );

                                                                                                                                                                                                                property dependenciesState_

                                                                                                                                                                                                                dependenciesState_: IDerivationState_;

                                                                                                                                                                                                                  property diffValue_

                                                                                                                                                                                                                  diffValue_: number;

                                                                                                                                                                                                                    property isDisposed_

                                                                                                                                                                                                                    isDisposed_: boolean;

                                                                                                                                                                                                                      property isRunning_

                                                                                                                                                                                                                      isRunning_: boolean;

                                                                                                                                                                                                                        property isScheduled_

                                                                                                                                                                                                                        isScheduled_: boolean;

                                                                                                                                                                                                                          property isTracing_

                                                                                                                                                                                                                          isTracing_: TraceMode;

                                                                                                                                                                                                                            property isTrackPending_

                                                                                                                                                                                                                            isTrackPending_: boolean;

                                                                                                                                                                                                                              property name_

                                                                                                                                                                                                                              name_: string;

                                                                                                                                                                                                                                property newObserving_

                                                                                                                                                                                                                                newObserving_: IObservable[];

                                                                                                                                                                                                                                  property observing_

                                                                                                                                                                                                                                  observing_: IObservable[];

                                                                                                                                                                                                                                    property requiresObservable_

                                                                                                                                                                                                                                    requiresObservable_: boolean;

                                                                                                                                                                                                                                      property runId_

                                                                                                                                                                                                                                      runId_: number;

                                                                                                                                                                                                                                        property unboundDepsCount_

                                                                                                                                                                                                                                        unboundDepsCount_: number;

                                                                                                                                                                                                                                          method dispose

                                                                                                                                                                                                                                          dispose: () => void;

                                                                                                                                                                                                                                            method getDisposer_

                                                                                                                                                                                                                                            getDisposer_: () => IReactionDisposer;

                                                                                                                                                                                                                                              method isScheduled

                                                                                                                                                                                                                                              isScheduled: () => boolean;

                                                                                                                                                                                                                                                method onBecomeStale_

                                                                                                                                                                                                                                                onBecomeStale_: () => void;

                                                                                                                                                                                                                                                  method reportExceptionInDerivation_

                                                                                                                                                                                                                                                  reportExceptionInDerivation_: (error: any) => void;

                                                                                                                                                                                                                                                    method runReaction_

                                                                                                                                                                                                                                                    runReaction_: () => void;
                                                                                                                                                                                                                                                    • internal, use schedule() if you intend to kick off a reaction

                                                                                                                                                                                                                                                    method schedule_

                                                                                                                                                                                                                                                    schedule_: () => void;

                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                      toString: () => string;

                                                                                                                                                                                                                                                        method trace

                                                                                                                                                                                                                                                        trace: (enterBreakPoint?: boolean) => void;

                                                                                                                                                                                                                                                          method track

                                                                                                                                                                                                                                                          track: (fn: () => void) => void;

                                                                                                                                                                                                                                                            Interfaces

                                                                                                                                                                                                                                                            interface IActionFactory

                                                                                                                                                                                                                                                            interface IActionFactory extends Annotation, PropertyDecorator {}

                                                                                                                                                                                                                                                              property bound

                                                                                                                                                                                                                                                              bound: Annotation & PropertyDecorator;

                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                <T extends Function | undefined | null>(fn: T): T;

                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                  <T extends Function | undefined | null>(name: string, fn: T): T;

                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                    (customName: string): PropertyDecorator & Annotation;

                                                                                                                                                                                                                                                                      interface IActionRunInfo

                                                                                                                                                                                                                                                                      interface IActionRunInfo {}

                                                                                                                                                                                                                                                                        property actionId_

                                                                                                                                                                                                                                                                        actionId_: number;

                                                                                                                                                                                                                                                                          property error_

                                                                                                                                                                                                                                                                          error_?: any;

                                                                                                                                                                                                                                                                            property notifySpy_

                                                                                                                                                                                                                                                                            notifySpy_: boolean;

                                                                                                                                                                                                                                                                              property parentActionId_

                                                                                                                                                                                                                                                                              parentActionId_: number;

                                                                                                                                                                                                                                                                                property prevAllowStateChanges_

                                                                                                                                                                                                                                                                                prevAllowStateChanges_: boolean;

                                                                                                                                                                                                                                                                                  property prevAllowStateReads_

                                                                                                                                                                                                                                                                                  prevAllowStateReads_: boolean;

                                                                                                                                                                                                                                                                                    property prevDerivation_

                                                                                                                                                                                                                                                                                    prevDerivation_: IDerivation | null;

                                                                                                                                                                                                                                                                                      property runAsAction_

                                                                                                                                                                                                                                                                                      runAsAction_?: boolean;

                                                                                                                                                                                                                                                                                        property startTime_

                                                                                                                                                                                                                                                                                        startTime_: number;

                                                                                                                                                                                                                                                                                          interface IArraySplice

                                                                                                                                                                                                                                                                                          interface IArraySplice<T = any> extends IArrayBaseChange<T> {}

                                                                                                                                                                                                                                                                                            property added

                                                                                                                                                                                                                                                                                            added: T[];

                                                                                                                                                                                                                                                                                              property addedCount

                                                                                                                                                                                                                                                                                              addedCount: number;

                                                                                                                                                                                                                                                                                                property removed

                                                                                                                                                                                                                                                                                                removed: T[];

                                                                                                                                                                                                                                                                                                  property removedCount

                                                                                                                                                                                                                                                                                                  removedCount: number;

                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                    type: 'splice';

                                                                                                                                                                                                                                                                                                      interface IArrayUpdate

                                                                                                                                                                                                                                                                                                      interface IArrayUpdate<T = any> extends IArrayBaseChange<T> {}

                                                                                                                                                                                                                                                                                                        property newValue

                                                                                                                                                                                                                                                                                                        newValue: T;

                                                                                                                                                                                                                                                                                                          property oldValue

                                                                                                                                                                                                                                                                                                          oldValue: T;

                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                            type: 'update';

                                                                                                                                                                                                                                                                                                              interface IArrayWillChange

                                                                                                                                                                                                                                                                                                              interface IArrayWillChange<T = any> {}

                                                                                                                                                                                                                                                                                                                property index

                                                                                                                                                                                                                                                                                                                index: number;

                                                                                                                                                                                                                                                                                                                  property newValue

                                                                                                                                                                                                                                                                                                                  newValue: T;

                                                                                                                                                                                                                                                                                                                    property object

                                                                                                                                                                                                                                                                                                                    object: IObservableArray<T>;

                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                      type: 'update';

                                                                                                                                                                                                                                                                                                                        interface IArrayWillSplice

                                                                                                                                                                                                                                                                                                                        interface IArrayWillSplice<T = any> {}

                                                                                                                                                                                                                                                                                                                          property added

                                                                                                                                                                                                                                                                                                                          added: T[];

                                                                                                                                                                                                                                                                                                                            property index

                                                                                                                                                                                                                                                                                                                            index: number;

                                                                                                                                                                                                                                                                                                                              property object

                                                                                                                                                                                                                                                                                                                              object: IObservableArray<T>;

                                                                                                                                                                                                                                                                                                                                property removedCount

                                                                                                                                                                                                                                                                                                                                removedCount: number;

                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                  type: 'splice';

                                                                                                                                                                                                                                                                                                                                    interface IAtom

                                                                                                                                                                                                                                                                                                                                    interface IAtom extends IObservable {}

                                                                                                                                                                                                                                                                                                                                      method reportChanged

                                                                                                                                                                                                                                                                                                                                      reportChanged: () => any;

                                                                                                                                                                                                                                                                                                                                        method reportObserved

                                                                                                                                                                                                                                                                                                                                        reportObserved: () => boolean;

                                                                                                                                                                                                                                                                                                                                          interface IAutorunOptions

                                                                                                                                                                                                                                                                                                                                          interface IAutorunOptions {}

                                                                                                                                                                                                                                                                                                                                            property delay

                                                                                                                                                                                                                                                                                                                                            delay?: number;

                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                              name?: string;

                                                                                                                                                                                                                                                                                                                                                property onError

                                                                                                                                                                                                                                                                                                                                                onError?: (error: any) => void;

                                                                                                                                                                                                                                                                                                                                                  property requiresObservable

                                                                                                                                                                                                                                                                                                                                                  requiresObservable?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Experimental. Warns if the view doesn't track observables

                                                                                                                                                                                                                                                                                                                                                  property scheduler

                                                                                                                                                                                                                                                                                                                                                  scheduler?: (callback: () => void) => any;

                                                                                                                                                                                                                                                                                                                                                    interface IComputedFactory

                                                                                                                                                                                                                                                                                                                                                    interface IComputedFactory extends Annotation, PropertyDecorator {}

                                                                                                                                                                                                                                                                                                                                                      property struct

                                                                                                                                                                                                                                                                                                                                                      struct: Annotation & PropertyDecorator;

                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                        <T>(options: IComputedValueOptions<T>): Annotation & PropertyDecorator;

                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                          <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>;

                                                                                                                                                                                                                                                                                                                                                            interface IComputedValue

                                                                                                                                                                                                                                                                                                                                                            interface IComputedValue<T> {}

                                                                                                                                                                                                                                                                                                                                                              method get

                                                                                                                                                                                                                                                                                                                                                              get: () => T;

                                                                                                                                                                                                                                                                                                                                                                method observe_

                                                                                                                                                                                                                                                                                                                                                                observe_: (
                                                                                                                                                                                                                                                                                                                                                                listener: (change: IComputedDidChange<T>) => void,
                                                                                                                                                                                                                                                                                                                                                                fireImmediately?: boolean
                                                                                                                                                                                                                                                                                                                                                                ) => Lambda;

                                                                                                                                                                                                                                                                                                                                                                  method set

                                                                                                                                                                                                                                                                                                                                                                  set: (value: T) => void;

                                                                                                                                                                                                                                                                                                                                                                    interface IComputedValueOptions

                                                                                                                                                                                                                                                                                                                                                                    interface IComputedValueOptions<T> {}

                                                                                                                                                                                                                                                                                                                                                                      property context

                                                                                                                                                                                                                                                                                                                                                                      context?: any;

                                                                                                                                                                                                                                                                                                                                                                        property equals

                                                                                                                                                                                                                                                                                                                                                                        equals?: IEqualsComparer<T>;

                                                                                                                                                                                                                                                                                                                                                                          property get

                                                                                                                                                                                                                                                                                                                                                                          get?: () => T;

                                                                                                                                                                                                                                                                                                                                                                            property keepAlive

                                                                                                                                                                                                                                                                                                                                                                            keepAlive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                              name?: string;

                                                                                                                                                                                                                                                                                                                                                                                property requiresReaction

                                                                                                                                                                                                                                                                                                                                                                                requiresReaction?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                  property set

                                                                                                                                                                                                                                                                                                                                                                                  set?: (value: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                    interface IDependencyTree

                                                                                                                                                                                                                                                                                                                                                                                    interface IDependencyTree {}

                                                                                                                                                                                                                                                                                                                                                                                      property dependencies

                                                                                                                                                                                                                                                                                                                                                                                      dependencies?: IDependencyTree[];

                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                          interface IDepTreeNode

                                                                                                                                                                                                                                                                                                                                                                                          interface IDepTreeNode {}

                                                                                                                                                                                                                                                                                                                                                                                            property name_

                                                                                                                                                                                                                                                                                                                                                                                            name_: string;

                                                                                                                                                                                                                                                                                                                                                                                              property observing_

                                                                                                                                                                                                                                                                                                                                                                                              observing_?: IObservable[];

                                                                                                                                                                                                                                                                                                                                                                                                interface IEnhancer

                                                                                                                                                                                                                                                                                                                                                                                                interface IEnhancer<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                  (newValue: T, oldValue: T | undefined, name: string): T;

                                                                                                                                                                                                                                                                                                                                                                                                    interface IEqualsComparer

                                                                                                                                                                                                                                                                                                                                                                                                    interface IEqualsComparer<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                      (a: T, b: T): boolean;

                                                                                                                                                                                                                                                                                                                                                                                                        interface IInterceptable

                                                                                                                                                                                                                                                                                                                                                                                                        interface IInterceptable<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property interceptors_

                                                                                                                                                                                                                                                                                                                                                                                                          interceptors_: IInterceptor<T>[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            interface IKeyValueMap

                                                                                                                                                                                                                                                                                                                                                                                                            interface IKeyValueMap<V = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: V;

                                                                                                                                                                                                                                                                                                                                                                                                                interface IListenable

                                                                                                                                                                                                                                                                                                                                                                                                                interface IListenable {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property changeListeners_

                                                                                                                                                                                                                                                                                                                                                                                                                  changeListeners_: Function[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                    interface IMapWillChange

                                                                                                                                                                                                                                                                                                                                                                                                                    interface IMapWillChange<K = any, V = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: K;

                                                                                                                                                                                                                                                                                                                                                                                                                        property newValue

                                                                                                                                                                                                                                                                                                                                                                                                                        newValue?: V;

                                                                                                                                                                                                                                                                                                                                                                                                                          property object

                                                                                                                                                                                                                                                                                                                                                                                                                          object: ObservableMap<K, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'update' | 'add' | 'delete';

                                                                                                                                                                                                                                                                                                                                                                                                                              interface IObservable

                                                                                                                                                                                                                                                                                                                                                                                                                              interface IObservable extends IDepTreeNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property diffValue_

                                                                                                                                                                                                                                                                                                                                                                                                                                diffValue_: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property isBeingObserved_

                                                                                                                                                                                                                                                                                                                                                                                                                                  isBeingObserved_: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isPendingUnobservation_

                                                                                                                                                                                                                                                                                                                                                                                                                                    isPendingUnobservation_: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property lastAccessedBy_

                                                                                                                                                                                                                                                                                                                                                                                                                                      lastAccessedBy_: 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

                                                                                                                                                                                                                                                                                                                                                                                                                                      property lowestObserverState_

                                                                                                                                                                                                                                                                                                                                                                                                                                      lowestObserverState_: IDerivationState_;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property observers_

                                                                                                                                                                                                                                                                                                                                                                                                                                        observers_: Set<IDerivation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property onBOL

                                                                                                                                                                                                                                                                                                                                                                                                                                          onBOL: Set<Lambda> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property onBUOL

                                                                                                                                                                                                                                                                                                                                                                                                                                            onBUOL: Set<Lambda> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method onBO

                                                                                                                                                                                                                                                                                                                                                                                                                                              onBO: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method onBUO

                                                                                                                                                                                                                                                                                                                                                                                                                                                onBUO: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IObservableArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IObservableArray<T = any> extends Array<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                    clear: () => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                      remove: (value: T) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                        replace: (newItems: T[]) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method spliceWithArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                          spliceWithArray: (index: number, deleteCount?: number, newItems?: T[]) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                            toJSON: () => T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IObservableFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IObservableFactory extends Annotation, PropertyDecorator {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property array

                                                                                                                                                                                                                                                                                                                                                                                                                                                                array: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                initialValues?: T[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => IObservableArray<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property box

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  box: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value?: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => IObservableValue<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property deep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deep: Annotation & PropertyDecorator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      map: <K = any, V = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      initialValues?: IObservableMapInitialValues<K, V>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ObservableMap<K, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        object: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        props: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        decorators?: AnnotationsMap<T, never>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ref: Annotation & PropertyDecorator;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Decorator that creates an observable that only observes the references, but doesn't try to turn the assigned value into an observable.ts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          set: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          initialValues?: IObservableSetInitialValues<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ObservableSet<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property shallow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            shallow: Annotation & PropertyDecorator;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property struct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            struct: Annotation & PropertyDecorator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <T = any>(value: Set<T>, options?: CreateObservableOptions): ObservableSet<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <K = any, V = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Map<K, V>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): ObservableMap<K, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <T extends object>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    decorators?: AnnotationsMap<T, never>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: CreateObservableOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IObservableValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IObservableValue<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        get: () => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method intercept_

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          intercept_: (handler: IInterceptor<IValueWillChange<T>>) => Lambda;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method observe_

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            observe_: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            listener: (change: IValueDidChange<T>) => void,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fireImmediately?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Lambda;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              set: (value: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IObserverTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IObserverTree {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property observers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    observers?: IObserverTree[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IReactionDisposer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IReactionDisposer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property $mobx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $mobx: Reaction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IReactionPublic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IReactionPublic {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dispose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method trace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              trace: (enterBreakPoint?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IValueWillChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IValueWillChange<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property newValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  newValue: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    object: IObservableValue<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'update';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IWhenOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IWhenOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onError?: (error: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Lambda

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Lambda {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AnnotationMapEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AnnotationMapEntry =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Annotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | true /* follow the default decorator, usually deep */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AnnotationsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AnnotationsMap<T, AdditionalFields extends PropertyKey> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [P in Exclude<keyof T, 'toString'>]?: AnnotationMapEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<AdditionalFields, AnnotationMapEntry>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateObservableOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateObservableOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          equals?: IEqualsComparer<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deep?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultDecorator?: Annotation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          proxy?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoBind?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IArrayDidChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IArrayDidChange<T = any> = IArrayUpdate<T> | IArraySplice<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IInterceptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IInterceptor<T> = (change: T) => T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IMapDidChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IMapDidChange<K = any, V = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                observableKind: 'map';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                debugObjectName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } & (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                object: ObservableMap<K, V>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: K; // actual the key or index, but this is based on the ancient .observe proposal for consistency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IMapEntries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IMapEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IMapEntry<K = any, V = any> = [K, V];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IObjectDidChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IObjectDidChange<T = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      observableKind: 'object';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: PropertyKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      object: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      debugObjectName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'add';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      newValue: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'update';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      oldValue: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      newValue: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'remove';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      oldValue: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IObjectWillChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IObjectWillChange<T = any> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        object: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'update' | 'add';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: PropertyKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        newValue: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        object: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'remove';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: PropertyKey;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IObservableMapInitialValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IObservableMapInitialValues<K = any, V = any> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | IMapEntries<K, V>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | IKeyValueMap<V>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Map<K, V>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IObservableSetInitialValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IObservableSetInitialValues<T> = Set<T> | readonly T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IReactionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IReactionOptions<T, FireImmediately extends boolean> = IAutorunOptions & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fireImmediately?: FireImmediately;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              equals?: IEqualsComparer<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ISetDidChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ISetDidChange<T = any> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                object: ObservableSet<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                observableKind: 'set';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                debugObjectName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'add';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                newValue: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                object: ObservableSet<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                observableKind: 'set';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                debugObjectName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'delete';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                oldValue: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ISetWillChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ISetWillChange<T = any> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'delete';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  object: ObservableSet<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  oldValue: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'add';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  object: ObservableSet<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  newValue: T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IValueDidChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IValueDidChange<T = any> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'update';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    observableKind: 'value';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    object: IObservableValue<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debugObjectName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    newValue: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    oldValue: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (40)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (9)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/mobx.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/mobx)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/mobx"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>