@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.namespaceinspection.js

@@ -0,0 +1,138 @@
+import * as plugins from './plugins.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { SmartdataSession, acquireSmartdataSession, isSmartdataSession } from './classes.session.js';
+import { runCursorOperation } from './classes.cursoroperation.js';
+import { collectionTopologyDbInspectionSymbol, compareSmartdataTopologyStrings, inspectCollectionTopologySnapshot, } from './classes.collectiontopology.js';
+const requireBound = (valueArg, defaultArg, minimumArg, maximumArg, labelArg) => {
+    const value = valueArg === undefined ? defaultArg : valueArg;
+    if (!Number.isSafeInteger(value) || value < minimumArg || value > maximumArg) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must be an integer from ${minimumArg} through ${maximumArg}.`);
+    }
+    return value;
+};
+/** @internal Bounded catalog reading shared with collection preparation. */
+export const readBoundedInspectionCursor = async (cursorArg, maximumArg, signalArg, closeOptionsArg) => runCursorOperation(cursorArg, async (cursor) => {
+    const result = [];
+    while (true) {
+        signalArg.throwIfAborted();
+        const next = await cursor.next();
+        if (next === null)
+            return result;
+        if (result.length === maximumArg) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Namespace inspection exceeded its metadata bound.');
+        }
+        if (plugins.mongodb.BSON.calculateObjectSize(next) > 65_536) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Namespace inspection metadata exceeds 64 KiB per document.');
+        }
+        result.push(next);
+    }
+}, signalArg, closeOptionsArg ? () => [closeOptionsArg()] : undefined);
+/** @internal Entry point exposed through SmartdataDb.inspectNamespace(). */
+export const inspectSmartdataNamespace = async (dbArg, opts = {}) => {
+    if (!opts || Object.getPrototypeOf(opts) !== Object.prototype ||
+        Reflect.ownKeys(opts).some((keyArg) => typeof keyArg !== 'string' ||
+            !['maxCollections', 'documentCountMode', 'documentCountUpTo', 'timeoutMs', 'signal', 'session'].includes(keyArg) ||
+            !('value' in Object.getOwnPropertyDescriptor(opts, keyArg)))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid namespace inspection options.');
+    }
+    const maxCollections = requireBound(opts.maxCollections, 256, 1, 1024, 'maxCollections');
+    const documentCountMode = opts.documentCountMode === undefined ? 'bounded' : opts.documentCountMode;
+    if (!['bounded', 'exact'].includes(documentCountMode) ||
+        (documentCountMode === 'exact' && opts.documentCountUpTo !== undefined)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid namespace document count mode.');
+    }
+    const documentCountUpTo = requireBound(opts.documentCountUpTo, 1, 0, 10_000, 'documentCountUpTo');
+    const timeoutMs = requireBound(opts.timeoutMs, 5_000, 1, 120_000, 'timeoutMs');
+    if (opts.signal !== undefined && !(opts.signal instanceof AbortSignal)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'signal must be an AbortSignal.');
+    }
+    opts.signal?.throwIfAborted();
+    if (opts.session !== undefined && !isSmartdataSession(opts.session)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Namespace inspection requires an owned session.');
+    }
+    const deadline = new AbortController();
+    const timer = setTimeout(() => deadline.abort(new SmartdataPersistenceError('unsupported_operation', 'Namespace inspection deadline exceeded.')), timeoutMs);
+    const signal = opts.signal ? AbortSignal.any([opts.signal, deadline.signal]) : deadline.signal;
+    const expiresAt = performance.now() + timeoutMs;
+    const cleanupOptions = () => ({ timeoutMS: Math.max(1, Math.ceil(expiresAt - performance.now())) });
+    const operationOptions = () => {
+        signal.throwIfAborted();
+        return cleanupOptions();
+    };
+    let lease;
+    try {
+        if (opts.session) {
+            lease = acquireSmartdataSession(opts.session, dbArg);
+            if (lease.rawSession.inTransaction()) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Namespace inspection cannot run in a transaction.');
+            }
+        }
+        const result = await dbArg[collectionTopologyDbInspectionSymbol](async (mongoDbArg) => {
+            const session = lease?.rawSession;
+            const namespaces = await readBoundedInspectionCursor(mongoDbArg.listCollections({}, {
+                nameOnly: false, batchSize: 1,
+                ...operationOptions(), signal, session,
+            }), maxCollections, signal, cleanupOptions);
+            const collections = [];
+            const names = new Set();
+            for (const namespace of namespaces) {
+                if (typeof namespace.name !== 'string' || namespace.name.length === 0 ||
+                    namespace.name.length > 255 || names.has(namespace.name)) {
+                    throw new SmartdataPersistenceError('unsupported_operation', 'Unreadable namespace metadata.');
+                }
+                names.add(namespace.name);
+                const namespaceType = namespace.type === 'collection' || namespace.type === 'view'
+                    ? namespace.type : 'other';
+                let indexes = [];
+                let documentCount = null;
+                if (namespaceType === 'collection') {
+                    const collection = mongoDbArg.collection(namespace.name);
+                    indexes = await readBoundedInspectionCursor(collection.listIndexes({
+                        batchSize: 1, ...operationOptions(), session,
+                    }), 64, signal, cleanupOptions);
+                    // Both modes reduce on the server; no document bodies enter the
+                    // observation. Exact mode retains the cumulative operation deadline.
+                    const pipeline = documentCountMode === 'exact'
+                        ? [{ $count: 'count' }]
+                        : [{ $limit: documentCountUpTo + 1 }, { $count: 'count' }];
+                    const countCursor = collection.aggregate(pipeline, {
+                        ...operationOptions(), session, signal,
+                    });
+                    const count = await runCursorOperation(countCursor, async (cursorArg) => {
+                        const reduction = await cursorArg.next();
+                        return reduction === null ? 0 : reduction.count;
+                    }, signal, () => [cleanupOptions()]);
+                    if (!Number.isSafeInteger(count) || count < 0 ||
+                        (documentCountMode === 'bounded' && count > documentCountUpTo + 1)) {
+                        throw new SmartdataPersistenceError('unsupported_operation', 'Unreadable namespace count.');
+                    }
+                    documentCount = Object.freeze({
+                        kind: documentCountMode === 'bounded' && count > documentCountUpTo ? 'at_least' : 'exact',
+                        value: count,
+                    });
+                }
+                const topology = inspectCollectionTopologySnapshot({
+                    collectionName: namespace.name, indexes: [],
+                }, { namespace: namespace, indexes });
+                collections.push(Object.freeze({
+                    collectionName: namespace.name, namespaceType, documentCount,
+                    actualIndexes: topology.actualIndexes,
+                    reasonCodes: Object.freeze(topology.reasonCodes.filter((reasonArg) => reasonArg !== 'unexpected_index')),
+                }));
+            }
+            signal.throwIfAborted();
+            collections.sort((leftArg, rightArg) => compareSmartdataTopologyStrings(leftArg.collectionName, rightArg.collectionName));
+            return Object.freeze({ consistency: 'observational', collections: Object.freeze(collections) });
+        });
+        return result;
+    }
+    catch (errorArg) {
+        signal.throwIfAborted();
+        throw errorArg;
+    }
+    finally {
+        lease?.release();
+        clearTimeout(timer);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.namespaceinspection.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.namespaceinspection.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,22 @@
+/** @internal Options must not execute accessors or accept inherited configuration. */
+export declare const assertDataOptions: (valueArg: unknown, keysArg: readonly string[]) => Record<string, unknown>;
+/** @internal One deadline for an operation and all of its phases. Never exposes abort reasons. */
+export declare class SmartdataOperationBudget {
+    readonly signal: AbortSignal;
+    private readonly controller;
+    private readonly expiresAt;
+    private readonly timer;
+    constructor(timeoutMsArg: unknown, signalArg?: unknown);
+    check(): void;
+    remainingMs(): number;
+    operationOptions(): {
+        timeoutMS: number;
+        signal: AbortSignal;
+    };
+    cleanupOptions(): {
+        timeoutMS: number;
+    };
+    /** Waiting does not cancel or abandon the owner of the pending operation. */
+    waitFor(operationArg: Promise<unknown>): Promise<void>;
+    close(): void;
+}

package/dist_ts/nosqldb/classes.operationbudget.js

@@ -0,0 +1,65 @@
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import * as plugins from './plugins.js';
+/** @internal Options must not execute accessors or accept inherited configuration. */
+export const assertDataOptions = (valueArg, keysArg) => {
+    if (!valueArg || plugins.nodeUtil.types.isProxy(valueArg) || Object.getPrototypeOf(valueArg) !== Object.prototype ||
+        Reflect.ownKeys(valueArg).some((keyArg) => typeof keyArg !== 'string' ||
+            !keysArg.includes(keyArg) ||
+            !('value' in Object.getOwnPropertyDescriptor(valueArg, keyArg)))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid SmartData operation options.');
+    }
+    const snapshot = Object.create(null);
+    for (const key of Reflect.ownKeys(valueArg)) {
+        snapshot[key] = Object.getOwnPropertyDescriptor(valueArg, key).value;
+    }
+    return snapshot;
+};
+/** @internal One deadline for an operation and all of its phases. Never exposes abort reasons. */
+export class SmartdataOperationBudget {
+    signal;
+    controller = new AbortController();
+    expiresAt;
+    timer;
+    constructor(timeoutMsArg, signalArg) {
+        if (!Number.isSafeInteger(timeoutMsArg) || timeoutMsArg < 1 ||
+            timeoutMsArg > 120_000 ||
+            (signalArg !== undefined && (plugins.nodeUtil.types.isProxy(signalArg) || !(signalArg instanceof AbortSignal)))) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Invalid SmartData timeout or cancellation signal.');
+        }
+        this.expiresAt = performance.now() + timeoutMsArg;
+        this.signal = signalArg instanceof AbortSignal
+            ? AbortSignal.any([signalArg, this.controller.signal]) : this.controller.signal;
+        this.timer = setTimeout(() => this.controller.abort(), timeoutMsArg);
+    }
+    check() {
+        if (performance.now() >= this.expiresAt)
+            this.controller.abort();
+        if (this.signal.aborted) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'SmartData operation was cancelled or exceeded its deadline.');
+        }
+    }
+    remainingMs() {
+        this.check();
+        return this.cleanupOptions().timeoutMS;
+    }
+    operationOptions() {
+        return { timeoutMS: this.remainingMs(), signal: this.signal };
+    }
+    cleanupOptions() {
+        return { timeoutMS: Math.max(1, Math.ceil(this.expiresAt - performance.now())) };
+    }
+    /** Waiting does not cancel or abandon the owner of the pending operation. */
+    async waitFor(operationArg) {
+        this.check();
+        await new Promise((resolveArg) => {
+            const finish = () => { this.signal.removeEventListener('abort', finish); resolveArg(); };
+            this.signal.addEventListener('abort', finish, { once: true });
+            operationArg.then(finish, finish);
+            if (this.signal.aborted)
+                finish();
+        });
+        this.check();
+    }
+    close() { clearTimeout(this.timer); }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+export interface IOrdinaryPersistenceOptions {
+    /** Defaults to ObjectId. String IDs are caller-owned and immutable. */
+    idType?: 'objectId' | 'string';
+    /** Defaults to managed. `none` forbids SmartData timestamp fields in storage. */
+    timestamps?: 'managed' | 'none';
+    /** Validates the complete BSON envelope before model hydration. */
+    assertStoredDocument: (valueArg: unknown) => void;
+}
+export interface IOrdinaryPersistencePolicy {
+    readonly idType: 'objectId' | 'string';
+    readonly timestamps: 'managed' | 'none';
+    readonly assertStoredDocument: (valueArg: unknown) => void;
+}
+export declare const getOrdinaryPersistencePolicy: (modelArg: any) => IOrdinaryPersistencePolicy | undefined;
+/** Opt into immutable whole-stored-document validation for an ordinary model. */
+export declare const ordinaryPersistence: (opts: IOrdinaryPersistenceOptions) => <T extends new (...args: any[]) => any>(modelArg: T, _contextArg?: ClassDecoratorContext<T>) => T;
+/** @internal Returns an isolated validated BSON document, never a hydrated model. */
+export declare const validateOrdinaryStoredDocument: (documentArg: unknown, policyArg: IOrdinaryPersistencePolicy, persistedFieldsArg: readonly string[]) => Record<string, any>;

package/dist_ts/nosqldb/classes.ordinarypersistence.js

@@ -0,0 +1,71 @@
+import * as plugins from './plugins.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { assertBsonWithoutMutation } from './classes.bsonassertion.js';
+const policySymbol = Symbol.for('@push.rocks/smartdata.ordinaryPersistencePolicy');
+const exactSymbol = Symbol.for('@push.rocks/smartdata.exactPersistencePolicy');
+export const getOrdinaryPersistencePolicy = (modelArg) => {
+    const policy = modelArg?.[policySymbol];
+    if (policy && modelArg[exactSymbol]) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Ordinary and exact persistence policies cannot be combined.');
+    }
+    return policy;
+};
+/** Opt into immutable whole-stored-document validation for an ordinary model. */
+export const ordinaryPersistence = (opts) => {
+    if (!opts || Object.getPrototypeOf(opts) !== Object.prototype ||
+        Reflect.ownKeys(opts).some((keyArg) => typeof keyArg !== 'string' ||
+            !['idType', 'timestamps', 'assertStoredDocument'].includes(keyArg) ||
+            !('value' in Object.getOwnPropertyDescriptor(opts, keyArg))) ||
+        typeof opts.assertStoredDocument !== 'function' ||
+        (opts.idType !== undefined && !['objectId', 'string'].includes(opts.idType)) ||
+        (opts.timestamps !== undefined && !['managed', 'none'].includes(opts.timestamps))) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Invalid ordinary persistence policy.');
+    }
+    const policy = Object.freeze({
+        idType: opts.idType ?? 'objectId', timestamps: opts.timestamps ?? 'managed',
+        assertStoredDocument: opts.assertStoredDocument,
+    });
+    return (modelArg, _contextArg) => {
+        if (modelArg[policySymbol] || modelArg[exactSymbol]) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'A persistence policy cannot be overridden.');
+        }
+        Object.defineProperty(modelArg, policySymbol, { value: policy });
+        return modelArg;
+    };
+};
+/** @internal Returns an isolated validated BSON document, never a hydrated model. */
+export const validateOrdinaryStoredDocument = (documentArg, policyArg, persistedFieldsArg) => {
+    const invalid = () => new SmartdataPersistenceError('invalid_document', 'Stored document does not satisfy its ordinary persistence policy.');
+    if (!documentArg || typeof documentArg !== 'object' ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(documentArg)))
+        throw invalid();
+    const allowed = new Set([...persistedFieldsArg, '_id']);
+    if (policyArg.timestamps === 'managed') {
+        allowed.add('_createdAt');
+        allowed.add('_updatedAt');
+    }
+    for (const key of Reflect.ownKeys(documentArg)) {
+        if (typeof key !== 'string' || !allowed.has(key) ||
+            (policyArg.timestamps === 'none' && ['_createdAt', '_updatedAt'].includes(key)) ||
+            key === '_smartdataRevision' || !('value' in Object.getOwnPropertyDescriptor(documentArg, key)))
+            throw invalid();
+    }
+    let clone;
+    try {
+        clone = plugins.mongodb.BSON.deserialize(plugins.mongodb.BSON.serialize(documentArg));
+    }
+    catch {
+        throw invalid();
+    }
+    if (policyArg.idType === 'string'
+        ? typeof clone._id !== 'string' || clone._id.trim().length === 0
+        : !(clone._id instanceof plugins.mongodb.ObjectId))
+        throw invalid();
+    if (policyArg.timestamps === 'managed' &&
+        (typeof clone._createdAt !== 'string' || typeof clone._updatedAt !== 'string'))
+        throw invalid();
+    assertBsonWithoutMutation(clone, policyArg.assertStoredDocument, invalid);
+    // The assertion must not retain authority to mutate the returned document.
+    return plugins.mongodb.BSON.deserialize(plugins.mongodb.BSON.serialize(clone));
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,14 @@
+import * as plugins from './plugins.js';
+export type TSmartdataPersistenceErrorCode = 'invalid_argument' | 'invalid_configuration' | 'invalid_document' | 'unique_conflict' | 'ambiguous_write' | 'unsupported_operation';
+/**
+ * Stable errors for ordinary SmartData model configuration and persistence.
+ *
+ * Exact-persistence models keep using SmartdataExactPersistenceError.
+ */
+export declare class SmartdataPersistenceError extends Error {
+    readonly code: TSmartdataPersistenceErrorCode;
+    constructor(codeArg: TSmartdataPersistenceErrorCode, messageArg: string, optionsArg?: ErrorOptions);
+}
+export declare const isMongoTransactionRetryError: (errorArg: unknown) => boolean;
+export declare const isMongoDuplicateKeyError: (errorArg: unknown) => errorArg is plugins.mongodb.MongoServerError;
+export declare const normalizeOrdinaryPersistenceError: (errorArg: unknown, messageArg: string) => never;

package/dist_ts/nosqldb/classes.persistence.js

@@ -0,0 +1,34 @@
+import * as plugins from './plugins.js';
+/**
+ * Stable errors for ordinary SmartData model configuration and persistence.
+ *
+ * Exact-persistence models keep using SmartdataExactPersistenceError.
+ */
+export class SmartdataPersistenceError extends Error {
+    code;
+    constructor(codeArg, messageArg, optionsArg) {
+        super(messageArg, optionsArg);
+        this.name = 'SmartdataPersistenceError';
+        this.code = codeArg;
+    }
+}
+export const isMongoTransactionRetryError = (errorArg) => errorArg instanceof plugins.mongodb.MongoServerError &&
+    (errorArg.hasErrorLabel('TransientTransactionError') ||
+        errorArg.hasErrorLabel('UnknownTransactionCommitResult'));
+export const isMongoDuplicateKeyError = (errorArg) => {
+    return (errorArg instanceof plugins.mongodb.MongoServerError &&
+        (errorArg.code === 11000 || errorArg.codeName === 'DuplicateKey'));
+};
+export const normalizeOrdinaryPersistenceError = (errorArg, messageArg) => {
+    if (errorArg instanceof SmartdataPersistenceError ||
+        isMongoTransactionRetryError(errorArg)) {
+        throw errorArg;
+    }
+    if (isMongoDuplicateKeyError(errorArg)) {
+        throw new SmartdataPersistenceError('unique_conflict', messageArg, {
+            cause: errorArg,
+        });
+    }
+    throw errorArg;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5wZXJzaXN0ZW5jZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL25vc3FsZGIvY2xhc3Nlcy5wZXJzaXN0ZW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQVV4Qzs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLHlCQUEwQixTQUFRLEtBQUs7SUFDbEMsSUFBSSxDQUFpQztJQUVyRCxZQUNFLE9BQXVDLEVBQ3ZDLFVBQWtCLEVBQ2xCLFVBQXlCO1FBRXpCLEtBQUssQ0FBQyxVQUFVLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDOUIsSUFBSSxDQUFDLElBQUksR0FBRywyQkFBMkIsQ0FBQztRQUN4QyxJQUFJLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQztJQUN0QixDQUFDO0NBQ0Y7QUFFRCxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBRyxDQUFDLFFBQWlCLEVBQVcsRUFBRSxDQUN6RSxRQUFRLFlBQVksT0FBTyxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0I7SUFDcEQsQ0FDRSxRQUFRLENBQUMsYUFBYSxDQUFDLDJCQUEyQixDQUFDO1FBQ25ELFFBQVEsQ0FBQyxhQUFhLENBQUMsZ0NBQWdDLENBQUMsQ0FDekQsQ0FBQztBQUVKLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLENBQ3RDLFFBQWlCLEVBQzZCLEVBQUU7SUFDaEQsT0FBTyxDQUNMLFFBQVEsWUFBWSxPQUFPLENBQUMsT0FBTyxDQUFDLGdCQUFnQjtRQUNwRCxDQUFDLFFBQVEsQ0FBQyxJQUFJLEtBQUssS0FBSyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEtBQUssY0FBYyxDQUFDLENBQ2xFLENBQUM7QUFDSixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxpQ0FBaUMsR0FBRyxDQUMvQyxRQUFpQixFQUNqQixVQUFrQixFQUNYLEVBQUU7SUFDVCxJQUNFLFFBQVEsWUFBWSx5QkFBeUI7UUFDN0MsNEJBQTRCLENBQUMsUUFBUSxDQUFDLEVBQ3RDLENBQUM7UUFDRCxNQUFNLFFBQVEsQ0FBQztJQUNqQixDQUFDO0lBQ0QsSUFBSSx3QkFBd0IsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1FBQ3ZDLE1BQU0sSUFBSSx5QkFBeUIsQ0FBQyxpQkFBaUIsRUFBRSxVQUFVLEVBQUU7WUFDakUsS0FBSyxFQUFFLFFBQVE7U0FDaEIsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUNELE1BQU0sUUFBUSxDQUFDO0FBQ2pCLENBQUMsQ0FBQyJ9

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

@@ -0,0 +1,28 @@
+import * as plugins from './plugins.js';
+import type { SmartdataDb } from './classes.db.js';
+interface ISmartdataSessionAcquireOptions {
+    ordinaryWrite?: boolean;
+}
+interface IOrdinarySessionOperationOptions {
+    ordinaryWrite?: boolean;
+    prepared?: boolean;
+    preparationMessage?: string;
+}
+export declare class SmartdataSession {
+    withTransaction<TResult>(callbackArg: (sessionArg: SmartdataSession) => Promise<TResult>): Promise<TResult | undefined>;
+    close(): Promise<void>;
+}
+export declare const createSmartdataSession: (ownerArg: SmartdataDb) => SmartdataSession;
+export declare const acquireSmartdataSession: (sessionArg: SmartdataSession, ownerArg: SmartdataDb, optionsArg?: ISmartdataSessionAcquireOptions) => {
+    rawSession: plugins.mongodb.ClientSession;
+    release: () => void;
+};
+/** Marks the current owned attempt for rollback by withTransaction. */
+export declare const failSmartdataTransaction: (sessionArg: SmartdataSession, ownerArg: SmartdataDb, errorArg: unknown) => never;
+export type TSmartdataOrdinarySession = plugins.mongodb.ClientSession | SmartdataSession;
+export declare const isSmartdataSession: (sessionArg: TSmartdataOrdinarySession | undefined) => sessionArg is SmartdataSession;
+export declare const isOrdinarySessionInTransaction: (sessionArg: TSmartdataOrdinarySession | undefined) => boolean;
+export declare const runWithOrdinarySmartdataSession: <TResult>(sessionArg: TSmartdataOrdinarySession | undefined, ownerArg: SmartdataDb, optionsArg: IOrdinarySessionOperationOptions, operationArg: (rawSessionArg: plugins.mongodb.ClientSession | undefined) => Promise<TResult>) => Promise<TResult>;
+export declare const invalidateSmartdataSessions: (ownerArg: SmartdataDb) => Promise<void>;
+export declare const unwrapSmartdataSessionInvalidationErrors: (errorArg: unknown) => readonly unknown[] | undefined;
+export {};