@lossless.org/nosqldb 8.0.0

package/dist_ts/ts_nosqldb/rust-db-bridge.js

@@ -0,0 +1,439 @@
+import * as plugins from './plugins.js';
+import { normalizeNoSqlDbFileStorageOptions } from './file-storage-options.js';
+import * as path from 'path';
+import * as url from 'url';
+import { EventEmitter } from 'events';
+import { normalizeNoSqlDbStorageRehearsalInput, } from './storage-rehearsal.js';
+import { normalizeNoSqlDbAllocationReadAccessGrantError, normalizeNoSqlDbResourceFenceError, } from './service-types.js';
+import { normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput, normalizeLocalNoSqlDbOfflineInspectionInput, validateNoSqlDbManagementOperationOptions, } from './offline-inspection.js';
+import { normalizeLocalNoSqlDbStoppedStorageRootRelocationInput, } from './storage-root-relocation.js';
+export class NoSqlDbManagementOperationTerminationError extends AggregateError {
+    constructor(operationErrorArg, terminationErrorArg) {
+        super([operationErrorArg, terminationErrorArg], 'NoSQLDB management operation failed and Rust engine termination was incomplete', { cause: operationErrorArg });
+        this.name = 'NoSqlDbManagementOperationTerminationError';
+    }
+}
+export const rustDbBridgeStorageRootRelocation = Symbol('nosqldb.internal.storage-root-relocation');
+export const rustDbBridgeStorageRehearsal = Symbol('nosqldb.internal.storage-rehearsal');
+/**
+ * Get the package root directory using import.meta.url.
+ * This file is at ts/ts_nosqldb/, so package root is 2 levels up.
+ */
+function getPackageRoot() {
+    const thisDir = path.dirname(url.fileURLToPath(import.meta.url));
+    return path.resolve(thisDir, '..', '..');
+}
+/**
+ * Map Node.js process.platform/process.arch to tsrust's friendly name suffix.
+ * tsrust names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
+ */
+function getTsrustPlatformSuffix() {
+    const archMap = { x64: 'amd64', arm64: 'arm64' };
+    const osMap = { linux: 'linux', darwin: 'macos' };
+    const os = osMap[process.platform];
+    const arch = archMap[process.arch];
+    if (os && arch) {
+        return `${os}_${arch}`;
+    }
+    return null;
+}
+/**
+ * Build local search paths for the Rust binary, including dist_rust/ candidates
+ * (built by tsrust) and local development build paths.
+ */
+function buildLocalPaths() {
+    const packageRoot = getPackageRoot();
+    const suffix = getTsrustPlatformSuffix();
+    const paths = [];
+    // dist_rust/ candidates (tsrust cross-compiled output)
+    if (suffix) {
+        paths.push(path.join(packageRoot, 'dist_rust', `rustdb_${suffix}`));
+    }
+    paths.push(path.join(packageRoot, 'dist_rust', 'rustdb'));
+    // Local dev build paths
+    paths.push(path.resolve(process.cwd(), 'rust', 'target', 'release', 'rustdb'));
+    paths.push(path.resolve(process.cwd(), 'rust', 'target', 'debug', 'rustdb'));
+    return paths;
+}
+export function getRustDbAllocatorEnv(environment = process.env) {
+    return {
+        MIMALLOC_ARENA_EAGER_COMMIT: environment.MIMALLOC_ARENA_EAGER_COMMIT ?? '0',
+        MIMALLOC_ALLOW_LARGE_OS_PAGES: environment.MIMALLOC_ALLOW_LARGE_OS_PAGES ?? '0',
+    };
+}
+/**
+ * Bridge between TypeScript NoSqlDbServer and the Rust binary.
+ * Wraps @push.rocks/smartrust's RustBridge with type-safe command definitions.
+ */
+export class RustDbBridge extends EventEmitter {
+    /**
+     * Operating-system process id of the spawned Rust engine while it runs as a
+     * child process of this Node.js process. Undefined before spawn, after
+     * termination, or when the bridge is connected to an external process.
+     */
+    get processId() {
+        const transport = this.bridge.transport;
+        return transport?.childProcess?.pid;
+    }
+    constructor(options = {}) {
+        super();
+        this.terminationConfirmed = true;
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'rustdb',
+            binaryPath: options.binaryPath,
+            envVarName: 'NOSQLDB_RUST_BINARY',
+            platformPackagePrefix: '@lossless.org/nosqldb',
+            localPaths: buildLocalPaths(),
+            maxPayloadSize: 100 * 1024 * 1024, // database exports/imports can be larger than command replies
+            env: getRustDbAllocatorEnv(),
+        });
+        // Forward events from the inner bridge
+        this.bridge.on('exit', (code, signal) => {
+            this.terminationConfirmed = true;
+            this.emit('exit', code, signal);
+        });
+    }
+    /**
+     * Spawn the Rust binary in management mode.
+     * Returns true if the binary was found and spawned successfully.
+     */
+    async spawn(optionsArg) {
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        if (optionsArg?.signal?.aborted) {
+            throw new plugins.smartrust.RustBridgeRequestError('NoSQLDB Rust sidecar spawn was aborted before it started', {
+                code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+                method: 'spawn',
+                cause: optionsArg.signal.reason,
+            });
+        }
+        this.terminationConfirmed = false;
+        this.terminationFailure = undefined;
+        const spawnPromise = this.bridge.spawn();
+        let timeout;
+        let abortHandler;
+        const cancellationPromise = new Promise((_resolveArg, rejectArg) => {
+            if (optionsArg?.timeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    rejectArg(new plugins.smartrust.RustBridgeRequestError(`NoSQLDB Rust sidecar spawn timed out after ${optionsArg.timeoutMs}ms`, {
+                        code: 'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
+                        method: 'spawn',
+                    }));
+                }, optionsArg.timeoutMs);
+            }
+            if (optionsArg?.signal) {
+                abortHandler = () => {
+                    rejectArg(new plugins.smartrust.RustBridgeRequestError('NoSQLDB Rust sidecar spawn was aborted', {
+                        code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+                        method: 'spawn',
+                        cause: optionsArg.signal.reason,
+                    }));
+                };
+                optionsArg.signal.addEventListener('abort', abortHandler, { once: true });
+            }
+        });
+        try {
+            const spawned = await Promise.race([spawnPromise, cancellationPromise]);
+            if (!spawned) {
+                await this.terminate({ gracePeriodMs: 0 });
+            }
+            return spawned;
+        }
+        catch (error) {
+            try {
+                await this.terminate({ gracePeriodMs: 0 });
+            }
+            catch (terminationError) {
+                throw new NoSqlDbManagementOperationTerminationError(error, terminationError);
+            }
+            throw error;
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            if (abortHandler && optionsArg?.signal) {
+                optionsArg.signal.removeEventListener('abort', abortHandler);
+            }
+        }
+    }
+    /**
+     * Kill the Rust process and clean up.
+     */
+    kill() {
+        this.bridge.kill();
+    }
+    /**
+     * Confirm that the Rust process has exited and all bridge resources are released.
+     */
+    terminate(optionsArg) {
+        if (this.terminationPromise) {
+            return this.terminationPromise;
+        }
+        const terminationPromise = this.bridge.terminate(optionsArg).then(() => {
+            this.terminationConfirmed = true;
+            this.terminationFailure = undefined;
+        }, (errorArg) => {
+            this.terminationFailure = errorArg;
+            throw errorArg;
+        });
+        this.terminationPromise = terminationPromise;
+        void terminationPromise.then(() => {
+            if (this.terminationPromise === terminationPromise) {
+                this.terminationPromise = undefined;
+            }
+        }, () => {
+            if (this.terminationPromise === terminationPromise) {
+                this.terminationPromise = undefined;
+            }
+        });
+        return terminationPromise;
+    }
+    /**
+     * Whether the bridge is currently running.
+     */
+    get running() {
+        return this.bridge.running;
+    }
+    get ownershipReleased() {
+        return this.terminationConfirmed;
+    }
+    async awaitManagementOperationTermination(errorArg) {
+        const cancellationRequiresTermination = errorArg instanceof plugins.smartrust.RustBridgeRequestError
+            && [
+                'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+                'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
+            ].includes(errorArg.code);
+        let terminationPromise = this.terminationPromise;
+        if (cancellationRequiresTermination && !terminationPromise) {
+            terminationPromise = this.terminate({ gracePeriodMs: 0 });
+        }
+        if (!terminationPromise) {
+            if (!this.terminationConfirmed && this.terminationFailure !== undefined) {
+                throw new NoSqlDbManagementOperationTerminationError(errorArg, this.terminationFailure);
+            }
+            return;
+        }
+        try {
+            await terminationPromise;
+        }
+        catch (terminationError) {
+            throw new NoSqlDbManagementOperationTerminationError(errorArg, terminationError);
+        }
+    }
+    // --- Convenience methods for each management command ---
+    async [rustDbBridgeStorageRehearsal](inputArg, optionsArg) {
+        const request = normalizeNoSqlDbStorageRehearsalInput(inputArg);
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        try {
+            return await this.bridge.sendCommand('createStoppedStorageRehearsal', { request, timeoutMs: optionsArg.timeoutMs }, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async [rustDbBridgeStorageRootRelocation](inputArg, optionsArg) {
+        const input = normalizeLocalNoSqlDbStoppedStorageRootRelocationInput(inputArg);
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        try {
+            return await this.bridge.sendCommand('relocateStoppedStorageRoot', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async inspectOfflinePhysicalNamespaces(inputArg, optionsArg) {
+        const input = normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput(inputArg);
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        const params = {
+            folderPath: input.folderPath,
+            ...input.limits,
+            timeoutMs: optionsArg?.timeoutMs,
+        };
+        try {
+            return await this.bridge.sendCommand('inspectOfflinePhysicalNamespaces', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async inspectOfflineStringValue(inputArg, optionsArg) {
+        const input = normalizeLocalNoSqlDbOfflineInspectionInput(inputArg);
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        try {
+            return await this.bridge.sendCommand('inspectOfflineStringValue', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async startDb(config, optionsArg) {
+        normalizeNoSqlDbFileStorageOptions(config);
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        try {
+            return await this.bridge.sendCommand('start', { config, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async stopDb() {
+        await this.bridge.sendCommand('stop', {});
+    }
+    async getStatus() {
+        return await this.bridge.sendCommand('getStatus', {});
+    }
+    async getMetrics() {
+        return this.bridge.sendCommand('getMetrics', {});
+    }
+    async getHealth(optionsArg) {
+        try {
+            return await this.bridge.sendCommand('getHealth', {}, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async createDatabaseTenant(params) {
+        try {
+            return await this.bridge.sendCommand('createDatabaseTenant', params);
+        }
+        catch (error) {
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async ensureDatabaseTenant(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('ensureDatabaseTenant', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async attestDatabaseTenant(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('attestDatabaseTenant', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async allocateDatabaseTenant(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('allocateDatabaseTenant', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async deleteDatabaseTenant(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('deleteDatabaseTenant', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async issueDatabaseAllocationReadAccessGrant(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('issueDatabaseAllocationReadAccessGrant', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbAllocationReadAccessGrantError(normalizeNoSqlDbResourceFenceError(error), error instanceof plugins.smartrust.RustBridgeRequestError
+                ? error.responseErrorCode
+                : undefined);
+        }
+    }
+    async revokeDatabaseAllocationReadAccessGrant(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('revokeDatabaseAllocationReadAccessGrant', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbAllocationReadAccessGrantError(normalizeNoSqlDbResourceFenceError(error), error instanceof plugins.smartrust.RustBridgeRequestError
+                ? error.responseErrorCode
+                : undefined);
+        }
+    }
+    async rotateDatabaseTenantPassword(params) {
+        return this.bridge.sendCommand('rotateDatabaseTenantPassword', params);
+    }
+    async listDatabaseTenants() {
+        const result = await this.bridge.sendCommand('listDatabaseTenants', {});
+        return result.tenants;
+    }
+    async getDatabaseTenantDescriptor(params) {
+        return this.bridge.sendCommand('getDatabaseTenantDescriptor', params);
+    }
+    async getDatabaseResourceFenceState(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('getDatabaseResourceFenceState', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async exportDatabase(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('exportDatabase', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async getDatabaseContentDigest(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('getDatabaseContentDigest', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
+    async importDatabase(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('importDatabase', { ...params, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async commitDatabasePublication(params, optionsArg) {
+        try {
+            return await this.bridge.sendCommand('commitDatabasePublication', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw normalizeNoSqlDbResourceFenceError(error);
+        }
+    }
+    async getOpLog(params = {}) {
+        return this.bridge.sendCommand('getOpLog', params);
+    }
+    async getOpLogStats() {
+        return this.bridge.sendCommand('getOpLogStats', {});
+    }
+    async revertToSeq(seq, dryRun = false) {
+        return this.bridge.sendCommand('revertToSeq', { seq, dryRun });
+    }
+    async getCollections(db) {
+        const result = await this.bridge.sendCommand('getCollections', db ? { db } : {});
+        return result.collections;
+    }
+    async getDocuments(db, collection, limit = 50, skip = 0) {
+        return this.bridge.sendCommand('getDocuments', { db, collection, limit, skip });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-db-bridge.js","sourceRoot":"","sources":["../../ts/ts_nosqldb/rust-db-bridge.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_nosqldb/server/classes.nosqldbserver.d.ts

@@ -0,0 +1,204 @@
+import { type TNoSqlDbFileStorageStartup } from '../file-storage-startup.js';
+import type { IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, INoSqlDbMetrics, INoSqlDbQueryOptions } from '../rust-db-bridge.js';
+import type { INoSqlDbHealth, INoSqlDbDatabaseTenantInput, INoSqlDbAttestDatabaseTenantInput, INoSqlDbAttestDatabaseTenantResult, INoSqlDbEnsureDatabaseTenantInput, INoSqlDbEnsureDatabaseTenantResult, INoSqlDbAllocateDatabaseTenantInput, INoSqlDbAllocateDatabaseTenantResult, INoSqlDbDeleteDatabaseTenantInput, INoSqlDbRotateDatabaseTenantPasswordInput, INoSqlDbDatabaseTenantDescriptor, INoSqlDbDeleteDatabaseTenantResult, INoSqlDbIssueDatabaseAllocationReadAccessGrantInput, INoSqlDbIssueDatabaseAllocationReadAccessGrantResult, INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput, INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult, INoSqlDbDatabaseExport, INoSqlDbExportDatabaseInput, INoSqlDbDatabaseContentDigest, INoSqlDbGetDatabaseContentDigestInput, INoSqlDbImportDatabaseInput, INoSqlDbImportDatabaseResult, INoSqlDbCommitDatabasePublicationInput, INoSqlDbManagementOperationOptions, INoSqlDbDatabaseResourceFenceState, TNoSqlDbCommitDatabasePublicationResult } from '../service-types.js';
+/**
+ * Server configuration options
+ */
+export interface INoSqlDbServerOptions {
+    /** Exact engine executable. Invalid explicit paths reject without chmod or discovery fallback. Omit for normal discovery. */
+    binaryPath?: string;
+    /** Exact rehearsal operation ID. Requires authenticated current-format-only file storage and an explicit private Unix socket. Never promotes a rehearsal. */
+    storageRehearsalId?: string;
+    /** Default: current-format-only. The native owner rejects foreign, mixed and migration staging roots without conversion. */
+    fileStorageStartup?: TNoSqlDbFileStorageStartup;
+    /** Port to listen on (default: 27017, 0 requests an OS-assigned port) - ignored if socketPath is set */
+    port?: number;
+    /** Host to bind to (default: 127.0.0.1) - ignored if socketPath is set */
+    host?: string;
+    /** Unix socket path - if set, server listens on socket instead of TCP */
+    socketPath?: string;
+    /** Storage type: 'memory' or 'file' (default: 'memory') */
+    storage?: 'memory' | 'file';
+    /** Path for file storage (required if storage is 'file') */
+    storagePath?: string;
+    /** Authentication configuration. Disabled by default. */
+    auth?: INoSqlDbAuthOptions;
+    /** TLS transport configuration for TCP listeners. Disabled by default. */
+    tls?: INoSqlDbTlsOptions;
+    /** In-memory oplog retention limits (defaults: 10000 entries / 64 MiB). */
+    oplog?: INoSqlDbOplogOptions;
+    /** Memory, temporary storage, and concurrency admission for large sorts. */
+    query?: INoSqlDbQueryOptions;
+}
+export interface INoSqlDbOplogOptions {
+    /** Maximum number of retained oplog entries (default: 10000). */
+    maxEntries?: number;
+    /** Maximum approximate retained bytes (default: 64 MiB). Oldest entries are evicted first; reverts cannot reach past evicted entries. */
+    maxBytes?: number;
+}
+export interface INoSqlDbAuthOptions {
+    enabled?: boolean;
+    users?: INoSqlDbAuthUser[];
+    scramIterations?: number;
+}
+export interface INoSqlDbAuthUser {
+    username: string;
+    password: string;
+    database?: string;
+    roles?: string[];
+}
+export interface INoSqlDbTlsOptions {
+    enabled?: boolean;
+    certPath?: string;
+    keyPath?: string;
+    caPath?: string;
+    requireClientCert?: boolean;
+}
+/**
+ * NoSqlDbServer - Wire protocol compatible database server backed by Rust
+ *
+ * This server implements the wire protocol to allow official drivers to
+ * connect and perform operations. The core engine runs as a Rust sidecar
+ * binary managed via @push.rocks/smartrust IPC.
+ *
+ * @example
+ * ```typescript
+ * import { NoSqlDbServer } from '@lossless.org/nosqldb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new NoSqlDbServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient(server.getConnectionUri());
+ * await client.connect();
+ * ```
+ */
+export declare class NoSqlDbServer {
+    private options;
+    private bridge;
+    private bridgeOwned;
+    private startInProgress;
+    private startCompletionPromise;
+    private isRunning;
+    private resolvedConnectionUri;
+    private resolvedPort;
+    constructor(options?: INoSqlDbServerOptions);
+    /**
+     * Start the server
+     */
+    start(optionsArg?: INoSqlDbManagementOperationOptions): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the connection URI for this server
+     */
+    getConnectionUri(): string;
+    /**
+     * Get the socket path (if using Unix socket mode)
+     */
+    get socketPath(): string | undefined;
+    /**
+     * Check if the server is running
+     */
+    /** Process id of the spawned Rust engine, when it runs as a child process. */
+    get processId(): number | undefined;
+    get running(): boolean;
+    private runDatabaseManagementOperation;
+    /**
+     * Get the port the server is listening on
+     */
+    get port(): number;
+    /**
+     * Get the host the server is bound to
+     */
+    get host(): string;
+    /**
+     * Create an isolated database/user pair for an application tenant.
+     */
+    createDatabaseTenant(params: INoSqlDbDatabaseTenantInput): Promise<INoSqlDbDatabaseTenantDescriptor>;
+    /** Authoritatively allocate an absent, fenced database tenant. */
+    allocateDatabaseTenant(params: INoSqlDbAllocateDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbAllocateDatabaseTenantResult>;
+    /**
+     * Idempotently provision or rotate one exclusively owned database tenant.
+     */
+    ensureDatabaseTenant(params: INoSqlDbEnsureDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbEnsureDatabaseTenantResult>;
+    /** Verify an exact tenant credential without changing provider state. */
+    attestDatabaseTenant(params: INoSqlDbAttestDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbAttestDatabaseTenantResult>;
+    /**
+     * Delete a tenant database and its tenant user(s).
+     */
+    deleteDatabaseTenant(params: INoSqlDbDeleteDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDeleteDatabaseTenantResult>;
+    /** Issue one fixed-expiry read grant bound to an exact active allocation. */
+    issueDatabaseAllocationReadAccessGrant(params: INoSqlDbIssueDatabaseAllocationReadAccessGrantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbIssueDatabaseAllocationReadAccessGrantResult>;
+    /** Idempotently revoke one allocation read grant without returning a secret. */
+    revokeDatabaseAllocationReadAccessGrant(params: INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult>;
+    /**
+     * Rotate a tenant user's password without restarting the server.
+     */
+    rotateDatabaseTenantPassword(params: INoSqlDbRotateDatabaseTenantPasswordInput): Promise<INoSqlDbDatabaseTenantDescriptor>;
+    /**
+     * List known database tenants.
+     */
+    listDatabaseTenants(): Promise<INoSqlDbDatabaseTenantDescriptor[]>;
+    /**
+     * Get a tenant descriptor without exposing a password.
+     */
+    getDatabaseTenantDescriptor(params: {
+        databaseName: string;
+        username: string;
+    }): Promise<INoSqlDbDatabaseTenantDescriptor>;
+    /** Inspect the durable high-water mark without exposing mutation receipts. */
+    getDatabaseResourceFenceState(params: {
+        databaseName: string;
+    }, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDatabaseResourceFenceState | null>;
+    /**
+     * Export one database as an Extended JSON snapshot.
+     */
+    exportDatabase(params: INoSqlDbExportDatabaseInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDatabaseExport>;
+    /** Compute a bounded, database-name-independent digest of logical database content. */
+    getDatabaseContentDigest(params: INoSqlDbGetDatabaseContentDigestInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDatabaseContentDigest>;
+    /**
+     * Replace one database with a previously exported snapshot.
+     */
+    importDatabase(params: INoSqlDbImportDatabaseInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbImportDatabaseResult>;
+    /** Release an exact held database publication after downstream fsync. */
+    commitDatabasePublication(params: INoSqlDbCommitDatabasePublicationInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<TNoSqlDbCommitDatabasePublicationResult>;
+    /**
+     * Get readiness/health details for long-running service use.
+     */
+    getHealth(optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbHealth>;
+    /**
+     * Get oplog entries, optionally filtered.
+     */
+    getOpLog(params?: {
+        sinceSeq?: number;
+        limit?: number;
+        db?: string;
+        collection?: string;
+    }): Promise<IOpLogResult>;
+    /**
+     * Get aggregate oplog statistics.
+     */
+    getOpLogStats(): Promise<IOpLogStats>;
+    /**
+     * Revert database state to a specific oplog sequence number.
+     * Use dryRun=true to preview which entries would be reverted.
+     */
+    revertToSeq(seq: number, dryRun?: boolean): Promise<IRevertResult>;
+    /**
+     * List all collections across all databases, with document counts.
+     */
+    getCollections(db?: string): Promise<ICollectionInfo[]>;
+    /**
+     * Get documents from a collection with pagination.
+     */
+    getDocuments(db: string, collection: string, limit?: number, skip?: number): Promise<IDocumentsResult>;
+    /**
+     * Get server metrics including database/collection counts and oplog info.
+     */
+    getMetrics(): Promise<INoSqlDbMetrics>;
+    private withTenantMongoUri;
+    private buildTenantMongoUri;
+}