@lossless.org/nosqldb 8.0.0

package/dist_ts/ts_nosqldb/resource-fencing.js

@@ -0,0 +1,271 @@
+import * as plugins from './plugins.js';
+const typedPayloadPrefix = plugins.buffer.Buffer.from('smartdb.effective-payload.typed.v1\0', 'utf8');
+const minimumI64 = -9223372036854775808n;
+const maximumU64 = 18446744073709551615n;
+const compareUtf8Keys = (leftArg, rightArg) => plugins.buffer.Buffer.compare(plugins.buffer.Buffer.from(leftArg, 'utf8'), plugins.buffer.Buffer.from(rightArg, 'utf8'));
+const formatSerdeJsonFloat = (valueArg) => {
+    const transportNumber = JSON.stringify(valueArg);
+    if (/^-?\d+$/.test(transportNumber)) {
+        const integer = BigInt(transportNumber);
+        if (integer >= minimumI64 && integer <= maximumU64) {
+            return transportNumber;
+        }
+    }
+    const negative = valueArg < 0;
+    const source = Math.abs(valueArg).toString().toLowerCase();
+    let digits;
+    let decimalExponent;
+    if (source.includes('e')) {
+        const [coefficient, exponent] = source.split('e');
+        digits = coefficient.replace('.', '').replace(/^0+|0+$/g, '');
+        decimalExponent = Number.parseInt(exponent, 10);
+    }
+    else {
+        const [integerPart, fractionPart = ''] = source.split('.');
+        const rawDigits = `${integerPart}${fractionPart}`;
+        const firstSignificant = rawDigits.search(/[1-9]/);
+        const lastSignificant = rawDigits.search(/[1-9](?!.*[1-9])/);
+        if (firstSignificant < 0) {
+            return '0.0';
+        }
+        digits = rawDigits.slice(firstSignificant, lastSignificant + 1);
+        decimalExponent = integerPart.length - firstSignificant - 1;
+    }
+    let rendered;
+    if (decimalExponent >= -5 && decimalExponent <= 15) {
+        const integerDigits = decimalExponent + 1;
+        if (digits.length <= integerDigits) {
+            rendered = `${digits}${'0'.repeat(integerDigits - digits.length)}.0`;
+        }
+        else if (integerDigits > 0) {
+            rendered = `${digits.slice(0, integerDigits)}.${digits.slice(integerDigits)}`;
+        }
+        else {
+            rendered = `0.${'0'.repeat(-integerDigits)}${digits}`;
+        }
+    }
+    else {
+        const significand = digits.length === 1 ? digits : `${digits[0]}.${digits.slice(1)}`;
+        rendered = `${significand}e${decimalExponent >= 0 ? '+' : ''}${decimalExponent}`;
+    }
+    return negative ? `-${rendered}` : rendered;
+};
+const canonicalJsonStringify = (valueArg) => {
+    if (typeof valueArg === 'number') {
+        return formatSerdeJsonFloat(valueArg);
+    }
+    if (valueArg === null || typeof valueArg !== 'object') {
+        const serialized = JSON.stringify(valueArg);
+        if (serialized === undefined) {
+            throw new TypeError('NoSQLDB effective payload contains unsupported JSON');
+        }
+        return serialized;
+    }
+    if (Array.isArray(valueArg)) {
+        return `[${valueArg.map((entryArg) => canonicalJsonStringify(entryArg)).join(',')}]`;
+    }
+    return `{${Object.keys(valueArg)
+        .map((keyArg) => `${JSON.stringify(keyArg)}:${canonicalJsonStringify(valueArg[keyArg])}`)
+        .join(',')}}`;
+};
+const encodeTypedLength = (lengthArg) => {
+    const encoded = plugins.buffer.Buffer.allocUnsafe(8);
+    encoded.writeBigUInt64BE(BigInt(lengthArg));
+    return encoded;
+};
+const encodeTypedBytes = (valueArg) => [
+    encodeTypedLength(valueArg.byteLength),
+    valueArg,
+];
+const encodeTypedValue = (valueArg, chunksArg) => {
+    if (valueArg === null) {
+        chunksArg.push(plugins.buffer.Buffer.from([0]));
+        return;
+    }
+    if (valueArg === false) {
+        chunksArg.push(plugins.buffer.Buffer.from([1]));
+        return;
+    }
+    if (valueArg === true) {
+        chunksArg.push(plugins.buffer.Buffer.from([2]));
+        return;
+    }
+    if (typeof valueArg === 'number') {
+        if (!Number.isFinite(valueArg)) {
+            throw new TypeError('NoSQLDB exact replace contains a non-finite number');
+        }
+        const encoded = plugins.buffer.Buffer.allocUnsafe(9);
+        encoded[0] = 3;
+        encoded.writeDoubleBE(valueArg, 1);
+        chunksArg.push(encoded);
+        return;
+    }
+    if (typeof valueArg === 'string') {
+        const encoded = plugins.buffer.Buffer.from(valueArg, 'utf8');
+        chunksArg.push(plugins.buffer.Buffer.from([4]), ...encodeTypedBytes(encoded));
+        return;
+    }
+    if (Array.isArray(valueArg)) {
+        chunksArg.push(plugins.buffer.Buffer.from([5]), encodeTypedLength(valueArg.length));
+        for (const value of valueArg) {
+            encodeTypedValue(value, chunksArg);
+        }
+        return;
+    }
+    const keys = Object.keys(valueArg).sort(compareUtf8Keys);
+    chunksArg.push(plugins.buffer.Buffer.from([6]), encodeTypedLength(keys.length));
+    for (const key of keys) {
+        const encodedKey = plugins.buffer.Buffer.from(key, 'utf8');
+        chunksArg.push(plugins.buffer.Buffer.from([4]), ...encodeTypedBytes(encodedKey));
+        encodeTypedValue(valueArg[key], chunksArg);
+    }
+};
+const encodeTypedPayload = (valueArg) => {
+    const chunks = [typedPayloadPrefix];
+    encodeTypedValue(valueArg, chunks);
+    return plugins.buffer.Buffer.concat(chunks);
+};
+/**
+ * Computes the provider-derived SHA-256 identity for NoSQLDB's version 1
+ * fenced replace, exact-user delete, and exact-user ensure payload profiles.
+ */
+export const createNoSqlDbEffectivePayloadSha256V1 = (inputArg) => {
+    if (inputArg.version !== 1) {
+        throw new TypeError('NoSQLDB effective payload version must be 1');
+    }
+    if (typeof inputArg.databaseName !== 'string') {
+        throw new TypeError('NoSQLDB effective payload databaseName must be a string');
+    }
+    let effectivePayload;
+    let useTypedEncoding = false;
+    switch (inputArg.kind) {
+        case 'smartdb.database.replace.v1':
+            if (inputArg.username !== undefined &&
+                typeof inputArg.username !== 'string') {
+                throw new TypeError('NoSQLDB exact replace username must be a string');
+            }
+            if (inputArg.holdPublication !== undefined &&
+                typeof inputArg.holdPublication !== 'boolean') {
+                throw new TypeError('NoSQLDB holdPublication must be a Boolean');
+            }
+            effectivePayload = {
+                version: 1,
+                kind: inputArg.kind,
+                databaseName: inputArg.databaseName,
+                source: inputArg.source,
+                ...(inputArg.username === undefined
+                    ? {}
+                    : { username: inputArg.username }),
+                ...(inputArg.allocation === undefined
+                    ? {}
+                    : { allocation: inputArg.allocation }),
+                ...(inputArg.holdPublication === true
+                    ? { holdPublication: true }
+                    : {}),
+            };
+            useTypedEncoding =
+                inputArg.username !== undefined ||
+                    inputArg.allocation !== undefined ||
+                    inputArg.holdPublication === true;
+            break;
+        case 'smartdb.database.ensure.v1': {
+            if (typeof inputArg.username !== 'string') {
+                throw new TypeError('NoSQLDB exact ensure username must be a string');
+            }
+            if (typeof inputArg.password !== 'string') {
+                throw new TypeError('NoSQLDB exact ensure password must be a string');
+            }
+            const roles = inputArg.roles ?? ['readWrite', 'dbAdmin'];
+            if (!Array.isArray(roles) ||
+                roles.some((roleArg) => typeof roleArg !== 'string' || roleArg.length === 0)) {
+                throw new TypeError('NoSQLDB exact ensure roles must be an array of non-empty strings');
+            }
+            const canonicalRoles = [...new Set(roles)].sort(compareUtf8Keys);
+            effectivePayload = {
+                version: 1,
+                kind: inputArg.kind,
+                databaseName: inputArg.databaseName,
+                username: inputArg.username,
+                passwordSha256: plugins.crypto
+                    .createHash('sha256')
+                    .update(inputArg.password, 'utf8')
+                    .digest('hex'),
+                roles: canonicalRoles,
+                ...(inputArg.allocation === undefined
+                    ? {}
+                    : { allocation: inputArg.allocation }),
+            };
+            useTypedEncoding = inputArg.allocation !== undefined;
+            break;
+        }
+        case 'smartdb.database.allocate.v1': {
+            if (inputArg.expectedAbsent !== true) {
+                throw new TypeError('NoSQLDB allocation expectedAbsent must be true');
+            }
+            if (typeof inputArg.username !== 'string') {
+                throw new TypeError('NoSQLDB allocation username must be a string');
+            }
+            if (typeof inputArg.password !== 'string') {
+                throw new TypeError('NoSQLDB allocation password must be a string');
+            }
+            const roles = inputArg.roles ?? ['readWrite', 'dbAdmin'];
+            if (!Array.isArray(roles) || roles.some((roleArg) => typeof roleArg !== 'string' || roleArg.length === 0)) {
+                throw new TypeError('NoSQLDB allocation roles must be an array of non-empty strings');
+            }
+            effectivePayload = {
+                version: 1,
+                kind: inputArg.kind,
+                databaseName: inputArg.databaseName,
+                expectedAbsent: true,
+                username: inputArg.username,
+                passwordSha256: plugins.crypto
+                    .createHash('sha256')
+                    .update(inputArg.password, 'utf8')
+                    .digest('hex'),
+                roles: [...new Set(roles)].sort(compareUtf8Keys),
+            };
+            useTypedEncoding = true;
+            break;
+        }
+        case 'smartdb.database.delete.v1':
+            if (inputArg.username !== undefined &&
+                typeof inputArg.username !== 'string') {
+                throw new TypeError('NoSQLDB exact delete username must be a string when supplied');
+            }
+            if (inputArg.holdPublication !== undefined &&
+                typeof inputArg.holdPublication !== 'boolean') {
+                throw new TypeError('NoSQLDB holdPublication must be a Boolean');
+            }
+            effectivePayload = {
+                version: 1,
+                kind: inputArg.kind,
+                databaseName: inputArg.databaseName,
+                ...(inputArg.username === undefined
+                    ? { rawDatabaseOnly: true }
+                    : { username: inputArg.username, rawDatabaseOnly: false }),
+                ...(inputArg.allocation === undefined
+                    ? {}
+                    : { allocation: inputArg.allocation }),
+                ...(inputArg.holdPublication === true
+                    ? { holdPublication: true }
+                    : {}),
+            };
+            useTypedEncoding = inputArg.allocation !== undefined;
+            break;
+        default:
+            throw new TypeError('NoSQLDB mutation kind has no version 1 payload profile');
+    }
+    const transportJson = JSON.stringify(effectivePayload);
+    if (transportJson === undefined) {
+        throw new TypeError('NoSQLDB effective payload cannot be encoded as JSON');
+    }
+    const normalizedPayload = JSON.parse(transportJson);
+    const encodedPayload = useTypedEncoding
+        ? encodeTypedPayload(normalizedPayload)
+        : canonicalJsonStringify(normalizedPayload);
+    return plugins.crypto
+        .createHash('sha256')
+        .update(encodedPayload)
+        .digest('hex');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-fencing.js","sourceRoot":"","sources":["../../ts/ts_nosqldb/resource-fencing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAoDxC,MAAM,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CACnD,sCAAsC,EACtC,MAAM,CACP,CAAC;AACF,MAAM,UAAU,GAAG,CAAC,oBAA0B,CAAC;AAC/C,MAAM,UAAU,GAAG,qBAA2B,CAAC;AAE/C,MAAM,eAAe,GAAG,CAAC,OAAe,EAAE,QAAgB,EAAU,EAAE,CACpE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAC3B,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,EAC3C,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAC7C,CAAC;AAEJ,MAAM,oBAAoB,GAAG,CAAC,QAAgB,EAAU,EAAE;IACxD,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACjD,IAAI,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;QACxC,IAAI,OAAO,IAAI,UAAU,IAAI,OAAO,IAAI,UAAU,EAAE,CAAC;YACnD,OAAO,eAAe,CAAC;QACzB,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,GAAG,CAAC,CAAC;IAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,CAAC;IAC3D,IAAI,MAAc,CAAC;IACnB,IAAI,eAAuB,CAAC;IAC5B,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAClD,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAC9D,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAClD,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,WAAW,EAAE,YAAY,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,GAAG,WAAW,GAAG,YAAY,EAAE,CAAC;QAClD,MAAM,gBAAgB,GAAG,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACnD,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;QAC7D,IAAI,gBAAgB,GAAG,CAAC,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,gBAAgB,EAAE,eAAe,GAAG,CAAC,CAAC,CAAC;QAChE,eAAe,GAAG,WAAW,CAAC,MAAM,GAAG,gBAAgB,GAAG,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,QAAgB,CAAC;IACrB,IAAI,eAAe,IAAI,CAAC,CAAC,IAAI,eAAe,IAAI,EAAE,EAAE,CAAC;QACnD,MAAM,aAAa,GAAG,eAAe,GAAG,CAAC,CAAC;QAC1C,IAAI,MAAM,CAAC,MAAM,IAAI,aAAa,EAAE,CAAC;YACnC,QAAQ,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;QACvE,CAAC;aAAM,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;YAC7B,QAAQ,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;QAChF,CAAC;aAAM,CAAC;YACN,QAAQ,GAAG,KAAK,GAAG,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GAAG,MAAM,EAAE,CAAC;QACxD,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,WAAW,GACf,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACnE,QAAQ,GAAG,GAAG,WAAW,IAAI,eAAe,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,eAAe,EAAE,CAAC;IACnF,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC9C,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAAC,QAA6B,EAAU,EAAE;IACvE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACtD,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,IAAI,SAAS,CAAC,qDAAqD,CAAC,CAAC;QAC7E,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IACvF,CAAC;IACD,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;SAC7B,GAAG,CACF,CAAC,MAAM,EAAE,EAAE,CACT,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,sBAAsB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAC1E;SACA,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,iBAAiB,GAAG,CAAC,SAAiB,EAAc,EAAE;IAC1D,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IACrD,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IAC5C,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,QAAoB,EAAgB,EAAE,CAAC;IAC/D,iBAAiB,CAAC,QAAQ,CAAC,UAAU,CAAC;IACtC,QAAQ;CACT,CAAC;AAEF,MAAM,gBAAgB,GAAG,CACvB,QAA6B,EAC7B,SAAuB,EACjB,EAAE;IACR,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,OAAO;IACT,CAAC;IACD,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;QACvB,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,OAAO;IACT,CAAC;IACD,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,OAAO;IACT,CAAC;IACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAC;QAC5E,CAAC;QACD,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACrD,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACf,OAAO,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QACnC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxB,OAAO;IACT,CAAC;IACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC7D,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9E,OAAO;IACT,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,SAAS,CAAC,IAAI,CACZ,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAC/B,iBAAiB,CAAC,QAAQ,CAAC,MAAM,CAAC,CACnC,CAAC;QACF,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACrC,CAAC;QACD,OAAO;IACT,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IACzD,SAAS,CAAC,IAAI,CACZ,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAC/B,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,CAC/B,CAAC;IACF,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC3D,SAAS,CAAC,IAAI,CACZ,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAC/B,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAChC,CAAC;QACF,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC;IAC7C,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,QAA6B,EAAc,EAAE;IACvE,MAAM,MAAM,GAAiB,CAAC,kBAAkB,CAAC,CAAC;IAClD,gBAAgB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnC,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAC9C,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,CACnD,QAAyC,EACjC,EAAE;IACV,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,SAAS,CAAC,6CAA6C,CAAC,CAAC;IACrE,CAAC;IACD,IAAI,OAAO,QAAQ,CAAC,YAAY,KAAK,QAAQ,EAAE,CAAC;QAC9C,MAAM,IAAI,SAAS,CAAC,yDAAyD,CAAC,CAAC;IACjF,CAAC;IAED,IAAI,gBAAwB,CAAC;IAC7B,IAAI,gBAAgB,GAAG,KAAK,CAAC;IAC7B,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtB,KAAK,6BAA6B;YAChC,IACE,QAAQ,CAAC,QAAQ,KAAK,SAAS;gBAC/B,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,EACrC,CAAC;gBACD,MAAM,IAAI,SAAS,CAAC,iDAAiD,CAAC,CAAC;YACzE,CAAC;YACD,IACE,QAAQ,CAAC,eAAe,KAAK,SAAS;gBACtC,OAAO,QAAQ,CAAC,eAAe,KAAK,SAAS,EAC7C,CAAC;gBACD,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAC;YACnE,CAAC;YACD,gBAAgB,GAAG;gBACjB,OAAO,EAAE,CAAC;gBACV,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,GAAG,CAAC,QAAQ,CAAC,QAAQ,KAAK,SAAS;oBACjC,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBACpC,GAAG,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS;oBACnC,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;gBACxC,GAAG,CAAC,QAAQ,CAAC,eAAe,KAAK,IAAI;oBACnC,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE;oBAC3B,CAAC,CAAC,EAAE,CAAC;aACR,CAAC;YACF,gBAAgB;gBACd,QAAQ,CAAC,QAAQ,KAAK,SAAS;oBAC/B,QAAQ,CAAC,UAAU,KAAK,SAAS;oBACjC,QAAQ,CAAC,eAAe,KAAK,IAAI,CAAC;YACpC,MAAM;QACR,KAAK,4BAA4B,CAAC,CAAC,CAAC;YAClC,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1C,MAAM,IAAI,SAAS,CAAC,gDAAgD,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1C,MAAM,IAAI,SAAS,CAAC,gDAAgD,CAAC,CAAC;YACxE,CAAC;YACD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;YACzD,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACrB,KAAK,CAAC,IAAI,CACR,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,CACjE,EACD,CAAC;gBACD,MAAM,IAAI,SAAS,CACjB,kEAAkE,CACnE,CAAC;YACJ,CAAC;YACD,MAAM,cAAc,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACjE,gBAAgB,GAAG;gBACjB,OAAO,EAAE,CAAC;gBACV,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,cAAc,EAAE,OAAO,CAAC,MAAM;qBAC3B,UAAU,CAAC,QAAQ,CAAC;qBACpB,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;qBACjC,MAAM,CAAC,KAAK,CAAC;gBAChB,KAAK,EAAE,cAAc;gBACrB,GAAG,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS;oBACnC,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;aACzC,CAAC;YACF,gBAAgB,GAAG,QAAQ,CAAC,UAAU,KAAK,SAAS,CAAC;YACrD,MAAM;QACR,CAAC;QACD,KAAK,8BAA8B,CAAC,CAAC,CAAC;YACpC,IAAI,QAAQ,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC;gBACrC,MAAM,IAAI,SAAS,CAAC,gDAAgD,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1C,MAAM,IAAI,SAAS,CAAC,8CAA8C,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1C,MAAM,IAAI,SAAS,CAAC,8CAA8C,CAAC,CAAC;YACtE,CAAC;YACD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;YACzD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC1G,MAAM,IAAI,SAAS,CAAC,gEAAgE,CAAC,CAAC;YACxF,CAAC;YACD,gBAAgB,GAAG;gBACjB,OAAO,EAAE,CAAC;gBACV,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,cAAc,EAAE,IAAI;gBACpB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,cAAc,EAAE,OAAO,CAAC,MAAM;qBAC3B,UAAU,CAAC,QAAQ,CAAC;qBACpB,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;qBACjC,MAAM,CAAC,KAAK,CAAC;gBAChB,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC;aACjD,CAAC;YACF,gBAAgB,GAAG,IAAI,CAAC;YACxB,MAAM;QACR,CAAC;QACD,KAAK,4BAA4B;YAC/B,IACE,QAAQ,CAAC,QAAQ,KAAK,SAAS;gBAC/B,OAAO,QAAQ,CAAC,QAAQ,KAAK,QAAQ,EACrC,CAAC;gBACD,MAAM,IAAI,SAAS,CAAC,8DAA8D,CAAC,CAAC;YACtF,CAAC;YACD,IACE,QAAQ,CAAC,eAAe,KAAK,SAAS;gBACtC,OAAO,QAAQ,CAAC,eAAe,KAAK,SAAS,EAC7C,CAAC;gBACD,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAC;YACnE,CAAC;YACD,gBAAgB,GAAG;gBACjB,OAAO,EAAE,CAAC;gBACV,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,GAAG,CAAC,QAAQ,CAAC,QAAQ,KAAK,SAAS;oBACjC,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE;oBAC3B,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;gBAC5D,GAAG,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS;oBACnC,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,EAAE,CAAC;gBACxC,GAAG,CAAC,QAAQ,CAAC,eAAe,KAAK,IAAI;oBACnC,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE;oBAC3B,CAAC,CAAC,EAAE,CAAC;aACR,CAAC;YACF,gBAAgB,GAAG,QAAQ,CAAC,UAAU,KAAK,SAAS,CAAC;YACrD,MAAM;QACR;YACE,MAAM,IAAI,SAAS,CAAC,wDAAwD,CAAC,CAAC;IAClF,CAAC;IAED,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IACvD,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QAChC,MAAM,IAAI,SAAS,CAAC,qDAAqD,CAAC,CAAC;IAC7E,CAAC;IACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAwB,CAAC;IAC3E,MAAM,cAAc,GAAG,gBAAgB;QACrC,CAAC,CAAC,kBAAkB,CAAC,iBAAiB,CAAC;QACvC,CAAC,CAAC,sBAAsB,CAAC,iBAAiB,CAAC,CAAC;IAC9C,OAAO,OAAO,CAAC,MAAM;SAClB,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,cAAc,CAAC;SACtB,MAAM,CAAC,KAAK,CAAC,CAAC;AACnB,CAAC,CAAC"}

package/dist_ts/ts_nosqldb/rust-db-bridge.d.ts

@@ -0,0 +1,213 @@
+import * as plugins from './plugins.js';
+import { EventEmitter } from 'events';
+import { type INoSqlDbStorageRehearsalInput, type INoSqlDbStorageRehearsalReceipt } from './storage-rehearsal.js';
+import { type ILocalNoSqlDbStoppedStorageRootRelocationInput, type ILocalNoSqlDbStoppedStorageRootRelocationReceipt } from './storage-root-relocation.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, ILocalNoSqlDbOfflinePhysicalNamespaceInspection, ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult, ILocalNoSqlDbOfflineStringValueInspection, TLocalNoSqlDbOfflineStringValueInspectionResult, TNoSqlDbCommitDatabasePublicationResult } from './service-types.js';
+export type { INoSqlDbHealth, INoSqlDbDatabaseTenantInput, INoSqlDbAttestDatabaseTenantInput, INoSqlDbAttestDatabaseTenantResult, INoSqlDbEnsureDatabaseTenantInput, INoSqlDbEnsureDatabaseTenantResult, INoSqlDbAllocateDatabaseTenantInput, INoSqlDbAllocateDatabaseTenantResult, INoSqlDbDeleteDatabaseTenantInput, INoSqlDbRotateDatabaseTenantPasswordInput, INoSqlDbDatabaseTenantDescriptor, INoSqlDbDeleteDatabaseTenantResult, INoSqlDbDatabaseAllocationReadAccessGrantIdentity, INoSqlDbIssueDatabaseAllocationReadAccessGrantInput, INoSqlDbIssueDatabaseAllocationReadAccessGrantResult, INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput, INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult, INoSqlDbDatabaseExportCollection, INoSqlDbDatabaseExport, INoSqlDbImportDatabaseInput, INoSqlDbImportDatabaseResult, INoSqlDbHeldPublicationReceipt, INoSqlDbCommitDatabasePublicationInput, INoSqlDbManagementOperationOptions, INoSqlDbDatabaseResourceFenceState, ILocalNoSqlDbOfflineInspectionLimits, ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits, ILocalNoSqlDbOfflinePhysicalNamespaceInspection, ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult, ILocalNoSqlDbOfflineStringValueInspection, TLocalNoSqlDbOfflineStringValueInspectionResult, TNoSqlDbCommitDatabasePublicationResult, } from './service-types.js';
+/**
+ * A single oplog entry returned from the Rust engine.
+ */
+export interface IOpLogEntry {
+    seq: number;
+    timestampMs: number;
+    op: 'insert' | 'update' | 'delete';
+    db: string;
+    collection: string;
+    documentId: string;
+    document: Record<string, any> | null;
+    previousDocument: Record<string, any> | null;
+}
+/**
+ * Aggregate oplog statistics.
+ */
+export interface IOpLogStats {
+    currentSeq: number;
+    totalEntries: number;
+    oldestSeq: number;
+    /** Approximate retained bytes across all in-memory oplog entries. */
+    approxBytes: number;
+    entriesByOp: {
+        insert: number;
+        update: number;
+        delete: number;
+    };
+}
+/**
+ * Result of a getOpLog query.
+ */
+export interface IOpLogResult {
+    entries: IOpLogEntry[];
+    currentSeq: number;
+    totalEntries: number;
+}
+/**
+ * Result of a revertToSeq command.
+ */
+export interface IRevertResult {
+    dryRun: boolean;
+    reverted: number;
+    targetSeq?: number;
+    entries?: IOpLogEntry[];
+    errors?: string[];
+}
+/**
+ * A collection info entry.
+ */
+export interface ICollectionInfo {
+    db: string;
+    name: string;
+    count: number;
+}
+/**
+ * Result of a getDocuments query.
+ */
+export interface IDocumentsResult {
+    documents: Record<string, any>[];
+    total: number;
+}
+export declare class NoSqlDbManagementOperationTerminationError extends AggregateError {
+    constructor(operationErrorArg: unknown, terminationErrorArg: unknown);
+}
+/**
+ * Server metrics.
+ */
+export interface INoSqlDbMetrics {
+    databases: number;
+    collections: number;
+    oplogEntries: number;
+    oplogCurrentSeq: number;
+    sessions: number;
+    activeTransactions: number;
+    authEnabled: boolean;
+    authUsers: number;
+    uptimeSeconds: number;
+}
+export declare const rustDbBridgeStorageRootRelocation: unique symbol;
+export declare const rustDbBridgeStorageRehearsal: unique symbol;
+/**
+ * Configuration sent to the Rust binary on start.
+ */
+export interface INoSqlDbQueryOptions {
+    /** Target encoded bytes per in-memory sort run (default: 4 MiB). */
+    sortBufferBytes?: number;
+    /** Shared temporary sort-file budget, including merge output (default: 4 GiB). */
+    maxSortSpillBytes?: number;
+    /** Concurrent sort builders (default: 4). */
+    maxConcurrentSorts?: number;
+}
+interface INoSqlDbRustConfig {
+    storageRehearsalId?: string;
+    port?: number;
+    host?: string;
+    socketPath?: string;
+    storage: 'memory' | 'file';
+    storagePath?: string;
+    query?: INoSqlDbQueryOptions;
+    auth?: {
+        enabled?: boolean;
+        users?: Array<{
+            username: string;
+            password: string;
+            database?: string;
+            roles?: string[];
+        }>;
+        scramIterations?: number;
+    };
+    tls?: {
+        enabled?: boolean;
+        certPath?: string;
+        keyPath?: string;
+        caPath?: string;
+        requireClientCert?: boolean;
+    };
+    oplog?: {
+        maxEntries?: number;
+        maxBytes?: number;
+    };
+}
+export declare function getRustDbAllocatorEnv(environment?: NodeJS.ProcessEnv): Record<string, string>;
+export interface IRustDbBridgeOptions {
+    /** Exact engine executable, validated by Smartrust without discovery fallback or permission changes. */
+    binaryPath?: string;
+}
+/**
+ * Bridge between TypeScript NoSqlDbServer and the Rust binary.
+ * Wraps @push.rocks/smartrust's RustBridge with type-safe command definitions.
+ */
+export declare class RustDbBridge extends EventEmitter {
+    private bridge;
+    /**
+     * 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(): number | undefined;
+    private terminationConfirmed;
+    private terminationPromise;
+    private terminationFailure;
+    constructor(options?: IRustDbBridgeOptions);
+    /**
+     * Spawn the Rust binary in management mode.
+     * Returns true if the binary was found and spawned successfully.
+     */
+    spawn(optionsArg?: INoSqlDbManagementOperationOptions): Promise<boolean>;
+    /**
+     * Kill the Rust process and clean up.
+     */
+    kill(): void;
+    /**
+     * Confirm that the Rust process has exited and all bridge resources are released.
+     */
+    terminate(optionsArg?: plugins.smartrust.IRustBridgeTerminateOptions): Promise<void>;
+    /**
+     * Whether the bridge is currently running.
+     */
+    get running(): boolean;
+    get ownershipReleased(): boolean;
+    private awaitManagementOperationTermination;
+    [rustDbBridgeStorageRehearsal](inputArg: INoSqlDbStorageRehearsalInput, optionsArg: INoSqlDbManagementOperationOptions & {
+        timeoutMs: number;
+    }): Promise<INoSqlDbStorageRehearsalReceipt>;
+    [rustDbBridgeStorageRootRelocation](inputArg: ILocalNoSqlDbStoppedStorageRootRelocationInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<ILocalNoSqlDbStoppedStorageRootRelocationReceipt>;
+    inspectOfflinePhysicalNamespaces(inputArg: ILocalNoSqlDbOfflinePhysicalNamespaceInspection, optionsArg?: INoSqlDbManagementOperationOptions): Promise<ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult>;
+    inspectOfflineStringValue(inputArg: ILocalNoSqlDbOfflineStringValueInspection, optionsArg?: INoSqlDbManagementOperationOptions): Promise<TLocalNoSqlDbOfflineStringValueInspectionResult>;
+    startDb(config: INoSqlDbRustConfig, optionsArg?: INoSqlDbManagementOperationOptions): Promise<{
+        connectionUri: string;
+    }>;
+    stopDb(): Promise<void>;
+    getStatus(): Promise<{
+        running: boolean;
+    }>;
+    getMetrics(): Promise<INoSqlDbMetrics>;
+    getHealth(optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbHealth>;
+    createDatabaseTenant(params: INoSqlDbDatabaseTenantInput): Promise<INoSqlDbDatabaseTenantDescriptor>;
+    ensureDatabaseTenant(params: INoSqlDbEnsureDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbEnsureDatabaseTenantResult>;
+    attestDatabaseTenant(params: INoSqlDbAttestDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbAttestDatabaseTenantResult>;
+    allocateDatabaseTenant(params: INoSqlDbAllocateDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbAllocateDatabaseTenantResult>;
+    deleteDatabaseTenant(params: INoSqlDbDeleteDatabaseTenantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDeleteDatabaseTenantResult>;
+    issueDatabaseAllocationReadAccessGrant(params: INoSqlDbIssueDatabaseAllocationReadAccessGrantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbIssueDatabaseAllocationReadAccessGrantResult>;
+    revokeDatabaseAllocationReadAccessGrant(params: INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult>;
+    rotateDatabaseTenantPassword(params: INoSqlDbRotateDatabaseTenantPasswordInput): Promise<INoSqlDbDatabaseTenantDescriptor>;
+    listDatabaseTenants(): Promise<INoSqlDbDatabaseTenantDescriptor[]>;
+    getDatabaseTenantDescriptor(params: {
+        databaseName: string;
+        username: string;
+    }): Promise<INoSqlDbDatabaseTenantDescriptor>;
+    getDatabaseResourceFenceState(params: {
+        databaseName: string;
+    }, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDatabaseResourceFenceState | null>;
+    exportDatabase(params: INoSqlDbExportDatabaseInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDatabaseExport>;
+    getDatabaseContentDigest(params: INoSqlDbGetDatabaseContentDigestInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbDatabaseContentDigest>;
+    importDatabase(params: INoSqlDbImportDatabaseInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbImportDatabaseResult>;
+    commitDatabasePublication(params: INoSqlDbCommitDatabasePublicationInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<TNoSqlDbCommitDatabasePublicationResult>;
+    getOpLog(params?: {
+        sinceSeq?: number;
+        limit?: number;
+        db?: string;
+        collection?: string;
+    }): Promise<IOpLogResult>;
+    getOpLogStats(): Promise<IOpLogStats>;
+    revertToSeq(seq: number, dryRun?: boolean): Promise<IRevertResult>;
+    getCollections(db?: string): Promise<ICollectionInfo[]>;
+    getDocuments(db: string, collection: string, limit?: number, skip?: number): Promise<IDocumentsResult>;
+}