@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.easystore.d.ts

@@ -0,0 +1,42 @@
+import { SmartdataDb } from './classes.db.js';
+/**
+ * EasyStore allows the storage of easy objects. It also allows easy sharing of the object between different instances
+ */
+export declare class EasyStore<T> {
+    smartdataDbRef: SmartdataDb;
+    nameId: string;
+    private easyStoreClass;
+    constructor(nameIdArg: string, smartdataDbRefArg: SmartdataDb);
+    private easyStorePromise?;
+    private getEasyStore;
+    /**
+     * reads all keyValue pairs at once and returns them
+     */
+    readAll(): Promise<any>;
+    /**
+     * reads a keyValueFile from disk
+     */
+    readKey<TKey extends keyof T>(keyArg: TKey): Promise<Partial<T>[TKey]>;
+    /**
+     * writes a specific key to the keyValueStore
+     */
+    writeKey<TKey extends keyof T>(keyArg: TKey, valueArg: T[TKey]): Promise<void>;
+    deleteKey(keyArg: keyof T): Promise<void>;
+    /**
+     * merges all keyValue pairs from the object argument into the store.
+     * Existing keys that are not present in `keyValueObject` are preserved.
+     * To overwrite the entire store and drop missing keys, use `replace()`.
+     */
+    writeAll(keyValueObject: Partial<T>): Promise<void>;
+    /**
+     * atomically replaces the entire store with the given object.
+     * Unlike `writeAll` (which merges), `replace` clears any keys not
+     * present in `keyValueObject`. Useful when you need to drop a key.
+     */
+    replace(keyValueObject: Partial<T>): Promise<void>;
+    /**
+     * wipes a key value store from disk
+     */
+    wipe(): Promise<void>;
+    cleanUpEphemeral(): Promise<void>;
+}

package/dist_ts/nosqldb/classes.easystore.js

@@ -0,0 +1,199 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import * as plugins from './plugins.js';
+import { Collection } from './classes.collection.js';
+import { SmartdataDb } from './classes.db.js';
+import { SmartDataDbDoc, svDb, unI } from './classes.doc.js';
+const easyStoreClassByDb = new WeakMap();
+const getEasyStoreClassForDb = (smartdataDbArg) => {
+    const existingClass = easyStoreClassByDb.get(smartdataDbArg);
+    if (existingClass) {
+        return existingClass;
+    }
+    let SmartdataEasyStore = (() => {
+        let _classDecorators = [Collection(() => smartdataDbArg)];
+        let _classDescriptor;
+        let _classExtraInitializers = [];
+        let _classThis;
+        let _classSuper = SmartDataDbDoc;
+        let _nameId_decorators;
+        let _nameId_initializers = [];
+        let _nameId_extraInitializers = [];
+        let _ephemeral_decorators;
+        let _ephemeral_initializers = [];
+        let _ephemeral_extraInitializers = [];
+        let _lastEdit_decorators;
+        let _lastEdit_initializers = [];
+        let _lastEdit_extraInitializers = [];
+        let _data_decorators;
+        let _data_initializers = [];
+        let _data_extraInitializers = [];
+        var SmartdataEasyStore = class extends _classSuper {
+            static { _classThis = this; }
+            static {
+                const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+                _nameId_decorators = [unI()];
+                _ephemeral_decorators = [svDb()];
+                _lastEdit_decorators = [svDb()];
+                _data_decorators = [svDb()];
+                __esDecorate(null, null, _nameId_decorators, { kind: "field", name: "nameId", static: false, private: false, access: { has: obj => "nameId" in obj, get: obj => obj.nameId, set: (obj, value) => { obj.nameId = value; } }, metadata: _metadata }, _nameId_initializers, _nameId_extraInitializers);
+                __esDecorate(null, null, _ephemeral_decorators, { kind: "field", name: "ephemeral", static: false, private: false, access: { has: obj => "ephemeral" in obj, get: obj => obj.ephemeral, set: (obj, value) => { obj.ephemeral = value; } }, metadata: _metadata }, _ephemeral_initializers, _ephemeral_extraInitializers);
+                __esDecorate(null, null, _lastEdit_decorators, { kind: "field", name: "lastEdit", static: false, private: false, access: { has: obj => "lastEdit" in obj, get: obj => obj.lastEdit, set: (obj, value) => { obj.lastEdit = value; } }, metadata: _metadata }, _lastEdit_initializers, _lastEdit_extraInitializers);
+                __esDecorate(null, null, _data_decorators, { kind: "field", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
+                __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+                SmartdataEasyStore = _classThis = _classDescriptor.value;
+                if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+                __runInitializers(_classThis, _classExtraInitializers);
+            }
+            nameId = __runInitializers(this, _nameId_initializers, void 0);
+            ephemeral = (__runInitializers(this, _nameId_extraInitializers), __runInitializers(this, _ephemeral_initializers, void 0));
+            lastEdit = (__runInitializers(this, _ephemeral_extraInitializers), __runInitializers(this, _lastEdit_initializers, void 0));
+            data = (__runInitializers(this, _lastEdit_extraInitializers), __runInitializers(this, _data_initializers, void 0));
+            constructor() {
+                super(...arguments);
+                __runInitializers(this, _data_extraInitializers);
+            }
+        };
+        return SmartdataEasyStore = _classThis;
+    })();
+    easyStoreClassByDb.set(smartdataDbArg, SmartdataEasyStore);
+    return SmartdataEasyStore;
+};
+/**
+ * EasyStore allows the storage of easy objects. It also allows easy sharing of the object between different instances
+ */
+export class EasyStore {
+    // instance
+    smartdataDbRef;
+    nameId;
+    easyStoreClass;
+    constructor(nameIdArg, smartdataDbRefArg) {
+        this.smartdataDbRef = smartdataDbRefArg;
+        this.nameId = nameIdArg;
+        this.easyStoreClass = getEasyStoreClassForDb(smartdataDbRefArg);
+    }
+    easyStorePromise;
+    async getEasyStore() {
+        if (this.easyStorePromise) {
+            return this.easyStorePromise;
+        }
+        // first run from here
+        const deferred = plugins.smartpromise.defer();
+        this.easyStorePromise = deferred.promise;
+        try {
+            let easyStore = await this.easyStoreClass.getInstance({
+                nameId: this.nameId,
+            });
+            if (!easyStore) {
+                easyStore = new this.easyStoreClass();
+                easyStore.nameId = this.nameId;
+                easyStore.data = {};
+                await easyStore.save();
+            }
+            deferred.resolve(easyStore);
+        }
+        catch (error) {
+            // settle the deferred and clear the cache so concurrent callers get the
+            // error instead of awaiting forever, and later callers can retry
+            this.easyStorePromise = undefined;
+            deferred.reject(error);
+        }
+        return deferred.promise;
+    }
+    /**
+     * reads all keyValue pairs at once and returns them
+     */
+    async readAll() {
+        const easyStore = await this.getEasyStore();
+        return easyStore.data;
+    }
+    /**
+     * reads a keyValueFile from disk
+     */
+    async readKey(keyArg) {
+        const easyStore = await this.getEasyStore();
+        return easyStore.data[keyArg];
+    }
+    /**
+     * writes a specific key to the keyValueStore
+     */
+    async writeKey(keyArg, valueArg) {
+        const easyStore = await this.getEasyStore();
+        easyStore.data[keyArg] = valueArg;
+        await easyStore.save();
+    }
+    async deleteKey(keyArg) {
+        const easyStore = await this.getEasyStore();
+        delete easyStore.data[keyArg];
+        await easyStore.save();
+    }
+    /**
+     * merges all keyValue pairs from the object argument into the store.
+     * Existing keys that are not present in `keyValueObject` are preserved.
+     * To overwrite the entire store and drop missing keys, use `replace()`.
+     */
+    async writeAll(keyValueObject) {
+        const easyStore = await this.getEasyStore();
+        easyStore.data = { ...easyStore.data, ...keyValueObject };
+        await easyStore.save();
+    }
+    /**
+     * atomically replaces the entire store with the given object.
+     * Unlike `writeAll` (which merges), `replace` clears any keys not
+     * present in `keyValueObject`. Useful when you need to drop a key.
+     */
+    async replace(keyValueObject) {
+        const easyStore = await this.getEasyStore();
+        easyStore.data = { ...keyValueObject };
+        await easyStore.save();
+    }
+    /**
+     * wipes a key value store from disk
+     */
+    async wipe() {
+        const easyStore = await this.getEasyStore();
+        easyStore.data = {};
+        await easyStore.save();
+    }
+    async cleanUpEphemeral() {
+        // Clean up ephemeral data periodically while connected
+        while (this.smartdataDbRef.status === 'connected') {
+            await plugins.smartdelay.delayFor(60000); // Check every minute
+            // TODO: Implement actual cleanup logic for ephemeral data
+            // For now, this prevents the infinite CPU loop
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5lYXN5c3RvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ub3NxbGRiL2NsYXNzZXMuZWFzeXN0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTdELE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxPQUFPLEVBQW9CLENBQUM7QUFFM0QsTUFBTSxzQkFBc0IsR0FBRyxDQUFJLGNBQTJCLEVBQUUsRUFBRTtJQUNoRSxNQUFNLGFBQWEsR0FBRyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDN0QsSUFBSSxhQUFhLEVBQUUsQ0FBQztRQUNsQixPQUFPLGFBQWEsQ0FBQztJQUN2QixDQUFDO1FBRUssa0JBQWtCO2dDQUR2QixVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBYyxDQUFDOzs7OzBCQUNBLGNBQWM7Ozs7Ozs7Ozs7Ozs7c0NBQXRCLFNBQVEsV0FHaEM7Ozs7c0NBQ0UsR0FBRyxFQUFFO3lDQUdMLElBQUksRUFBRTt3Q0FNTixJQUFJLEVBQUU7b0NBR04sSUFBSSxFQUFFO2dCQVhQLG9LQUFPLE1BQU0sNkJBQU4sTUFBTSx1RkFBVTtnQkFHdkIsNktBQU8sU0FBUyw2QkFBVCxTQUFTLDZGQUdkO2dCQUdGLDBLQUFBLFFBQVEsNkJBQVIsUUFBUSwyRkFBVTtnQkFHbEIsOEpBQU8sSUFBSSw2QkFBSixJQUFJLG1GQUFjO2dCQWpCM0IsNktBa0JDOzs7Z0JBbEJLLHVEQUFrQjs7WUFLZixNQUFNLHlEQUFVO1lBR2hCLFNBQVMsa0hBR2Q7WUFHRixRQUFRLG9IQUFVO1lBR1gsSUFBSSwrR0FBYzs7Ozs7Ozs7SUFFM0Isa0JBQWtCLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO0lBQzNELE9BQU8sa0JBQWtCLENBQUM7QUFDNUIsQ0FBQyxDQUFDO0FBRUY7O0dBRUc7QUFDSCxNQUFNLE9BQU8sU0FBUztJQUNwQixXQUFXO0lBQ0osY0FBYyxDQUFjO0lBQzVCLE1BQU0sQ0FBUztJQUVkLGNBQWMsQ0FBK0M7SUFFckUsWUFBWSxTQUFpQixFQUFFLGlCQUE4QjtRQUMzRCxJQUFJLENBQUMsY0FBYyxHQUFHLGlCQUFpQixDQUFDO1FBQ3hDLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxjQUFjLEdBQUcsc0JBQXNCLENBQUksaUJBQWlCLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBRU8sZ0JBQWdCLENBQXFEO0lBQ3JFLEtBQUssQ0FBQyxZQUFZO1FBQ3hCLElBQUksSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7WUFDMUIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUM7UUFDL0IsQ0FBQztRQUVELHNCQUFzQjtRQUN0QixNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBNEMsQ0FBQztRQUN4RixJQUFJLENBQUMsZ0JBQWdCLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQztRQUV6QyxJQUFJLENBQUM7WUFDSCxJQUFJLFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxjQUFjLENBQUMsV0FBVyxDQUFDO2dCQUNwRCxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU07YUFDcEIsQ0FBQyxDQUFDO1lBRUgsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO2dCQUNmLFNBQVMsR0FBRyxJQUFJLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQztnQkFDdEMsU0FBUyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDO2dCQUMvQixTQUFTLENBQUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztnQkFDcEIsTUFBTSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDekIsQ0FBQztZQUNELFFBQVEsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDOUIsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZix3RUFBd0U7WUFDeEUsaUVBQWlFO1lBQ2pFLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxTQUFTLENBQUM7WUFDbEMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN6QixDQUFDO1FBQ0QsT0FBTyxRQUFRLENBQUMsT0FBTyxDQUFDO0lBQzFCLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxPQUFPO1FBQ2xCLE1BQU0sU0FBUyxHQUFHLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQzVDLE9BQU8sU0FBUyxDQUFDLElBQUksQ0FBQztJQUN4QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsT0FBTyxDQUF1QixNQUFZO1FBQ3JELE1BQU0sU0FBUyxHQUFHLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQzVDLE9BQU8sU0FBUyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsUUFBUSxDQUF1QixNQUFZLEVBQUUsUUFBaUI7UUFDekUsTUFBTSxTQUFTLEdBQUcsTUFBTSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDNUMsU0FBUyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxRQUFRLENBQUM7UUFDbEMsTUFBTSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUVNLEtBQUssQ0FBQyxTQUFTLENBQUMsTUFBZTtRQUNwQyxNQUFNLFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUM1QyxPQUFPLFNBQVMsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDOUIsTUFBTSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxLQUFLLENBQUMsUUFBUSxDQUFDLGNBQTBCO1FBQzlDLE1BQU0sU0FBUyxHQUFHLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQzVDLFNBQVMsQ0FBQyxJQUFJLEdBQUcsRUFBRSxHQUFHLFNBQVMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxjQUFjLEVBQUUsQ0FBQztRQUMxRCxNQUFNLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEtBQUssQ0FBQyxPQUFPLENBQUMsY0FBMEI7UUFDN0MsTUFBTSxTQUFTLEdBQUcsTUFBTSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDNUMsU0FBUyxDQUFDLElBQUksR0FBRyxFQUFFLEdBQUcsY0FBYyxFQUFFLENBQUM7UUFDdkMsTUFBTSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLElBQUk7UUFDZixNQUFNLFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUM1QyxTQUFTLENBQUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztRQUNwQixNQUFNLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN6QixDQUFDO0lBRU0sS0FBSyxDQUFDLGdCQUFnQjtRQUMzQix1REFBdUQ7UUFDdkQsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDLE1BQU0sS0FBSyxXQUFXLEVBQUUsQ0FBQztZQUNsRCxNQUFNLE9BQU8sQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMscUJBQXFCO1lBQy9ELDBEQUEwRDtZQUMxRCwrQ0FBK0M7UUFDakQsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/dist_ts/nosqldb/classes.exactpersistence.d.ts

@@ -0,0 +1,141 @@
+import * as plugins from './plugins.js';
+import type { SmartdataCollection } from './classes.collection.js';
+import type { SmartdataSession } from './classes.session.js';
+import { type MongoFilter, type SmartDataDbDoc } from './classes.doc.js';
+declare const reservedKeys: readonly ["_id", "_smartdataRevision", "_createdAt", "_updatedAt"];
+type TReservedKey = (typeof reservedKeys)[number];
+export type TExactPersistedDocument<TPersisted extends object> = Omit<TPersisted, TReservedKey> & {
+    [TKey in TReservedKey]?: never;
+};
+export type TStoredDocument<TPersisted extends object> = Omit<TPersisted, TReservedKey> & {
+    _id: plugins.mongodb.ObjectId;
+    _smartdataRevision?: string;
+    _createdAt?: never;
+    _updatedAt?: never;
+};
+export type TExactDistinctValue<TValue> = TValue extends ReadonlyArray<infer TEntry> ? TEntry : TValue;
+type TExactDocumentPathLeaf = string | number | boolean | bigint | symbol | null | undefined | Date | RegExp | Uint8Array | ((...args: any[]) => unknown) | {
+    readonly _bsontype: string;
+};
+type TExactDocumentPathTarget<TValue> = NonNullable<TValue> extends ReadonlyArray<infer TEntry> ? NonNullable<TEntry> : NonNullable<TValue>;
+type TExactDocumentPathInternal<TDocument, TDepth extends readonly unknown[]> = TDepth['length'] extends 8 ? never : TDocument extends TExactDocumentPathLeaf ? never : TDocument extends object ? {
+    [TKey in keyof TDocument & string]: TExactDocumentPathTarget<TDocument[TKey]> extends TExactDocumentPathLeaf ? TKey : TExactDocumentPathTarget<TDocument[TKey]> extends object ? TKey | `${TKey}.${TExactDocumentPathInternal<TExactDocumentPathTarget<TDocument[TKey]>, [
+        ...TDepth,
+        unknown
+    ]>}` : TKey;
+}[keyof TDocument & string] : never;
+type TExactDocumentPathContainer<TValue> = NonNullable<TValue> extends ReadonlyArray<infer TEntry> ? NonNullable<TEntry> : NonNullable<TValue>;
+export type TExactDocumentPath<TDocument extends object> = TExactDocumentPathInternal<TDocument, []>;
+type TExactDocumentPathValueForContainer<TContainer, TPath extends string> = TContainer extends unknown ? TPath extends `${infer THead}.${infer TTail}` ? THead extends keyof TContainer ? TExactDocumentPathValue<TContainer[THead], TTail> : never : TPath extends keyof TContainer ? Exclude<TContainer[TPath], undefined> : never : never;
+export type TExactDocumentPathValue<TDocument, TPath extends string> = TExactDocumentPathValueForContainer<TExactDocumentPathContainer<TDocument>, TPath>;
+export declare const isMongoObjectId: (valueArg: unknown) => valueArg is plugins.mongodb.ObjectId;
+export type TExactInsertResult<TPersisted extends object> = {
+    status: 'inserted' | 'already_committed';
+    document: TStoredDocument<TPersisted>;
+} | {
+    status: 'conflict';
+    document: TStoredDocument<TPersisted>;
+};
+export type TExactTransitionResult<TPersisted extends object> = {
+    status: 'transitioned';
+    document: TStoredDocument<TPersisted>;
+} | {
+    status: 'concurrent_change';
+};
+export type TExactDeleteResult = {
+    status: 'deleted';
+    deletedCount: 1;
+} | {
+    status: 'concurrent_change';
+    deletedCount: 0;
+};
+export type TExactPersistenceErrorCode = 'ambiguous_write' | 'invalid_configuration' | 'invalid_document' | 'noncanonical_document' | 'reserved_field' | 'unique_conflict' | 'unsupported_operation';
+export declare class SmartdataExactPersistenceError extends Error {
+    readonly code: TExactPersistenceErrorCode;
+    constructor(codeArg: TExactPersistenceErrorCode, messageArg: string, optionsArg?: ErrorOptions);
+}
+export type TExactDocumentAssertion<TPersisted extends object> = (documentArg: unknown) => asserts documentArg is TPersisted;
+type TExactAssertedDocument<TAssertion extends TExactDocumentAssertion<object>> = TAssertion extends TExactDocumentAssertion<infer TPersisted> ? TPersisted : never;
+export type TExactIdentityKey<TPersisted extends object> = {
+    [TKey in Exclude<keyof TPersisted, TReservedKey> & string]-?: [
+        TPersisted[TKey]
+    ] extends [string] ? TKey : never;
+}[Exclude<keyof TPersisted, TReservedKey> & string];
+export interface IExactPersistenceOptions<TPersisted extends object> {
+    reconcileBy?: TExactIdentityKey<TPersisted>;
+    assertDocument: TExactDocumentAssertion<TPersisted>;
+}
+export type TPersistedOf<TModel extends SmartDataDbDoc<any, any, any>> = TModel extends SmartDataDbDoc<any, infer TPersisted, any> ? TPersisted : never;
+export type TExact<TModel extends SmartDataDbDoc<any, any, any>> = SmartdataExactCollection<TModel, TPersistedOf<TModel>>;
+export interface IExactSessionOptions {
+    session?: SmartdataSession;
+}
+export interface IExactReadOptions extends IExactSessionOptions {
+    signal?: AbortSignal;
+}
+export interface IFindStoredOptions<TPersisted extends object> extends IExactReadOptions {
+    filter?: MongoFilter<TStoredDocument<TPersisted>>;
+    sort?: Partial<Record<TExactDocumentPath<TStoredDocument<TPersisted>>, 1 | -1>>;
+    skip?: number;
+    limit?: number;
+}
+interface IExactModelConstructor<TModel extends SmartDataDbDoc<any, any, any>> {
+    new (...args: any[]): TModel;
+    collection: SmartdataCollection<any>;
+    createInstanceFromMongoDbNativeDoc<T>(documentArg: any): T;
+    name: string;
+    prototype: TModel;
+}
+export declare class SmartdataExactCollection<TModel extends SmartDataDbDoc<any, any, any>, TPersisted extends object> {
+    private readonly modelConstructor;
+    private readonly collection;
+    private readonly options;
+    private initializationPromise?;
+    private initializedCollection?;
+    private initializationTarget?;
+    private initializationGeneration;
+    private readonly allowedPersistedKeys;
+    private readonly uniqueIndexes;
+    private readonly reconcileBy;
+    constructor(modelConstructor: IExactModelConstructor<TModel>, collection: SmartdataCollection<any>, options: IExactPersistenceOptions<TPersisted>);
+    private initialize;
+    private initializeOnce;
+    prepare(): Promise<void>;
+    private beginOperation;
+    private runOperation;
+    private canonicalizeDocument;
+    private assertAllowedTopLevelKeys;
+    private canonicalizePersistedDocument;
+    private canonicalizeStoredDocument;
+    private assertWithoutMutation;
+    private getPersistedBody;
+    private persistedDocumentsEqual;
+    private storedDocumentsEqual;
+    private validateReconcileIdentity;
+    private serializeModel;
+    private createPersistedDocument;
+    private hydrateStoredDocument;
+    private findByReconcileIdentity;
+    private ambiguousWriteError;
+    private canonicalizeDeleteCurrent;
+    private reconcileDeleteOutcome;
+    insert(documentArg: TModel | TExactPersistedDocument<TPersisted>, optionsArg?: IExactSessionOptions): Promise<TExactInsertResult<TPersisted>>;
+    toPersisted(storedDocumentArg: TStoredDocument<TPersisted>): TExactPersistedDocument<TPersisted>;
+    canonicalBytes(persistedDocumentArg: TExactPersistedDocument<TPersisted>): Uint8Array;
+    findStoredOne(filterArg: MongoFilter<TStoredDocument<TPersisted>>, optionsArg?: IExactReadOptions): Promise<TStoredDocument<TPersisted> | null>;
+    findStored(optionsArg?: IFindStoredOptions<TPersisted>): Promise<Array<TStoredDocument<TPersisted>>>;
+    count(filterArg?: MongoFilter<TStoredDocument<TPersisted>>, optionsArg?: IExactSessionOptions): Promise<number>;
+    distinct<TField extends TExactDocumentPath<TStoredDocument<TPersisted>>>(fieldArg: TField, filterArg?: MongoFilter<TStoredDocument<TPersisted>>, optionsArg?: IExactSessionOptions): Promise<Array<TExactDistinctValue<TExactDocumentPathValue<TStoredDocument<TPersisted>, TField>>>>;
+    transition(optionsArg: {
+        current: TStoredDocument<TPersisted>;
+        change: (modelArg: TModel) => void;
+    }, sessionOptionsArg?: IExactSessionOptions): Promise<TExactTransitionResult<TPersisted>>;
+    delete(optionsArg: {
+        current: TStoredDocument<TPersisted>;
+    }, sessionOptionsArg?: IExactSessionOptions): Promise<TExactDeleteResult>;
+}
+export declare function exactPersistence<TAssertion extends TExactDocumentAssertion<object>>(optionsArg: {
+    assertDocument: TAssertion;
+    reconcileBy?: TExactIdentityKey<TExactAssertedDocument<TAssertion>>;
+}): <TConstructor extends new (...args: any[]) => SmartDataDbDoc<any, TExactAssertedDocument<TAssertion>, any> & TExactAssertedDocument<TAssertion>>(valueArg: TConstructor, contextArg: ClassDecoratorContext) => void;
+export {};