reactronic 0.22.308 → 0.22.309

package/build/dist/source/Buffer.d.ts

@@ -0,0 +1,8 @@
+import { ReactiveObject } from './impl/Hooks';
+export declare abstract class Buffer<T> extends ReactiveObject {
+    abstract readonly capacity: number;
+    abstract readonly count: number;
+    abstract put(...items: T[]): void;
+    abstract take(count: number): T[];
+    static create<T>(hint?: string, capacity?: number): Buffer<T>;
+}

package/build/dist/source/Buffer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Buffer = void 0;
+const Hooks_1 = require("./impl/Hooks");
+class Buffer extends Hooks_1.ReactiveObject {
+    static create(hint, capacity) { throw new Error('not implemented'); }
+}
+exports.Buffer = Buffer;

package/build/dist/source/Controller.d.ts

@@ -0,0 +1,12 @@
+import { MemberOptions } from './Options';
+export declare abstract class Controller<T> {
+    abstract readonly options: MemberOptions;
+    abstract readonly args: ReadonlyArray<any>;
+    abstract readonly result: T;
+    abstract readonly error: any;
+    abstract readonly stamp: number;
+    abstract readonly isUpToDate: boolean;
+    abstract configure(options: Partial<MemberOptions>): MemberOptions;
+    abstract markObsolete(): void;
+    abstract pullLastResult(args?: any[]): T | undefined;
+}

package/build/dist/source/Controller.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+class Controller {
+}
+exports.Controller = Controller;

package/build/dist/source/Logging.d.ts

@@ -0,0 +1,38 @@
+export interface LoggingOptions {
+    readonly enabled: boolean;
+    readonly transaction: boolean;
+    readonly operation: boolean;
+    readonly step: boolean;
+    readonly monitor: boolean;
+    readonly read: boolean;
+    readonly write: boolean;
+    readonly change: boolean;
+    readonly obsolete: boolean;
+    readonly error: boolean;
+    readonly warning: boolean;
+    readonly gc: boolean;
+    readonly color: number;
+    readonly prefix: string;
+    readonly margin1: number;
+    readonly margin2: number;
+}
+export interface ProfilingOptions {
+    repetitiveUsageWarningThreshold: number;
+    mainThreadBlockingWarningThreshold: number;
+    asyncActionDurationWarningThreshold: number;
+    garbageCollectionSummaryInterval: number;
+}
+export declare const LoggingLevel: {
+    readonly Off: LoggingOptions;
+    readonly ErrorsOnly: LoggingOptions;
+    readonly Reactions: LoggingOptions;
+    readonly Transactions: LoggingOptions;
+    readonly Operations: LoggingOptions;
+    readonly Debug: LoggingOptions;
+};
+declare global {
+    interface Window {
+        rWhy: string;
+        rBriefWhy: string;
+    }
+}

package/build/dist/source/Logging.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingLevel = void 0;
+exports.LoggingLevel = {
+    Off: {
+        enabled: false,
+        transaction: false,
+        operation: false,
+        step: false,
+        monitor: false,
+        read: false,
+        write: false,
+        change: false,
+        obsolete: false,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
+    ErrorsOnly: {
+        enabled: true,
+        transaction: false,
+        operation: false,
+        step: false,
+        monitor: false,
+        read: false,
+        write: false,
+        change: false,
+        obsolete: false,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
+    Reactions: {
+        enabled: true,
+        transaction: false,
+        operation: false,
+        step: false,
+        monitor: false,
+        read: false,
+        write: false,
+        change: false,
+        obsolete: true,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
+    Transactions: {
+        enabled: true,
+        transaction: true,
+        operation: false,
+        step: false,
+        monitor: false,
+        read: false,
+        write: false,
+        change: false,
+        obsolete: true,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
+    Operations: {
+        enabled: true,
+        transaction: true,
+        operation: true,
+        step: false,
+        monitor: true,
+        read: false,
+        write: false,
+        change: true,
+        obsolete: true,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
+    Debug: {
+        enabled: true,
+        transaction: true,
+        operation: true,
+        step: true,
+        monitor: true,
+        read: true,
+        write: true,
+        change: true,
+        obsolete: true,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
+};

package/build/dist/source/Options.d.ts

@@ -0,0 +1,38 @@
+import { LoggingOptions } from './Logging';
+import { StandaloneMode } from './impl/Data';
+export { LoggingOptions, ProfilingOptions, LoggingLevel } from './Logging';
+import { Journal } from './impl/Journal';
+import { Monitor } from './impl/Monitor';
+export interface SnapshotOptions {
+    readonly hint?: string;
+    readonly standalone?: StandaloneMode;
+    readonly journal?: Journal;
+    readonly logging?: Partial<LoggingOptions>;
+    readonly token?: any;
+}
+export interface MemberOptions {
+    readonly kind: Kind;
+    readonly standalone: StandaloneMode;
+    readonly order: number;
+    readonly noSideEffects: boolean;
+    readonly triggeringArgs: boolean;
+    readonly throttling: number;
+    readonly reentrance: Reentrance;
+    readonly journal: Journal | undefined;
+    readonly monitor: Monitor | null;
+    readonly logging?: Partial<LoggingOptions>;
+}
+export declare enum Kind {
+    Plain = 0,
+    Transaction = 1,
+    Reaction = 2,
+    Cache = 3
+}
+export declare enum Reentrance {
+    PreventWithError = 1,
+    WaitAndRestart = 0,
+    CancelPrevious = -1,
+    CancelAndWaitPrevious = -2,
+    OverwritePrevious = -3,
+    RunSideBySide = -4
+}

package/build/dist/source/Options.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reentrance = exports.Kind = exports.LoggingLevel = void 0;
+var Logging_1 = require("./Logging");
+Object.defineProperty(exports, "LoggingLevel", { enumerable: true, get: function () { return Logging_1.LoggingLevel; } });
+var Kind;
+(function (Kind) {
+    Kind[Kind["Plain"] = 0] = "Plain";
+    Kind[Kind["Transaction"] = 1] = "Transaction";
+    Kind[Kind["Reaction"] = 2] = "Reaction";
+    Kind[Kind["Cache"] = 3] = "Cache";
+})(Kind = exports.Kind || (exports.Kind = {}));
+var Reentrance;
+(function (Reentrance) {
+    Reentrance[Reentrance["PreventWithError"] = 1] = "PreventWithError";
+    Reentrance[Reentrance["WaitAndRestart"] = 0] = "WaitAndRestart";
+    Reentrance[Reentrance["CancelPrevious"] = -1] = "CancelPrevious";
+    Reentrance[Reentrance["CancelAndWaitPrevious"] = -2] = "CancelAndWaitPrevious";
+    Reentrance[Reentrance["OverwritePrevious"] = -3] = "OverwritePrevious";
+    Reentrance[Reentrance["RunSideBySide"] = -4] = "RunSideBySide";
+})(Reentrance = exports.Reentrance || (exports.Reentrance = {}));

package/build/dist/source/Ref.d.ts

@@ -0,0 +1,34 @@
+export declare type BoolOnly<T> = Pick<T, {
+    [P in keyof T]: T[P] extends boolean ? P : never;
+}[keyof T]>;
+export declare type GivenTypeOnly<T, V> = Pick<T, {
+    [P in keyof T]: T[P] extends V ? P : never;
+}[keyof T]>;
+export declare class Ref<T = any> {
+    readonly owner: any;
+    readonly name: string;
+    readonly index: number;
+    constructor(owner: any, name: string, index?: number);
+    get value(): T;
+    set value(value: T);
+    nonreactive(): T;
+    observe(): T;
+    unobserve(): T;
+    static to<O extends object = object>(owner: O): {
+        readonly [P in keyof O]-?: Ref<O[P]>;
+    };
+    static toToggle<O extends object = object>(owner: O): {
+        readonly [P in keyof BoolOnly<O>]: ToggleRef<O[P]>;
+    };
+    static toCustomToggle<T, O extends object = any>(owner: O, value1: T, value2: T): {
+        readonly [P in keyof GivenTypeOnly<O, T | any>]: ToggleRef<O[P]>;
+    };
+    static sameRefs(v1: Ref, v2: Ref): boolean;
+    static similarRefs(v1: Ref, v2: Ref): boolean;
+}
+export declare class ToggleRef<T = boolean> extends Ref<T> {
+    readonly valueOn: T;
+    readonly valueOff: T;
+    constructor(owner: any, name: string, valueOn: T, valueOff: T);
+    toggle(): void;
+}

package/build/dist/source/Ref.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToggleRef = exports.Ref = void 0;
+const Transaction_1 = require("./impl/Transaction");
+const Rx_1 = require("./Rx");
+class Ref {
+    constructor(owner, name, index = -1) {
+        this.owner = owner;
+        this.name = name;
+        this.index = index;
+    }
+    get value() {
+        if (this.index < 0)
+            return this.owner[this.name];
+        else
+            return this.owner[this.name][this.index];
+    }
+    set value(value) {
+        if (this.index < 0)
+            this.owner[this.name] = value;
+        else
+            this.owner[this.name][this.index] = value;
+    }
+    nonreactive() {
+        return (0, Rx_1.nonreactive)(() => this.value);
+    }
+    observe() {
+        return this.value;
+    }
+    unobserve() {
+        throw new Error('not implemented');
+    }
+    static to(owner) {
+        return new Proxy(owner, RefGettingProxy);
+    }
+    static toToggle(owner) {
+        return new Proxy(owner, BoolRefGettingProxy);
+    }
+    static toCustomToggle(owner, value1, value2) {
+        const handler = new CustomToggleRefGettingProxy(value1, value2);
+        return new Proxy(owner, handler);
+    }
+    static sameRefs(v1, v2) {
+        return v1.owner === v2.owner && v1.name === v2.name && v1.index === v2.index;
+    }
+    static similarRefs(v1, v2) {
+        return v1.owner.constructor === v2.owner.constructor && v1.name === v2.name && v1.index === v2.index;
+    }
+}
+exports.Ref = Ref;
+class ToggleRef extends Ref {
+    constructor(owner, name, valueOn, valueOff) {
+        super(owner, name);
+        this.valueOn = valueOn;
+        this.valueOff = valueOff;
+    }
+    toggle() {
+        const o = this.owner;
+        const p = this.name;
+        Transaction_1.Transaction.run({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+            const v = o[p];
+            const isOn = v === this.valueOn || (v instanceof Ref && this.valueOn instanceof Ref &&
+                Ref.sameRefs(v, this.valueOn));
+            if (!isOn)
+                o[p] = this.valueOn;
+            else
+                o[p] = this.valueOff;
+        });
+    }
+}
+exports.ToggleRef = ToggleRef;
+const RefGettingProxy = {
+    get: (obj, prop) => {
+        return new Ref(obj, prop);
+    },
+};
+const BoolRefGettingProxy = {
+    get: (obj, prop) => {
+        return new ToggleRef(obj, prop, true, false);
+    },
+};
+class CustomToggleRefGettingProxy {
+    constructor(value1, value2) {
+        this.value1 = value1;
+        this.value2 = value2;
+    }
+    get(obj, prop) {
+        return new ToggleRef(obj, prop, this.value1, this.value2);
+    }
+}

package/build/dist/source/Rx.d.ts

@@ -0,0 +1,27 @@
+import { F } from './util/Utils';
+import { Controller } from './Controller';
+import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options';
+export declare class Rx {
+    static getRevisionOf(obj: any): number;
+    static why(brief?: boolean): string;
+    static getController<T>(method: F<T>): Controller<T>;
+    static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;
+    static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
+    static takeSnapshot<T>(obj: T): T;
+    static dispose(obj: any): void;
+    static get reactionsAutoStartDisabled(): boolean;
+    static set reactionsAutoStartDisabled(value: boolean);
+    static get isLogging(): boolean;
+    static get loggingOptions(): LoggingOptions;
+    static setLoggingMode(isOn: boolean, options?: LoggingOptions): void;
+    static setLoggingHint<T extends object>(obj: T, name: string | undefined): void;
+    static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
+    static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
+}
+export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
+export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function isnonreactive(proto: object, prop: PropertyKey): any;
+export declare function transaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/Rx.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = void 0;
+const Dbg_1 = require("./util/Dbg");
+const Options_1 = require("./Options");
+const Data_1 = require("./impl/Data");
+const Changeset_1 = require("./impl/Changeset");
+const Hooks_1 = require("./impl/Hooks");
+const Operation_1 = require("./impl/Operation");
+class Rx {
+    static getRevisionOf(obj) { return obj[Data_1.Meta.Revision]; }
+    static why(brief = false) { return brief ? Operation_1.OperationController.briefWhy() : Operation_1.OperationController.why(); }
+    static getController(method) { return Operation_1.OperationController.of(method); }
+    static pullLastResult(method, args) { return Rx.getController(method).pullLastResult(args); }
+    static configureCurrentOperation(options) { return Operation_1.OperationController.configureImpl(undefined, options); }
+    static takeSnapshot(obj) { return Changeset_1.Changeset.takeSnapshot(obj); }
+    static dispose(obj) { Changeset_1.Changeset.dispose(obj); }
+    static get reactionsAutoStartDisabled() { return Hooks_1.Hooks.reactionsAutoStartDisabled; }
+    static set reactionsAutoStartDisabled(value) { Hooks_1.Hooks.reactionsAutoStartDisabled = value; }
+    static get isLogging() { return Dbg_1.Log.isOn; }
+    static get loggingOptions() { return Dbg_1.Log.opt; }
+    static setLoggingMode(isOn, options) { Dbg_1.Log.setMode(isOn, options); }
+    static setLoggingHint(obj, name) { Hooks_1.Hooks.setHint(obj, name); }
+    static getLoggingHint(obj, full = false) { return Data_1.ObjectHandle.getHint(obj, full); }
+    static setProfilingMode(isOn, options) { Hooks_1.Hooks.setProfilingMode(isOn, options); }
+}
+exports.Rx = Rx;
+function nonreactive(func, ...args) {
+    return Operation_1.OperationController.runWithin(undefined, func, ...args);
+}
+exports.nonreactive = nonreactive;
+function sensitive(sensitivity, func, ...args) {
+    return Hooks_1.Hooks.sensitive(sensitivity, func, ...args);
+}
+exports.sensitive = sensitive;
+function isnonreactive(proto, prop) {
+    return Hooks_1.Hooks.decorateData(false, proto, prop);
+}
+exports.isnonreactive = isnonreactive;
+function transaction(proto, prop, pd) {
+    const opts = { kind: Options_1.Kind.Transaction };
+    return Hooks_1.Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);
+}
+exports.transaction = transaction;
+function reaction(proto, prop, pd) {
+    const opts = { kind: Options_1.Kind.Reaction, throttling: -1 };
+    return Hooks_1.Hooks.decorateOperation(true, reaction, opts, proto, prop, pd);
+}
+exports.reaction = reaction;
+function cached(proto, prop, pd) {
+    const opts = { kind: Options_1.Kind.Cache, noSideEffects: true };
+    return Hooks_1.Hooks.decorateOperation(true, cached, opts, proto, prop, pd);
+}
+exports.cached = cached;
+function options(value) {
+    return Hooks_1.Hooks.decorateOperationParametrized(options, value);
+}
+exports.options = options;

package/build/dist/source/Worker.d.ts

@@ -0,0 +1,8 @@
+export interface Worker {
+    readonly id: number;
+    readonly hint: string;
+    readonly isCanceled: boolean;
+    readonly isFinished: boolean;
+    cancel(error: Error, restartAfter?: Worker | null): this;
+    whenFinished(): Promise<void>;
+}

package/build/dist/source/Worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/dist/source/api.d.ts

@@ -0,0 +1,14 @@
+export { all, pause } from './util/Utils';
+export { SealedArray } from './util/SealedArray';
+export { SealedMap } from './util/SealedMap';
+export { SealedSet } from './util/SealedSet';
+export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, ProfilingOptions, LoggingLevel } from './Options';
+export { Worker } from './Worker';
+export { Controller } from './Controller';
+export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
+export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { Changeset } from './impl/Changeset';
+export { Transaction } from './impl/Transaction';
+export { Monitor } from './impl/Monitor';
+export { Journal } from './impl/Journal';
+export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Changeset = exports.ReactiveMap = exports.ReactiveArray = exports.ReactiveObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
+var Utils_1 = require("./util/Utils");
+Object.defineProperty(exports, "all", { enumerable: true, get: function () { return Utils_1.all; } });
+Object.defineProperty(exports, "pause", { enumerable: true, get: function () { return Utils_1.pause; } });
+var SealedArray_1 = require("./util/SealedArray");
+Object.defineProperty(exports, "SealedArray", { enumerable: true, get: function () { return SealedArray_1.SealedArray; } });
+var SealedMap_1 = require("./util/SealedMap");
+Object.defineProperty(exports, "SealedMap", { enumerable: true, get: function () { return SealedMap_1.SealedMap; } });
+var SealedSet_1 = require("./util/SealedSet");
+Object.defineProperty(exports, "SealedSet", { enumerable: true, get: function () { return SealedSet_1.SealedSet; } });
+var Options_1 = require("./Options");
+Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return Options_1.Kind; } });
+Object.defineProperty(exports, "Reentrance", { enumerable: true, get: function () { return Options_1.Reentrance; } });
+Object.defineProperty(exports, "LoggingLevel", { enumerable: true, get: function () { return Options_1.LoggingLevel; } });
+var Controller_1 = require("./Controller");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return Controller_1.Controller; } });
+var Ref_1 = require("./Ref");
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return Ref_1.Ref; } });
+Object.defineProperty(exports, "ToggleRef", { enumerable: true, get: function () { return Ref_1.ToggleRef; } });
+var Hooks_1 = require("./impl/Hooks");
+Object.defineProperty(exports, "ReactiveObject", { enumerable: true, get: function () { return Hooks_1.ReactiveObject; } });
+Object.defineProperty(exports, "ReactiveArray", { enumerable: true, get: function () { return Hooks_1.ReactiveArray; } });
+Object.defineProperty(exports, "ReactiveMap", { enumerable: true, get: function () { return Hooks_1.ReactiveMap; } });
+var Changeset_1 = require("./impl/Changeset");
+Object.defineProperty(exports, "Changeset", { enumerable: true, get: function () { return Changeset_1.Changeset; } });
+var Transaction_1 = require("./impl/Transaction");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return Transaction_1.Transaction; } });
+var Monitor_1 = require("./impl/Monitor");
+Object.defineProperty(exports, "Monitor", { enumerable: true, get: function () { return Monitor_1.Monitor; } });
+var Journal_1 = require("./impl/Journal");
+Object.defineProperty(exports, "Journal", { enumerable: true, get: function () { return Journal_1.Journal; } });
+var Rx_1 = require("./Rx");
+Object.defineProperty(exports, "Rx", { enumerable: true, get: function () { return Rx_1.Rx; } });
+Object.defineProperty(exports, "nonreactive", { enumerable: true, get: function () { return Rx_1.nonreactive; } });
+Object.defineProperty(exports, "sensitive", { enumerable: true, get: function () { return Rx_1.sensitive; } });
+Object.defineProperty(exports, "isnonreactive", { enumerable: true, get: function () { return Rx_1.isnonreactive; } });
+Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return Rx_1.transaction; } });
+Object.defineProperty(exports, "reaction", { enumerable: true, get: function () { return Rx_1.reaction; } });
+Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return Rx_1.cached; } });
+Object.defineProperty(exports, "options", { enumerable: true, get: function () { return Rx_1.options; } });

package/build/dist/source/impl/Changeset.d.ts

@@ -0,0 +1,60 @@
+import { Kind, SnapshotOptions } from '../Options';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Subscription, Subscriber } from './Data';
+export declare const MAX_REVISION: number;
+export declare const UNDEFINED_REVISION: number;
+export declare class Changeset implements AbstractChangeset {
+    static idGen: number;
+    private static stampGen;
+    private static pending;
+    private static oldest;
+    static garbageCollectionSummaryInterval: number;
+    static lastGarbageCollectionSummaryTimestamp: number;
+    static totalObjectHandleCount: number;
+    static totalObjectSnapshotCount: number;
+    readonly id: number;
+    readonly options: SnapshotOptions;
+    get hint(): string;
+    get timestamp(): number;
+    private revision;
+    private bumper;
+    items: Map<ObjectHandle, ObjectSnapshot>;
+    reactions: Subscriber[];
+    sealed: boolean;
+    constructor(options: SnapshotOptions | null);
+    static current: () => Changeset;
+    static edit: () => Changeset;
+    static markUsed: (subscription: Subscription, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markEdited: (oldValue: any, newValue: any, edited: boolean, os: ObjectSnapshot, m: MemberName, h: ObjectHandle) => void;
+    static isConflicting: (oldValue: any, newValue: any) => boolean;
+    static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
+    static revokeAllSubscriptions: (changeset: Changeset) => void;
+    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
+    seekSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getRelevantSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getEditableSnapshot(h: ObjectHandle, m: MemberName, value: any, token?: any): ObjectSnapshot;
+    static takeSnapshot<T>(obj: T): T;
+    static dispose(obj: any): void;
+    static doDispose(ctx: Changeset, h: ObjectHandle): ObjectSnapshot;
+    private isNewSnapshotRequired;
+    acquire(outer: Changeset): void;
+    bumpBy(timestamp: number): void;
+    rebase(): ObjectSnapshot[] | undefined;
+    private merge;
+    applyOrDiscard(error?: any): Array<Subscriber>;
+    static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
+    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
+    static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
+    triggerGarbageCollection(): void;
+    private unlinkHistory;
+    static _init(): void;
+}
+export declare class Dump {
+    static valueHint: (value: any, m?: PropertyKey | undefined) => string;
+    static obj(h: ObjectHandle | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: Subscription): string;
+    static snapshot(os: ObjectSnapshot, m?: MemberName): string;
+    static conflicts(conflicts: ObjectSnapshot[]): string;
+    static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;
+}
+export declare const EMPTY_SNAPSHOT: ObjectSnapshot;
+export declare const DefaultSnapshotOptions: SnapshotOptions;