mobx-state-tree 3.12.2 → 3.15.0

package/dist/core/type/type.d.ts

@@ -1,177 +1,162 @@
-import { IValidationContext, IValidationResult, IStateTreeNode, ModelPrimitive } from "../../internal";
-/**
- * Name of the properties of an object that can't be set to undefined
- * @hidden
- */
-export declare type DefinablePropsNames<T> = {
-    [K in keyof T]: Extract<T[K], undefined> extends never ? K : never;
-}[keyof T];
-/**
- * Checks if a type is any or unknown
- * @hidden
- */
-export declare type IsTypeAnyOrUnknown<T> = unknown extends T ? true : false;
-declare type WithoutUndefined<T> = T extends undefined ? never : T;
-/**
- * Checks if a type is optional (its creation snapshot can be undefined) or not.
- * @hidden
- *
- * Examples:
- * - string = false
- * - undefined = true
- * - string | undefined = true
- * - string & undefined = true
- * - any = true
- * - unknown = true
- */
-export declare type IsOptionalType<IT extends IAnyType> = ExtractC<IT> extends WithoutUndefined<ExtractC<IT>> ? IsTypeAnyOrUnknown<ExtractC<IT>> : true;
-/**
- * Checks if a type supports an empty create() function
- * Basically !any, !unknown, X | undefined, objects with all properties being optional
- * @hidden
- */
-export declare type IsEmptyCreationType<O> = IsTypeAnyOrUnknown<O> extends true ? true : Extract<O, undefined> extends never ? (DefinablePropsNames<O> extends never | undefined ? true : false) : true;
-/**
- * Chooses a create function based on the creation type.
- * @hidden
- */
-export declare type CreateParams<C> = IsEmptyCreationType<C> extends false ? [C, any?] : [C?, any?];
-/**
- * @hidden
- */
-export declare type STNValue<T, IT extends IAnyType> = T extends object ? T & IStateTreeNode<IT> : T;
-/**
- * A type, either complex or simple.
- */
-export interface IType<C, S, T> {
-    /**
-     * Friendly type name.
-     */
-    name: string;
-    /**
-     * Name of the dentifier attribute or null if none.
-     */
-    readonly identifierAttribute?: string;
-    create(...args: CreateParams<C>): STNValue<T, this>;
-    /**
-     * Creates an instance for the type given an snapshot input.
-     *
-     * @returns An instance of that type.
-     */
-    create(snapshot: C, env?: any): STNValue<T, this>;
-    /**
-     * Checks if a given snapshot / instance is of the given type.
-     *
-     * @param thing Snapshot or instance to be checked.
-     * @returns true if the value is of the current type, false otherwise.
-     */
-    is(thing: any): thing is C | STNValue<T, this>;
-    /**
-     * Run's the type's typechecker on the given value with the given validation context.
-     *
-     * @param thing Value to be checked, either a snapshot or an instance.
-     * @param context Validation context, an array of { subpaths, subtypes } that should be validated
-     * @returns The validation result, an array with the list of validation errors.
-     */
-    validate(thing: C, context: IValidationContext): IValidationResult;
-    /**
-     * Gets the textual representation of the type as a string.
-     */
-    describe(): string;
-    /**
-     * @deprecated use `Instance<typeof MyType>` instead.
-     * @hidden
-     */
-    readonly Type: STNValue<T, this>;
-    /**
-     * @deprecated use `SnapshotOut<typeof MyType>` instead.
-     * @hidden
-     */
-    readonly SnapshotType: S;
-    /**
-     * @deprecated use `SnapshotIn<typeof MyType>` instead.
-     * @hidden
-     */
-    readonly CreationType: C;
-}
-/**
- * Any kind of type.
- */
-export declare type IAnyType = IType<any, any, any>;
-/**
- * A simple type, this is, a type where the instance and the snapshot representation are the same.
- */
-export interface ISimpleType<T> extends IType<T, T, T> {
-}
-/** @hidden */
-export declare type Primitives = ModelPrimitive | null | undefined;
-/**
- * A complex type.
- * @deprecated just for compatibility with old versions, could be deprecated on the next major version
- * @hidden
- */
-export interface IComplexType<C, S, T> extends IType<C, S, T & object> {
-}
-/**
- * Any kind of complex type.
- */
-export declare type IAnyComplexType = IType<any, any, object>;
-/** @hidden */
-export declare type ExtractC<T extends IAnyType> = T extends IType<infer C, any, any> ? C : never;
-/** @hidden */
-export declare type ExtractS<T extends IAnyType> = T extends IType<any, infer S, any> ? S : never;
-/** @hidden */
-export declare type ExtractTWithoutSTN<T extends IAnyType> = T extends IType<any, any, infer X> ? X : never;
-/** @hidden */
-export declare type ExtractTWithSTN<T extends IAnyType> = T extends IType<any, any, infer X> ? X extends object ? X & IStateTreeNode<T> : X : never;
-/** @hidden */
-export declare type ExtractCSTWithoutSTN<IT extends IAnyType> = IT extends IType<infer C, infer S, infer T> ? C | S | T : never;
-/** @hidden */
-export declare type ExtractCSTWithSTN<IT extends IAnyType> = IT extends IType<infer C, infer S, infer T> ? C | S | ExtractTWithSTN<IT> : never;
-/**
- * The instance representation of a given type.
- */
-export declare type Instance<T> = T extends IType<any, any, infer TT> ? (TT extends object ? TT & IStateTreeNode<T> : TT) : T;
-/**
- * The input (creation) snapshot representation of a given type.
- */
-export declare type SnapshotIn<T> = T extends IStateTreeNode<IType<infer STNC, any, any>> ? STNC : T extends IType<infer TC, any, any> ? TC : T;
-/**
- * The output snapshot representation of a given type.
- */
-export declare type SnapshotOut<T> = T extends IStateTreeNode<IType<any, infer STNS, any>> ? STNS : T extends IType<any, infer TS, any> ? TS : T;
-/**
- * A type which is equivalent to the union of SnapshotIn and Instance types of a given typeof TYPE or typeof VARIABLE.
- * For primitives it defaults to the primitive itself.
- *
- * For example:
- * - `SnapshotOrInstance<typeof ModelA> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`
- * - `SnapshotOrInstance<typeof self.a (where self.a is a ModelA)> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`
- *
- * Usually you might want to use this when your model has a setter action that sets a property.
- *
- * Example:
- * ```ts
- * const ModelA = types.model({
- *   n: types.number
- * })
- *
- * const ModelB = types.model({
- *   innerModel: ModelA
- * }).actions(self => ({
- *   // this will accept as property both the snapshot and the instance, whichever is preferred
- *   setInnerModel(m: SnapshotOrInstance<typeof self.innerModel>) {
- *     self.innerModel = cast(m)
- *   }
- * }))
- * ```
- */
-export declare type SnapshotOrInstance<T> = SnapshotIn<T> | Instance<T>;
-/**
- * Returns if a given value represents a type.
- *
- * @param value Value to check.
- * @returns `true` if the value is a type.
- */
-export declare function isType(value: any): value is IAnyType;
-export {};
+import { IValidationContext, IValidationResult, IStateTreeNode, ModelPrimitive } from "../../internal";
+/**
+ * A state tree node value.
+ * @hidden
+ */
+export declare type STNValue<T, IT extends IAnyType> = T extends object ? T & IStateTreeNode<IT> : T;
+/** @hidden */
+declare const $type: unique symbol;
+/**
+ * A type, either complex or simple.
+ */
+export interface IType<C, S, T> {
+    /** @hidden */
+    readonly [$type]: undefined;
+    /**
+     * Friendly type name.
+     */
+    name: string;
+    /**
+     * Name of the identifier attribute or null if none.
+     */
+    readonly identifierAttribute?: string;
+    /**
+     * Creates an instance for the type given an snapshot input.
+     *
+     * @returns An instance of that type.
+     */
+    create(snapshot?: C, env?: any): this["Type"];
+    /**
+     * Checks if a given snapshot / instance is of the given type.
+     *
+     * @param thing Snapshot or instance to be checked.
+     * @returns true if the value is of the current type, false otherwise.
+     */
+    is(thing: any): thing is C | this["Type"];
+    /**
+     * Run's the type's typechecker on the given value with the given validation context.
+     *
+     * @param thing Value to be checked, either a snapshot or an instance.
+     * @param context Validation context, an array of { subpaths, subtypes } that should be validated
+     * @returns The validation result, an array with the list of validation errors.
+     */
+    validate(thing: C, context: IValidationContext): IValidationResult;
+    /**
+     * Gets the textual representation of the type as a string.
+     */
+    describe(): string;
+    /**
+     * @deprecated use `Instance<typeof MyType>` instead.
+     * @hidden
+     */
+    readonly Type: STNValue<T, this>;
+    /**
+     * @deprecated do not use.
+     * @hidden
+     */
+    readonly TypeWithoutSTN: T;
+    /**
+     * @deprecated use `SnapshotOut<typeof MyType>` instead.
+     * @hidden
+     */
+    readonly SnapshotType: S;
+    /**
+     * @deprecated use `SnapshotIn<typeof MyType>` instead.
+     * @hidden
+     */
+    readonly CreationType: C;
+}
+/**
+ * Any kind of type.
+ */
+export interface IAnyType extends IType<any, any, any> {
+}
+/**
+ * A simple type, this is, a type where the instance and the snapshot representation are the same.
+ */
+export interface ISimpleType<T> extends IType<T, T, T> {
+}
+/** @hidden */
+export declare type Primitives = ModelPrimitive | null | undefined;
+/**
+ * A complex type.
+ * @deprecated just for compatibility with old versions, could be deprecated on the next major version
+ * @hidden
+ */
+export interface IComplexType<C, S, T> extends IType<C, S, T & object> {
+}
+/**
+ * Any kind of complex type.
+ */
+export interface IAnyComplexType extends IType<any, any, object> {
+}
+/** @hidden */
+export declare type ExtractCSTWithoutSTN<IT extends {
+    [$type]: undefined;
+    CreationType: any;
+    SnapshotType: any;
+    TypeWithoutSTN: any;
+}> = IT["CreationType"] | IT["SnapshotType"] | IT["TypeWithoutSTN"];
+/** @hidden */
+export declare type ExtractCSTWithSTN<IT extends {
+    [$type]: undefined;
+    CreationType: any;
+    SnapshotType: any;
+    Type: any;
+}> = IT["CreationType"] | IT["SnapshotType"] | IT["Type"];
+/**
+ * The instance representation of a given type.
+ */
+export declare type Instance<T> = T extends {
+    [$type]: undefined;
+    Type: any;
+} ? T["Type"] : T;
+/**
+ * The input (creation) snapshot representation of a given type.
+ */
+export declare type SnapshotIn<T> = T extends {
+    [$type]: undefined;
+    CreationType: any;
+} ? T["CreationType"] : T extends IStateTreeNode<infer IT> ? IT["CreationType"] : T;
+/**
+ * The output snapshot representation of a given type.
+ */
+export declare type SnapshotOut<T> = T extends {
+    [$type]: undefined;
+    SnapshotType: any;
+} ? T["SnapshotType"] : T extends IStateTreeNode<infer IT> ? IT["SnapshotType"] : T;
+/**
+ * A type which is equivalent to the union of SnapshotIn and Instance types of a given typeof TYPE or typeof VARIABLE.
+ * For primitives it defaults to the primitive itself.
+ *
+ * For example:
+ * - `SnapshotOrInstance<typeof ModelA> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`
+ * - `SnapshotOrInstance<typeof self.a (where self.a is a ModelA)> = SnapshotIn<typeof ModelA> | Instance<typeof ModelA>`
+ *
+ * Usually you might want to use this when your model has a setter action that sets a property.
+ *
+ * Example:
+ * ```ts
+ * const ModelA = types.model({
+ *   n: types.number
+ * })
+ *
+ * const ModelB = types.model({
+ *   innerModel: ModelA
+ * }).actions(self => ({
+ *   // this will accept as property both the snapshot and the instance, whichever is preferred
+ *   setInnerModel(m: SnapshotOrInstance<typeof self.innerModel>) {
+ *     self.innerModel = cast(m)
+ *   }
+ * }))
+ * ```
+ */
+export declare type SnapshotOrInstance<T> = SnapshotIn<T> | Instance<T>;
+/**
+ * Returns if a given value represents a type.
+ *
+ * @param value Value to check.
+ * @returns `true` if the value is a type.
+ */
+export declare function isType(value: any): value is IAnyType;
+export {};

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { IModelType, IAnyModelType, IDisposer, IMSTMap, IMapType, IMSTArray, IArrayType, IType, IAnyType, ISimpleType, IComplexType, IAnyComplexType, IReferenceType, _CustomCSProcessor, _CustomOrOther, _CustomJoin, _NotCustomized, typecheck, escapeJsonPath, unescapeJsonPath, joinJsonPath, splitJsonPath, IJsonPatch, IReversibleJsonPatch, decorate, addMiddleware, IMiddlewareEvent, IMiddlewareHandler, IMiddlewareEventType, process, isStateTreeNode, IStateTreeNode, IAnyStateTreeNode, flow, castFlowReturn, applyAction, onAction, IActionRecorder, ISerializedActionCall, recordActions, createActionTrackingMiddleware, setLivelinessChecking, getLivelinessChecking, LivelinessMode, setLivelynessChecking, // to be deprecated
-LivelynessMode, // to be deprecated
-ModelSnapshotType, ModelCreationType, ModelSnapshotType2, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPropertiesDeclarationToProperties, ModelProperties, ModelPropertiesDeclaration, ModelActions, ITypeUnion, CustomTypeOptions, UnionOptions, Instance, SnapshotIn, SnapshotOut, SnapshotOrInstance, TypeOrStateTreeNodeToStateTreeNode, UnionStringArray, getType, getChildType, onPatch, onSnapshot, applyPatch, IPatchRecorder, recordPatches, protect, unprotect, isProtected, applySnapshot, getSnapshot, hasParent, getParent, hasParentOfType, getParentOfType, getRoot, getPath, getPathParts, isRoot, resolvePath, resolveIdentifier, getIdentifier, tryResolve, getRelativePath, clone, detach, destroy, isAlive, addDisposer, getEnv, walk, IModelReflectionData, IModelReflectionPropertiesData, IMaybeIType, IMaybe, IMaybeNull, IOptionalIType, OptionalDefaultValueOrFunction, ValidOptionalValue, ValidOptionalValues, getMembers, getPropertyMembers, TypeOfValue, cast, castToSnapshot, castToReferenceSnapshot, isType, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, IsOptionalType, isPrimitiveType, isReferenceType, isRefinementType, isUnionType, tryReference, isValidReference, OnReferenceInvalidated, OnReferenceInvalidatedEvent, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, ReferenceIdentifier, ISnapshotProcessor, ISnapshotProcessors, getNodeId, types } from "./internal";
+export { IModelType, IAnyModelType, IDisposer, IMSTMap, IMapType, IMSTArray, IArrayType, IType, IAnyType, ModelPrimitive, ISimpleType, IComplexType, IAnyComplexType, IReferenceType, _CustomCSProcessor, _CustomOrOther, _CustomJoin, _NotCustomized, typecheck, escapeJsonPath, unescapeJsonPath, joinJsonPath, splitJsonPath, IJsonPatch, IReversibleJsonPatch, decorate, addMiddleware, IMiddlewareEvent, IActionTrackingMiddleware2Call, IMiddlewareHandler, IMiddlewareEventType, IActionTrackingMiddlewareHooks, IActionTrackingMiddleware2Hooks, process, isStateTreeNode, IStateTreeNode, IAnyStateTreeNode, flow, castFlowReturn, applyAction, onAction, IActionRecorder, ISerializedActionCall, recordActions, createActionTrackingMiddleware, createActionTrackingMiddleware2, setLivelinessChecking, getLivelinessChecking, LivelinessMode, setLivelynessChecking, // to be deprecated
+LivelynessMode, // to be deprecated
+ModelSnapshotType, ModelCreationType, ModelSnapshotType2, ModelCreationType2, ModelInstanceType, ModelInstanceTypeProps, ModelPropertiesDeclarationToProperties, ModelProperties, ModelPropertiesDeclaration, ModelActions, ITypeUnion, CustomTypeOptions, UnionOptions, Instance, SnapshotIn, SnapshotOut, SnapshotOrInstance, TypeOrStateTreeNodeToStateTreeNode, UnionStringArray, getType, getChildType, onPatch, onSnapshot, applyPatch, IPatchRecorder, recordPatches, protect, unprotect, isProtected, applySnapshot, getSnapshot, hasParent, getParent, hasParentOfType, getParentOfType, getRoot, getPath, getPathParts, isRoot, resolvePath, resolveIdentifier, getIdentifier, tryResolve, getRelativePath, clone, detach, destroy, isAlive, addDisposer, getEnv, walk, IModelReflectionData, IModelReflectionPropertiesData, IMaybeIType, IMaybe, IMaybeNull, IOptionalIType, OptionalDefaultValueOrFunction, ValidOptionalValue, ValidOptionalValues, getMembers, getPropertyMembers, TypeOfValue, cast, castToSnapshot, castToReferenceSnapshot, isType, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isReferenceType, isRefinementType, isUnionType, tryReference, isValidReference, OnReferenceInvalidated, OnReferenceInvalidatedEvent, ReferenceOptions, ReferenceOptionsGetSet, ReferenceOptionsOnInvalidated, ReferenceIdentifier, ISnapshotProcessor, ISnapshotProcessors, getNodeId, IActionContext, getRunningActionContext, isActionContextChildOf, isActionContextThisOrChildOf, types } from "./internal";

package/dist/internal.d.ts

@@ -1,35 +1,37 @@
-export * from "./core/node/livelinessChecking";
-export * from "./core/node/Hook";
-export * from "./core/mst-operations";
-export * from "./core/node/BaseNode";
-export * from "./core/node/scalar-node";
-export * from "./core/node/object-node";
-export * from "./core/type/type";
-export * from "./middlewares/create-action-tracking-middleware";
-export * from "./middlewares/on-action";
-export * from "./core/action";
-export * from "./core/type/type-checker";
-export * from "./core/node/identifier-cache";
-export * from "./core/node/create-node";
-export * from "./core/node/node-utils";
-export * from "./core/process";
-export * from "./core/flow";
-export * from "./core/json-patch";
-export * from "./utils";
-export * from "./types/utility-types/snapshotProcessor";
-export * from "./types/complex-types/map";
-export * from "./types/complex-types/array";
-export * from "./types/complex-types/model";
-export * from "./types/primitives";
-export * from "./types/utility-types/literal";
-export * from "./types/utility-types/refinement";
-export * from "./types/utility-types/enumeration";
-export * from "./types/utility-types/union";
-export * from "./types/utility-types/optional";
-export * from "./types/utility-types/maybe";
-export * from "./types/utility-types/late";
-export * from "./types/utility-types/frozen";
-export * from "./types/utility-types/reference";
-export * from "./types/utility-types/identifier";
-export * from "./types/utility-types/custom";
-export * from "./types";
+export * from "./core/node/livelinessChecking";
+export * from "./core/node/Hook";
+export * from "./core/mst-operations";
+export * from "./core/node/BaseNode";
+export * from "./core/node/scalar-node";
+export * from "./core/node/object-node";
+export * from "./core/type/type";
+export * from "./middlewares/create-action-tracking-middleware";
+export * from "./middlewares/createActionTrackingMiddleware2";
+export * from "./middlewares/on-action";
+export * from "./core/action";
+export * from "./core/actionContext";
+export * from "./core/type/type-checker";
+export * from "./core/node/identifier-cache";
+export * from "./core/node/create-node";
+export * from "./core/node/node-utils";
+export * from "./core/process";
+export * from "./core/flow";
+export * from "./core/json-patch";
+export * from "./utils";
+export * from "./types/utility-types/snapshotProcessor";
+export * from "./types/complex-types/map";
+export * from "./types/complex-types/array";
+export * from "./types/complex-types/model";
+export * from "./types/primitives";
+export * from "./types/utility-types/literal";
+export * from "./types/utility-types/refinement";
+export * from "./types/utility-types/enumeration";
+export * from "./types/utility-types/union";
+export * from "./types/utility-types/optional";
+export * from "./types/utility-types/maybe";
+export * from "./types/utility-types/late";
+export * from "./types/utility-types/frozen";
+export * from "./types/utility-types/reference";
+export * from "./types/utility-types/identifier";
+export * from "./types/utility-types/custom";
+export * from "./types";

package/dist/middlewares/create-action-tracking-middleware.d.ts

@@ -1,22 +1,24 @@
-import { IMiddlewareEvent, IMiddlewareHandler } from "../internal";
-export interface IActionTrackingMiddlewareHooks<T> {
-    filter?: (call: IMiddlewareEvent) => boolean;
-    onStart: (call: IMiddlewareEvent) => T;
-    onResume: (call: IMiddlewareEvent, context: T) => void;
-    onSuspend: (call: IMiddlewareEvent, context: T) => void;
-    onSuccess: (call: IMiddlewareEvent, context: T, result: any) => void;
-    onFail: (call: IMiddlewareEvent, context: T, error: any) => void;
-}
-/**
- * Convenience utility to create action based middleware that supports async processes more easily.
- * All hooks are called for both synchronous and asynchronous actions. Except that either `onSuccess` or `onFail` is called
- *
- * The create middleware tracks the process of an action (assuming it passes the `filter`).
- * `onResume` can return any value, which will be passed as second argument to any other hook. This makes it possible to keep state during a process.
- *
- * See the `atomic` middleware for an example
- *
- * @param hooks
- * @returns
- */
-export declare function createActionTrackingMiddleware<T = any>(hooks: IActionTrackingMiddlewareHooks<T>): IMiddlewareHandler;
+import { IMiddlewareEvent, IMiddlewareHandler } from "../internal";
+export interface IActionTrackingMiddlewareHooks<T> {
+    filter?: (call: IMiddlewareEvent) => boolean;
+    onStart: (call: IMiddlewareEvent) => T;
+    onResume: (call: IMiddlewareEvent, context: T) => void;
+    onSuspend: (call: IMiddlewareEvent, context: T) => void;
+    onSuccess: (call: IMiddlewareEvent, context: T, result: any) => void;
+    onFail: (call: IMiddlewareEvent, context: T, error: any) => void;
+}
+/**
+ * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.
+ *
+ * Convenience utility to create action based middleware that supports async processes more easily.
+ * All hooks are called for both synchronous and asynchronous actions. Except that either `onSuccess` or `onFail` is called
+ *
+ * The create middleware tracks the process of an action (assuming it passes the `filter`).
+ * `onResume` can return any value, which will be passed as second argument to any other hook. This makes it possible to keep state during a process.
+ *
+ * See the `atomic` middleware for an example
+ *
+ * @param hooks
+ * @returns
+ */
+export declare function createActionTrackingMiddleware<T = any>(hooks: IActionTrackingMiddlewareHooks<T>): IMiddlewareHandler;

package/dist/middlewares/createActionTrackingMiddleware2.d.ts

@@ -0,0 +1,34 @@
+import { IMiddlewareHandler, IActionContext } from "../internal";
+export interface IActionTrackingMiddleware2Call<TEnv> extends Readonly<IActionContext> {
+    env: TEnv | undefined;
+    readonly parentCall?: IActionTrackingMiddleware2Call<TEnv>;
+}
+export interface IActionTrackingMiddleware2Hooks<TEnv> {
+    filter?: (call: IActionTrackingMiddleware2Call<TEnv>) => boolean;
+    onStart: (call: IActionTrackingMiddleware2Call<TEnv>) => void;
+    onFinish: (call: IActionTrackingMiddleware2Call<TEnv>, error?: any) => void;
+}
+/**
+ * Convenience utility to create action based middleware that supports async processes more easily.
+ * The flow is like this:
+ * - for each action: if filter passes -> `onStart` -> (inner actions recursively) -> `onFinish`
+ *
+ * Example: if we had an action `a` that called inside an action `b1`, then `b2` the flow would be:
+ * - `filter(a)`
+ * - `onStart(a)`
+ *   - `filter(b1)`
+ *   - `onStart(b1)`
+ *   - `onFinish(b1)`
+ *   - `filter(b2)`
+ *   - `onStart(b2)`
+ *   - `onFinish(b2)`
+ * - `onFinish(a)`
+ *
+ * The flow is the same no matter if the actions are sync or async.
+ *
+ * See the `atomic` middleware for an example
+ *
+ * @param hooks
+ * @returns
+ */
+export declare function createActionTrackingMiddleware2<TEnv = any>(middlewareHooks: IActionTrackingMiddleware2Hooks<TEnv>): IMiddlewareHandler;