mobx-keystone 2.3.0 → 2.4.0

package/dist/types/modelShared/BaseModelShared.d.ts

@@ -1,8 +1,8 @@
-import { AnyDataModel } from '../dataModel/BaseDataModel';
-import { AnyModel } from '../model/BaseModel';
-import { modelTypeKey } from '../model/metadata';
-import { Flatten, IsNeverType } from '../utils/types';
-import { ModelProps, ModelPropsToSnapshotCreationData, ModelPropsToSnapshotData, ModelPropsToTransformedCreationData, ModelPropsToTransformedData, ModelPropsToUntransformedCreationData } from './prop';
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { AnyModel } from "../model/BaseModel";
+import type { modelTypeKey } from "../model/metadata";
+import type { Flatten, IsNeverType } from "../utils/types";
+import type { ModelProps, ModelPropsToSnapshotCreationData, ModelPropsToSnapshotData, ModelPropsToTransformedCreationData, ModelPropsToTransformedData, ModelPropsToUntransformedCreationData } from "./prop";
 /**
  * @ignore
  */

package/dist/types/modelShared/index.d.ts

@@ -1,4 +1,4 @@
-export * from './BaseModelShared';
-export * from './modelDecorator';
-export * from './modelInfo';
-export * from './prop';
+export * from "./BaseModelShared";
+export * from "./modelDecorator";
+export * from "./modelInfo";
+export * from "./prop";

package/dist/types/modelShared/modelDecorator.d.ts

@@ -1,6 +1,6 @@
-import { AnyDataModel } from '../dataModel/BaseDataModel';
-import { AnyModel } from '../model/BaseModel';
-import { AnyFunction } from '../utils/AnyFunction';
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { AnyModel } from "../model/BaseModel";
+import type { AnyFunction } from "../utils/AnyFunction";
 /**
  * Decorator that marks this class (which MUST inherit from the `Model` or `DataModel` abstract classes)
  * as a model.

package/dist/types/modelShared/modelInfo.d.ts

@@ -1,6 +1,6 @@
-import { AnyDataModel } from '../dataModel/BaseDataModel';
-import { AnyModel } from '../model/BaseModel';
-import { ModelClass } from './BaseModelShared';
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { AnyModel } from "../model/BaseModel";
+import type { ModelClass } from "./BaseModelShared";
 /**
  * Information about a registered model.
  */

package/dist/types/modelShared/newModel.d.ts

@@ -1,4 +1,4 @@
-import { AnyDataModel } from '../dataModel/BaseDataModel';
-import { AnyModel } from '../model/BaseModel';
-import { ModelClass } from '../modelShared/BaseModelShared';
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { AnyModel } from "../model/BaseModel";
+import type { ModelClass } from "../modelShared/BaseModelShared";
 export declare function applyModelInitializers(modelClass: ModelClass<AnyModel | AnyDataModel>, modelObj: any): void;

package/dist/types/modelShared/prop.d.ts

@@ -1,6 +1,6 @@
-import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
-import { AnyStandardType } from '../types/schemas';
-import { IsNeverType, IsOptionalValue, SimplifyObject } from '../utils/types';
+import type { SnapshotInOf, SnapshotOutOf } from "../snapshot/SnapshotOf";
+import type { AnyStandardType } from "../types/schemas";
+import type { IsNeverType, IsOptionalValue, SimplifyObject } from "../utils/types";
 /**
  * @ignore
  */

package/dist/types/modelShared/sharedInternalModel.d.ts

@@ -1,7 +1,7 @@
-import { AnyDataModel } from '../dataModel/BaseDataModel';
-import { AnyModel } from '../model/BaseModel';
-import { ModelClass } from './BaseModelShared';
-import { ModelProps } from './prop';
+import { type AnyDataModel } from "../dataModel/BaseDataModel";
+import { type AnyModel } from "../model/BaseModel";
+import { type ModelClass } from "./BaseModelShared";
+import { type ModelProps } from "./prop";
 type FromSnapshotProcessorFn = (sn: any) => any;
 type ToSnapshotProcessorFn = (sn: any, instance: any) => any;
 export declare function sharedInternalModel<TProps extends ModelProps, TBaseModel extends AnyModel | AnyDataModel>({ modelProps, baseModel, type, valueType, fromSnapshotProcessor, toSnapshotProcessor, }: {

package/dist/types/parent/findParent.d.ts

@@ -1,4 +1,4 @@
-import { Path } from './pathTypes';
+import type { Path } from "./pathTypes";
 /**
  * Iterates through all the parents (from the nearest until the root)
  * until one of them matches the given predicate.

package/dist/types/parent/index.d.ts

@@ -1,9 +1,9 @@
-export * from './detach';
-export * from './findChildren';
-export * from './findParent';
-export * from './getChildrenObjects';
-export * from './onChildAttachedTo';
-export * from './path';
-export * from './path2';
-export * from './pathTypes';
-export * from './walkTree';
+export * from "./detach";
+export * from "./findChildren";
+export * from "./findParent";
+export * from "./getChildrenObjects";
+export * from "./onChildAttachedTo";
+export * from "./path";
+export * from "./path2";
+export * from "./pathTypes";
+export * from "./walkTree";

package/dist/types/parent/path.d.ts

@@ -1,4 +1,4 @@
-import { Path, PathElement } from './pathTypes';
+import type { Path, PathElement } from "./pathTypes";
 /**
  * Path from an object to its immediate parent.
  *

package/dist/types/patch/Patch.d.ts

@@ -1,4 +1,4 @@
-import { Path } from '../parent/pathTypes';
+import type { Path } from "../parent/pathTypes";
 export type Patch = PatchAddOperation<any> | PatchRemoveOperation | PatchReplaceOperation<any>;
 export interface PatchBaseOperation {
     path: Path;

package/dist/types/patch/applyPatches.d.ts

@@ -1,4 +1,4 @@
-import { Patch } from '../patch/Patch';
+import type { Patch } from "../patch/Patch";
 /**
  * Applies the given patches to the given target object.
  * Automatic type checking validates the completed batch, including nested lists.

package/dist/types/patch/emitPatch.d.ts

@@ -1,4 +1,4 @@
-import { Patch } from './Patch';
+import type { Patch } from "./Patch";
 /**
  * A function that gets called when a patch is emitted.
  */
@@ -14,6 +14,9 @@ export type OnPatchesDisposer = () => void;
 /**
  * Adds a listener that will be called every time a patch is generated for the tree of the given target object.
  *
+ * The listener runs inside the action that made the change, so `getCurrentActionContext()` returns
+ * that action's context: its `rootContext` is the top-level action (for a flow step, the flow).
+ *
  * @param subtreeRoot Subtree root object of the patch listener.
  * @param listener The listener function that will be called everytime a patch is generated for the object or its children.
  * @returns A disposer to stop listening to patches.
@@ -23,6 +26,9 @@ export declare function onPatches(subtreeRoot: object, listener: OnPatchesListen
  * Adds a listener that will be called every time a patch is generated anywhere.
  * Usually prefer using `onPatches`.
  *
+ * The listener runs inside the action that made the change, so `getCurrentActionContext()` returns
+ * that action's context: its `rootContext` is the top-level action (for a flow step, the flow).
+ *
  * @param listener The listener function that will be called everytime a patch is generated anywhere.
  * @returns A disposer to stop listening to patches.
  */

package/dist/types/patch/index.d.ts

@@ -1,5 +1,5 @@
-export * from './applyPatches';
-export * from './emitPatch';
-export * from './jsonPatch';
-export * from './Patch';
-export * from './patchRecorder';
+export * from "./applyPatches";
+export * from "./emitPatch";
+export * from "./jsonPatch";
+export * from "./Patch";
+export * from "./patchRecorder";

package/dist/types/patch/jsonPatch.d.ts

@@ -1,5 +1,5 @@
-import { Path } from '../parent/pathTypes';
-import { Patch } from './Patch';
+import type { Path } from "../parent/pathTypes";
+import type { Patch } from "./Patch";
 export type JsonPatch = JsonPatchAddOperation<any> | JsonPatchRemoveOperation | JsonPatchReplaceOperation<any>;
 export interface JsonPatchBaseOperation {
     path: string;

package/dist/types/patch/patchRecorder.d.ts

@@ -1,5 +1,5 @@
-import { OnPatchesListener } from './emitPatch';
-import { Patch } from './Patch';
+import { type OnPatchesListener } from "./emitPatch";
+import type { Patch } from "./Patch";
 /**
  * Patch recorder event.
  */

package/dist/types/redux/index.d.ts

@@ -1,2 +1,2 @@
-export * from './connectReduxDevTools';
-export * from './redux';
+export * from "./connectReduxDevTools";
+export * from "./redux";

package/dist/types/redux/redux.d.ts

@@ -1,6 +1,6 @@
-import { ActionCall } from '../action';
-import { OnSnapshotDisposer, OnSnapshotListener } from '../snapshot/onSnapshot';
-import { SnapshotOutOf } from '../snapshot/SnapshotOf';
+import { type ActionCall } from "../action";
+import { type OnSnapshotDisposer, type OnSnapshotListener } from "../snapshot/onSnapshot";
+import type { SnapshotOutOf } from "../snapshot/SnapshotOf";
 export declare const reduxActionType = "applyAction";
 /**
  * A redux action for mobx-keystone.

package/dist/types/ref/Ref.d.ts

@@ -1,9 +1,9 @@
-import { ModelClass } from '../modelShared/BaseModelShared';
-declare const Ref_base: import('..')._Model<unknown, {
+import type { ModelClass } from "../modelShared/BaseModelShared";
+declare const Ref_base: import("..")._Model<unknown, {
     /**
      * Reference id.
      */
-    id: import('..').TypedMaybeOptionalModelProp<import('..').IdentityType<string>>;
+    id: import("..").TypedMaybeOptionalModelProp<import("..").IdentityType<string>>;
 }, never, never>;
 /**
  * A reference model base type.

package/dist/types/ref/core.d.ts

@@ -1,5 +1,5 @@
-import { ObservableSet } from 'mobx';
-import { Ref, RefConstructor } from './Ref';
+import { type ObservableSet } from "mobx";
+import { Ref, type RefConstructor } from "./Ref";
 /**
  * Reference resolver type.
  */

package/dist/types/ref/customRef.d.ts

@@ -1,5 +1,5 @@
-import { RefIdResolver, RefOnResolvedValueChange, RefResolver } from './core';
-import { RefConstructor } from './Ref';
+import { type RefIdResolver, type RefOnResolvedValueChange, type RefResolver } from "./core";
+import type { RefConstructor } from "./Ref";
 /**
  * Custom reference options.
  */

package/dist/types/ref/index.d.ts

@@ -1,4 +1,4 @@
-export * from './core';
-export * from './customRef';
-export * from './Ref';
-export * from './rootRef';
+export * from "./core";
+export * from "./customRef";
+export * from "./Ref";
+export * from "./rootRef";

package/dist/types/ref/rootRef.d.ts

@@ -1,5 +1,5 @@
-import { RefIdResolver, RefOnResolvedValueChange } from './core';
-import { RefConstructor } from './Ref';
+import { type RefIdResolver, type RefOnResolvedValueChange } from "./core";
+import type { RefConstructor } from "./Ref";
 /**
  * Custom reference options.
  */

package/dist/types/rootStore/index.d.ts

@@ -1 +1 @@
-export * from './rootStore';
+export * from "./rootStore";

package/dist/types/serialization/Call.d.ts

@@ -0,0 +1,55 @@
+import type { CallKind } from "../action/CallKind";
+import type { JsonValue } from "./JsonValue";
+/**
+ * A call as JSON, as `Serializer.encodeCall` returns it and `Serializer.decodeCall` takes it.
+ */
+export interface EncodedCall {
+    /**
+     * A reference to the node the call runs on; for a standalone action, its first argument.
+     */
+    target: JsonValue;
+    /**
+     * Name of the action or view.
+     */
+    name: string;
+    /**
+     * Encoded arguments; left out to read a getter.
+     */
+    args?: JsonValue[];
+}
+/**
+ * A call to an action or a view of a node.
+ */
+export interface Call {
+    /**
+     * The node the call runs on; for a standalone action, its first argument.
+     */
+    target: object;
+    /**
+     * Name of the action or view.
+     */
+    name: string;
+    /**
+     * Arguments (for a standalone action, without the target); left out to read a getter.
+     */
+    args?: unknown[];
+}
+/**
+ * A call whose target and name are resolved, as `Serializer.decodeCall` returns it and `canCall`
+ * gets it.
+ */
+export interface ResolvedCall extends Readonly<Call> {
+    /**
+     * What `name` resolved to on the target.
+     */
+    readonly kind: CallKind;
+    /**
+     * Whether it is a `@modelFlow` or a `standaloneFlow`, which needs `applyCallAsync`.
+     */
+    readonly isFlow: boolean;
+    /**
+     * The arguments as JSON, only on a call returned by `decodeCall`. Reading `args` decodes them
+     * (once).
+     */
+    readonly rawArgs?: JsonValue[];
+}

package/dist/types/serialization/CallError.d.ts

@@ -0,0 +1,96 @@
+import type { Path } from "../parent/pathTypes";
+import { MobxKeystoneError } from "../utils";
+/**
+ * The reason a call failed.
+ */
+export declare enum CallErrorCode {
+    /**
+     * The target, or a reference in the arguments, doesn't resolve.
+     */
+    NotFound = "notFound",
+    /**
+     * Nothing by that name can be called on the target.
+     */
+    UnknownName = "unknownName",
+    /**
+     * The name exists, but can't be used as asked (e.g. a method read without `args`).
+     */
+    WrongKind = "wrongKind",
+    /**
+     * Refused by `canCall`.
+     */
+    Forbidden = "forbidden",
+    /**
+     * An argument (or any other value being decoded) failed to decode.
+     */
+    BadArgument = "badArgument",
+    /**
+     * A value (usually the result) can't be encoded.
+     */
+    CannotEncode = "cannotEncode"
+}
+/**
+ * What a `CallError` is built from, e.g. by a custom `ValueSerializer` that wants to choose the
+ * code (a `CallError` it throws passes through as it is; any other error is wrapped).
+ */
+export interface CallErrorData {
+    /**
+     * The reason.
+     */
+    code: CallErrorCode;
+    /**
+     * The message, without the path and value preview the error adds to it.
+     */
+    message: string;
+    /**
+     * Path relative to the call or value, e.g. `["args", 1, "items", 3]`.
+     * Defaults to where the value being encoded or decoded is.
+     */
+    path?: Path;
+    /**
+     * The value the error is about, shown in the message.
+     */
+    previewValue?: unknown;
+    /**
+     * The error that caused it, if any. Its message is added to `message`, but left out of
+     * `toJSON()`, since it may hold the server's data.
+     */
+    cause?: unknown;
+}
+/**
+ * The JSON form of a `CallError`, safe to send back to the caller.
+ */
+export interface CallErrorJson {
+    code: CallErrorCode;
+    message: string;
+    path: Path;
+}
+/**
+ * Thrown when a call or a value can't be decoded, resolved, allowed, run or encoded
+ * (extends `MobxKeystoneError`). Errors thrown by the action or view being called are not
+ * `CallError`s: they are rethrown as they are.
+ *
+ * Use `instanceof CallError` to distinguish call errors from other
+ * `MobxKeystoneError` instances.
+ */
+export declare class CallError extends MobxKeystoneError {
+    /**
+     * The reason.
+     */
+    readonly code: CallErrorCode;
+    /**
+     * Where in the call or value the error is, e.g. `["args", 1]`.
+     */
+    readonly path: Path;
+    /**
+     * The error that caused it, if any.
+     */
+    readonly cause?: unknown;
+    private readonly jsonMessage;
+    constructor(data: CallErrorData);
+    /**
+     * The error as JSON, for RPC and tool layers. It leaves out the cause's message, and the value
+     * preview of a `CannotEncode` error, since they may hold the server's data.
+     */
+    toJSON(): CallErrorJson;
+}

package/dist/types/serialization/JsonValue.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A JSON value: what `JSON.parse` can return.
+ */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};

package/dist/types/serialization/Serializer.d.ts

@@ -0,0 +1,84 @@
+import type { ActionCall } from "../action/applyAction";
+import type { Call, EncodedCall, ResolvedCall } from "./Call";
+import type { JsonValue } from "./JsonValue";
+import type { ValueSerializer } from "./ValueSerializer";
+/**
+ * Encodes and decodes values and calls against a tree, with a list of value serializers.
+ * Created with `createSerializer`.
+ *
+ * Every operation takes the root of the tree as its first argument; it must be a tree root.
+ */
+export interface Serializer {
+    /**
+     * The list of value serializers it was created with, without the built-ins.
+     */
+    readonly serializers: readonly ValueSerializer[];
+    /**
+     * Encodes a value as JSON. Nodes of the tree go as references when a reference serializer in
+     * the list claims them.
+     *
+     * @param root Root of the tree.
+     * @param value Value to encode.
+     * @returns The encoded value.
+     */
+    encodeValue(root: object, value: unknown): JsonValue;
+    /**
+     * Decodes a value encoded with `encodeValue`. References are resolved against the tree;
+     * snapshots become new instances.
+     *
+     * @param root Root of the tree.
+     * @param json Value to decode.
+     * @returns The decoded value.
+     */
+    decodeValue(root: object, json: JsonValue): unknown;
+    /**
+     * Encodes a call (an `ActionCall`, e.g. from `onActionMiddleware`'s `onStart`, or a `Call`)
+     * as JSON. The target always goes as a reference; for a standalone action, it isn't repeated
+     * in the arguments.
+     *
+     * Encode an `ActionCall` before the action runs (e.g. in `onStart`), so its arguments are
+     * encoded against the tree the receiver has.
+     *
+     * @param root Root of the tree.
+     * @param call The call.
+     * @returns The encoded call.
+     */
+    encodeCall(root: object, call: ActionCall | Call): EncodedCall;
+    /**
+     * Decodes a call encoded with `encodeCall`: the target is resolved and the name resolved on
+     * it, nothing is run. The arguments are decoded when `args` is first read.
+     *
+     * @param root Root of the tree.
+     * @param json The encoded call.
+     * @returns The resolved call, to pass to `applyCall` or `applyCallAsync`.
+     */
+    decodeCall(root: object, json: EncodedCall | JsonValue): ResolvedCall;
+}
+/**
+ * Options of `createSerializer`.
+ */
+export interface SerializerOptions {
+    /**
+     * Value serializers, tried in order before the built-ins when encoding.
+     */
+    serializers?: readonly ValueSerializer[];
+    /**
+     * Whether to append the built-in serializers (`builtinSerializers`) to the list.
+     * Defaults to `true`.
+     */
+    builtins?: boolean;
+}
+/**
+ * Creates a serializer from a list of value serializers. When encoding, a value goes through the
+ * first serializer whose `is` accepts it, then the built-ins (unless `builtins` is `false`),
+ * then as plain JSON; decoding picks the serializer by tag.
+ *
+ * @param options Options.
+ * @returns The serializer.
+ */
+export declare function createSerializer(options?: SerializerOptions): Serializer;
+/**
+ * The default serializer: nodes of the tree as path references (`pathRefs()`, value-type models
+ * excepted), plus the built-ins.
+ */
+export declare const defaultSerializer: Serializer;

package/dist/types/serialization/ValueSerializer.d.ts

@@ -0,0 +1,88 @@
+import type { PathElement } from "../parent/pathTypes";
+import type { JsonValue } from "./JsonValue";
+/**
+ * The key that marks a special value in the encoded JSON:
+ * `{ "$mobxKeystone": <tag>, "v": <payload> }`.
+ */
+export declare const serializationMarkerKey = "$mobxKeystone";
+/**
+ * Context passed to `ValueSerializer.is` and `ValueSerializer.encode`.
+ */
+export interface EncodeContext {
+    /**
+     * Root of the tree the value is encoded against.
+     */
+    readonly root: object;
+    /**
+     * Encodes a nested value with the same serializer.
+     *
+     * @param value Value to encode.
+     * @param key Where the value is inside its parent, for error paths.
+     * @returns The encoded value.
+     */
+    encode(value: unknown, key?: PathElement): JsonValue;
+}
+/**
+ * Context passed to `ValueSerializer.decode`.
+ */
+export interface DecodeContext {
+    /**
+     * Root of the tree the value is decoded against.
+     */
+    readonly root: object;
+    /**
+     * Decodes a nested value with the same serializer.
+     *
+     * @param json Value to decode.
+     * @param key Where the value is inside its parent, for error paths.
+     * @returns The decoded value.
+     */
+    decode(json: JsonValue, key?: PathElement): unknown;
+}
+/**
+ * Handles one kind of value: encodes it as `{ "$mobxKeystone": tag, "v": payload }` and decodes
+ * it back. `createSerializer` composes a list of them into a `Serializer`.
+ *
+ * @template T Type of the values it handles.
+ * @template J Type of the encoded payload (`undefined` to carry none).
+ */
+export interface ValueSerializer<T = any, J extends JsonValue | undefined = any> {
+    /**
+     * Unique, e.g. `"geom/Polygon"`; the `$mobxKeystone` of the encoded value.
+     */
+    readonly tag: string;
+    /**
+     * Whether this serializer encodes `value`.
+     *
+     * @param value Value to check.
+     * @param ctx Encoding context; `ctx.root` is the tree the value is encoded against.
+     */
+    is(value: unknown, ctx: EncodeContext): value is T;
+    /**
+     * Encodes a value `is` accepted. Use `ctx.encode(child)` for nested values.
+     *
+     * @param value Value to encode.
+     * @param ctx Encoding context.
+     * @returns The payload (`v`), or `undefined` to carry none.
+     */
+    encode(value: T, ctx: EncodeContext): J;
+    /**
+     * Decodes a payload back into a value. Use `ctx.decode(child)` for nested values.
+     *
+     * @param json The payload (`v`).
+     * @param ctx Decoding context.
+     * @returns The decoded value.
+     */
+    decode(json: J, ctx: DecodeContext): T;
+    /**
+     * Only for reference serializers: whether this serializer references `value`, a node of the
+     * tree, when it is a call's target. Unlike `is`, it ignores options such as `when`, since the
+     * call must run on the node itself. A call's target goes through the first serializer whose
+     * `claimsTarget` accepts it (else as a `pathRef`), and only serializers with `claimsTarget`
+     * decode it.
+     *
+     * @param value The call's target.
+     * @param ctx Encoding context.
+     */
+    claimsTarget?(value: object, ctx: EncodeContext): boolean;
+}

package/dist/types/serialization/applyCall.d.ts

@@ -0,0 +1,54 @@
+import type { Call, ResolvedCall } from "./Call";
+/**
+ * Options of `applyCall` and `applyCallAsync`.
+ */
+export interface ApplyCallOptions {
+    /**
+     * Decides whether a call may run, after its target and name are resolved and before anything
+     * runs. Returning false throws a `CallError` with code `Forbidden`; an error it throws passes
+     * through as it is. Reading `call.args` decodes the arguments (once).
+     *
+     * Defaults to `allowModelActions`.
+     */
+    canCall?(call: ResolvedCall): boolean;
+}
+/**
+ * The default `canCall`: allows model actions (`CallKind.ModelAction`) only.
+ *
+ * @param call The call.
+ * @returns Whether it is a model action.
+ */
+export declare function allowModelActions(call: ResolvedCall): boolean;
+/**
+ * A `canCall` that allows every call, for calls from a source that is trusted.
+ *
+ * @param _call The call.
+ * @returns `true`.
+ */
+export declare function allowAnyCall(_call: ResolvedCall): boolean;
+/**
+ * Runs a call (as returned by `Serializer.decodeCall`, or built in process) on a tree and returns
+ * its result as is. Flows are refused (`call.isFlow`); use `applyCallAsync` for them.
+ *
+ * The call's name is resolved on its target (see `CallKind`), then `canCall` decides whether it
+ * may run (by default only model actions may). Errors about the call are `CallError`s; errors
+ * thrown by the action or view are rethrown as they are.
+ *
+ * @template TRet Return type.
+ * @param root Root of the tree.
+ * @param call The call.
+ * @param options Options.
+ * @returns The result of the call.
+ */
+export declare function applyCall<TRet = unknown>(root: object, call: Call | ResolvedCall, options?: ApplyCallOptions): TRet;
+/**
+ * Like `applyCall`, but accepts flows too and always returns a promise, which resolves to the
+ * result once the call (or the flow) ends. Every error is a rejection.
+ *
+ * @template TRet Return type.
+ * @param root Root of the tree.
+ * @param call The call.
+ * @param options Options.
+ * @returns A promise of the result of the call.
+ */
+export declare function applyCallAsync<TRet = unknown>(root: object, call: Call | ResolvedCall, options?: ApplyCallOptions): Promise<TRet>;