mobx-keystone 2.3.1 → 2.4.0

package/dist/types/action/CallKind.d.ts

@@ -0,0 +1,29 @@
+/**
+ * What a call's name resolved to on its target.
+ */
+export declare enum CallKind {
+    /**
+     * An action declared on a class: a model's `@modelAction` / `@modelFlow` (including
+     * `withSetter()` setters), or a data model's action.
+     */
+    ModelAction = "modelAction",
+    /**
+     * An action the app defines with `standaloneAction` / `standaloneFlow`, under a global name.
+     */
+    StandaloneAction = "standaloneAction",
+    /**
+     * A standalone action the library ships for editing any array or plain object
+     * (`arrayActions`, `objectActions`).
+     */
+    StandardAction = "standardAction",
+    /**
+     * A built-in action, as library functions record when they change a node: `$$applySnapshot`,
+     * `$$applyPatches`, `$$detach`, `$$applySet`, `$$applyDelete`, `$$applyMethodCall` (see
+     * `BuiltInAction`).
+     */
+    BuiltInAction = "builtInAction",
+    /**
+     * Not an action: a method, getter or function field of a model's or data model's own classes.
+     */
+    View = "view"
+}

package/dist/types/action/applyAction.d.ts

@@ -21,13 +21,19 @@ export interface ActionCall {
     readonly targetPathIds: ReadonlyArray<string | null>;
     /**
      * Marks this action call as non-serialized.
+     *
+     * @deprecated Not needed with `createSerializer`: a `Call` is never serialized, an
+     * `EncodedCall` always is.
      */
     readonly serialized?: boolean;
 }
 /**
  * Applies (runs) an action over a target object.
  *
- * If you intend to apply serialized actions check one of the `applySerializedAction` methods instead.
+ * It runs any kind of action (built-in, standalone, model actions and flows), but not views.
+ * To apply calls that come from outside (e.g. as JSON), decode them with a serializer
+ * (`defaultSerializer.decodeCall`) and use `applyCall` / `applyCallAsync` instead, which check
+ * what may be called.
  *
  * @param subtreeRoot Subtree root target object to run the action over.
  * @param call The action, usually as coming from `onActionMiddleware`.

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

@@ -3,6 +3,7 @@ export * from "./applyDelete";
 export * from "./applyMethodCall";
 export * from "./applySet";
 export * from "./builtInActions";
+export * from "./CallKind";
 export * from "./context";
 export * from "./hookActions";
 export * from "./isModelAction";

package/dist/types/action/resolveCallName.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/actionMiddlewares/actionSerialization/actionSerialization.d.ts

@@ -8,10 +8,14 @@ import { type ActionCallArgumentSerializer } from "./core";
  *
  * @param serializer Serializer to register.
  * @returns A disposer to unregister the serializer.
+ *
+ * @deprecated Use a `ValueSerializer` in the list passed to `createSerializer` instead.
  */
 export declare function registerActionCallArgumentSerializer(serializer: ActionCallArgumentSerializer<any, any>): () => void;
 /**
  * Serialized action call argument.
+ *
+ * @deprecated Replaced by the marked value `{ "$mobxKeystone": tag, "v": payload }` of `createSerializer`.
  */
 export interface SerializedActionCallArgument {
     /**
@@ -25,6 +29,8 @@ export interface SerializedActionCallArgument {
 }
 /**
  * A serialized action call.
+ *
+ * @deprecated Use `EncodedCall` instead.
  */
 export interface SerializedActionCall extends Omit<ActionCall, "serialized"> {
     /**
@@ -54,6 +60,8 @@ export interface SerializedActionCall extends Omit<ActionCall, "serialized"> {
  * @param argValue Argument value to be transformed into its serializable form.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The serializable form of the passed value.
+ *
+ * @deprecated Use `serializer.encodeValue(root, value)` instead (e.g. with `defaultSerializer`).
  */
 export declare function serializeActionCallArgument(argValue: any, targetRoot?: object): SerializedActionCallArgument | JSONPrimitiveValue;
 /**
@@ -63,6 +71,8 @@ export declare function serializeActionCallArgument(argValue: any, targetRoot?:
  * @param actionCall Action call to convert.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The serializable action call.
+ *
+ * @deprecated Use `serializer.encodeCall(root, call)` instead (e.g. with `defaultSerializer`).
  */
 export declare function serializeActionCall(actionCall: ActionCall, targetRoot?: object): SerializedActionCall;
 /**
@@ -71,6 +81,8 @@ export declare function serializeActionCall(actionCall: ActionCall, targetRoot?:
  * @param argValue Argument value to be transformed into its deserialized form.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The deserialized form of the passed value.
+ *
+ * @deprecated Use `serializer.decodeValue(root, json)` instead (e.g. with `defaultSerializer`).
  */
 export declare function deserializeActionCallArgument(argValue: SerializedActionCallArgument | JSONPrimitiveValue, targetRoot?: object): any;
 /**
@@ -80,5 +92,7 @@ export declare function deserializeActionCallArgument(argValue: SerializedAction
  * @param actionCall Action call to convert.
  * @param [targetRoot] Target root node of the model where this action is being performed.
  * @returns The deserialized action call.
+ *
+ * @deprecated Use `serializer.decodeCall(root, json)` instead (e.g. with `defaultSerializer`), then `applyCall`.
  */
 export declare function deserializeActionCall(actionCall: SerializedActionCall, targetRoot?: object): ActionCall;

package/dist/types/actionMiddlewares/actionSerialization/applySerializedAction.d.ts

@@ -4,6 +4,8 @@ import { type SerializedActionCall } from "./actionSerialization";
  * Serialized action call with model ID overrides.
  * Can be generated with `applySerializedActionAndTrackNewModelIds`.
  * To be applied with `applySerializedActionAndSyncNewModelIds`.
+ *
+ * @deprecated Use `EncodedCall` instead; model id overrides aren't needed when replicas apply the patches the server broadcasts.
  */
 export interface SerializedActionCallWithModelIdOverrides extends SerializedActionCall {
     /**
@@ -24,6 +26,8 @@ export interface SerializedActionCallWithModelIdOverrides extends SerializedActi
  * @param call The serialized action, usually as coming from the server/client.
  * @returns The return value of the action, if any, plus a new serialized action
  * with model overrides.
+ *
+ * @deprecated Use `applyCall` / `applyCallAsync` on the server instead, broadcasting the patches the call produces.
  */
 export declare function applySerializedActionAndTrackNewModelIds<TRet = any>(subtreeRoot: object, call: SerializedActionCall): {
     returnValue: TRet;
@@ -41,5 +45,7 @@ export declare function applySerializedActionAndTrackNewModelIds<TRet = any>(sub
  * @param subtreeRoot Subtree root target object to run the action over.
  * @param call The serialized action, usually as coming from the server/client.
  * @returns The return value of the action, if any.
+ *
+ * @deprecated Use `applyPatches` on the patches the server broadcasts instead.
  */
 export declare function applySerializedActionAndSyncNewModelIds<TRet = any>(subtreeRoot: object, call: SerializedActionCallWithModelIdOverrides): TRet;

package/dist/types/actionMiddlewares/actionSerialization/core.d.ts

@@ -1,6 +1,13 @@
+/**
+ * Returned by an `ActionCallArgumentSerializer` that can't serialize a value.
+ *
+ * @deprecated Use `ValueSerializer.is` returning false instead.
+ */
 export declare const cannotSerialize: unique symbol;
 /**
  * Serializer of action call arguments.
+ *
+ * @deprecated Use `ValueSerializer` instead.
  */
 export interface ActionCallArgumentSerializer<TOriginal, TSerialized> {
     /**

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ export * from "./patch";
 export * from "./redux";
 export * from "./ref";
 export * from "./rootStore";
+export * from "./serialization";
 export * from "./snapshot";
 export * from "./standardActions";
 export * from "./transforms";

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

@@ -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/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>;

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

@@ -0,0 +1,49 @@
+import type { AnyDataModel } from "../dataModel/BaseDataModel";
+import type { JsonValue } from "./JsonValue";
+import type { ValueSerializer } from "./ValueSerializer";
+/**
+ * The built-in value serializers, appended in this order to every serializer's list (unless it is
+ * created with `builtins: false`). Pick some of them to build a list by hand, e.g.
+ * `createSerializer({ serializers: [builtinSerializers.date], builtins: false })`.
+ */
+export declare const builtinSerializers: Readonly<{
+    /**
+     * Models and frozen data that aren't references, as their snapshots (unmarked, since snapshots
+     * mark themselves with `$modelType` / `$frozen`), decoded with `fromSnapshot` into new
+     * instances. Tree arrays and plain objects that aren't references are walked like any other.
+     */
+    snapshot: ValueSerializer<object, any>;
+    /**
+     * Data model instances, as their registered name and their data (encoded, so data of the tree
+     * goes as a reference), decoded as a new instance over the decoded data.
+     */
+    dataModel: ValueSerializer<AnyDataModel, {
+        type: string;
+        data: JsonValue;
+    }>;
+    /**
+     * Dates, as `toISOString()` (an invalid date as `null`); decodes an ISO string, a timestamp or
+     * `null`.
+     */
+    date: ValueSerializer<Date, string | number | null>;
+    /**
+     * Maps (plain or observable), as an array of `[key, value]` entries; decoded as plain maps.
+     */
+    map: ValueSerializer<Map<unknown, unknown>, [JsonValue, JsonValue][]>;
+    /**
+     * Sets (plain or observable), as an array of their values; decoded as plain sets.
+     */
+    set: ValueSerializer<Set<unknown>, JsonValue[]>;
+    /**
+     * The numbers JSON can't hold: `"NaN"`, `"Infinity"`, `"-Infinity"`.
+     */
+    number: ValueSerializer<number, string>;
+    /**
+     * Bigints, as a decimal string, with no loss of precision.
+     */
+    bigint: ValueSerializer<bigint, string>;
+    /**
+     * `undefined` (as an array item, an argument or an object property, which keeps its key).
+     */
+    undefined: ValueSerializer<undefined, undefined>;
+}>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+export * from "./applyCall";
+export { builtinSerializers } from "./builtinSerializers";
+export * from "./Call";
+export { CallError, CallErrorCode, type CallErrorData, type CallErrorJson } from "./CallError";
+export * from "./JsonValue";
+export { type IdRefJson, idRefs, type PathRefJson, pathRefs, type ReferenceNodeInfo, type ReferenceSerializerOptions, } from "./references";
+export * from "./Serializer";
+export * from "./ValueSerializer";