@qp-mongosh/shell-api 0.0.0-dev.0 → 0.0.0-dev.3

package/lib/shell-bson.d.ts

@@ -1,40 +1,40 @@
-/// <reference types="node" />
-import Help from './help';
-import { BinaryType, Document, bson as BSON } from '@qp-mongosh/service-provider-core';
-interface ShellBsonBase {
-    DBRef: (namespace: string, oid: any, db?: string, fields?: Document) => typeof BSON.DBRef.prototype;
-    Map: typeof BSON.Map;
-    bsonsize: (object: any) => number;
-    MaxKey: () => typeof BSON.MaxKey.prototype;
-    MinKey: () => typeof BSON.MinKey.prototype;
-    ObjectId: (id?: string | number | typeof BSON.ObjectId.prototype | Buffer) => typeof BSON.ObjectId.prototype;
-    Timestamp: (t?: number | typeof BSON.Long.prototype | {
-        t: number;
-        i: number;
-    }, i?: number) => typeof BSON.Timestamp.prototype;
-    Code: (c?: string | Function, s?: any) => typeof BSON.Code.prototype;
-    NumberDecimal: (s?: string) => typeof BSON.Decimal128.prototype;
-    NumberInt: (v?: string) => typeof BSON.Int32.prototype;
-    NumberLong: (s?: string | number) => typeof BSON.Long.prototype;
-    ISODate: (input?: string) => Date;
-    BinData: (subtype: number, b64string: string) => BinaryType;
-    HexData: (subtype: number, hexstr: string) => BinaryType;
-    UUID: (hexstr?: string) => BinaryType;
-    MD5: (hexstr: string) => BinaryType;
-    Decimal128: typeof BSON.Decimal128;
-    BSONSymbol: typeof BSON.BSONSymbol;
-    Int32: typeof BSON.Int32;
-    Long: typeof BSON.Long;
-    Binary: typeof BSON.Binary;
-    Double: typeof BSON.Double;
-    EJSON: typeof BSON.EJSON;
-    BSONRegExp: typeof BSON.BSONRegExp;
-}
-declare type WithHelp<T> = {
-    [prop in keyof T]: T[prop] & {
-        help?: () => Help;
-    };
-};
-export declare type ShellBson = WithHelp<ShellBsonBase>;
-export default function constructShellBson(bson: typeof BSON, printWarning: (msg: string) => void): ShellBson;
-export {};
+/// <reference types="node" />
+import Help from './help';
+import { BinaryType, Document, bson as BSON } from '@qp-mongosh/service-provider-core';
+interface ShellBsonBase {
+    DBRef: (namespace: string, oid: any, db?: string, fields?: Document) => typeof BSON.DBRef.prototype;
+    Map: typeof BSON.Map;
+    bsonsize: (object: any) => number;
+    MaxKey: () => typeof BSON.MaxKey.prototype;
+    MinKey: () => typeof BSON.MinKey.prototype;
+    ObjectId: (id?: string | number | typeof BSON.ObjectId.prototype | Buffer) => typeof BSON.ObjectId.prototype;
+    Timestamp: (t?: number | typeof BSON.Long.prototype | {
+        t: number;
+        i: number;
+    }, i?: number) => typeof BSON.Timestamp.prototype;
+    Code: (c?: string | Function, s?: any) => typeof BSON.Code.prototype;
+    NumberDecimal: (s?: string) => typeof BSON.Decimal128.prototype;
+    NumberInt: (v?: string) => typeof BSON.Int32.prototype;
+    NumberLong: (s?: string | number) => typeof BSON.Long.prototype;
+    ISODate: (input?: string) => Date;
+    BinData: (subtype: number, b64string: string) => BinaryType;
+    HexData: (subtype: number, hexstr: string) => BinaryType;
+    UUID: (hexstr?: string) => BinaryType;
+    MD5: (hexstr: string) => BinaryType;
+    Decimal128: typeof BSON.Decimal128;
+    BSONSymbol: typeof BSON.BSONSymbol;
+    Int32: typeof BSON.Int32;
+    Long: typeof BSON.Long;
+    Binary: typeof BSON.Binary;
+    Double: typeof BSON.Double;
+    EJSON: typeof BSON.EJSON;
+    BSONRegExp: typeof BSON.BSONRegExp;
+}
+declare type WithHelp<T> = {
+    [prop in keyof T]: T[prop] & {
+        help?: () => Help;
+    };
+};
+export declare type ShellBson = WithHelp<ShellBsonBase>;
+export default function constructShellBson(bson: typeof BSON, printWarning: (msg: string) => void): ShellBson;
+export {};

package/lib/shell-bson.js

@@ -1,160 +1,160 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const enums_1 = require("./enums");
-const help_1 = __importDefault(require("./help"));
-const service_provider_core_1 = require("@qp-mongosh/service-provider-core");
-const errors_1 = require("@qp-mongosh/errors");
-const helpers_1 = require("./helpers");
-const crypto_1 = require("crypto");
-function constructHelp(className) {
-    const classHelpKeyPrefix = `shell-api.classes.${className}.help`;
-    const classHelp = {
-        help: `${classHelpKeyPrefix}.description`,
-        example: `${classHelpKeyPrefix}.example`,
-        docs: `${classHelpKeyPrefix}.link`,
-        attr: []
-    };
-    return new help_1.default(classHelp);
-}
-function constructShellBson(bson, printWarning) {
-    const bsonNames = [
-        'Binary', 'Code', 'DBRef', 'Decimal128', 'Double', 'Int32', 'Long',
-        'MaxKey', 'MinKey', 'ObjectId', 'Timestamp', 'Map', 'BSONSymbol',
-        'BSONRegExp'
-    ];
-    if (bson === undefined) {
-        bson = service_provider_core_1.bson;
-    }
-    const helps = {};
-    bsonNames.forEach((className) => {
-        if (!(className in bson)) {
-            throw new errors_1.MongoshInternalError(`${className} does not exist in provided BSON package.`);
-        }
-        const proto = bson[className].prototype;
-        proto.serverVersions = enums_1.ALL_SERVER_VERSIONS;
-        proto.platforms = enums_1.ALL_PLATFORMS;
-        proto.topologies = enums_1.ALL_TOPOLOGIES;
-        const help = constructHelp(className);
-        helps[className] = help;
-        proto.help = () => (help);
-        Object.setPrototypeOf(proto.help, help);
-    });
-    bson.BSONSymbol.prototype.serverVersions = [enums_1.ServerVersions.earliest, '1.6.0'];
-    bson.BSONSymbol.prototype.deprecated = true;
-    const bsonPkg = {
-        DBRef: Object.assign(function DBRef(namespace, oid, db, fields) {
-            (0, helpers_1.assertArgsDefinedType)([namespace, oid, db], ['string', true, [undefined, 'string'], [undefined, 'object']], 'DBRef');
-            return new bson.DBRef(namespace, oid, db, fields);
-        }, { ...bson.DBRef, prototype: bson.DBRef.prototype }),
-        Map: bson.Map,
-        bsonsize: function bsonsize(object) {
-            (0, helpers_1.assertArgsDefinedType)([object], ['object'], 'bsonsize');
-            return bson.calculateObjectSize(object);
-        },
-        MaxKey: Object.assign(function MaxKey() {
-            return new bson.MaxKey();
-        }, { ...bson.MaxKey, toBSON: () => new bson.MaxKey(), prototype: bson.MaxKey.prototype }),
-        MinKey: Object.assign(function MinKey() {
-            return new bson.MinKey();
-        }, { ...bson.MinKey, toBSON: () => new bson.MinKey(), prototype: bson.MinKey.prototype }),
-        ObjectId: Object.assign(function ObjectId(id) {
-            (0, helpers_1.assertArgsDefinedType)([id], [[undefined, 'string', 'number', 'object']], 'ObjectId');
-            return new bson.ObjectId(id);
-        }, { ...bson.ObjectId, prototype: bson.ObjectId.prototype }),
-        Timestamp: Object.assign(function Timestamp(t, i) {
-            (0, helpers_1.assertArgsDefinedType)([t, i], [['number', 'object', undefined], [undefined, 'number']], 'Timestamp');
-            if (typeof t === 'object' && t !== null && 't' in t && 'i' in t) {
-                return new bson.Timestamp(new bson.Long(t.i, t.t));
-            }
-            else if (i !== undefined || typeof t === 'number') {
-                return new bson.Timestamp(new bson.Long((i !== null && i !== void 0 ? i : 0), t));
-            }
-            return new bson.Timestamp(t);
-        }, { ...bson.Timestamp, prototype: bson.Timestamp.prototype }),
-        Code: Object.assign(function Code(c = '', s) {
-            (0, helpers_1.assertArgsDefinedType)([c, s], [[undefined, 'string', 'function'], [undefined, 'object']], 'Code');
-            return new bson.Code(c, s);
-        }, { ...bson.Code, prototype: bson.Code.prototype }),
-        NumberDecimal: Object.assign(function NumberDecimal(s = '0') {
-            (0, helpers_1.assertArgsDefinedType)([s], [['string', 'number', 'bson:Long', 'bson:Int32', 'bson:Decimal128']], 'NumberDecimal');
-            if (typeof s === 'number') {
-                printWarning('NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead');
-            }
-            return bson.Decimal128.fromString(`${s}`);
-        }, { prototype: bson.Decimal128.prototype }),
-        NumberInt: Object.assign(function NumberInt(v = '0') {
-            v !== null && v !== void 0 ? v : (v = '0');
-            (0, helpers_1.assertArgsDefinedType)([v], [['string', 'number', 'bson:Long', 'bson:Int32']], 'NumberInt');
-            return new bson.Int32(parseInt(`${v}`, 10));
-        }, { prototype: bson.Int32.prototype }),
-        NumberLong: Object.assign(function NumberLong(s = '0') {
-            s !== null && s !== void 0 ? s : (s = '0');
-            (0, helpers_1.assertArgsDefinedType)([s], [['string', 'number', 'bson:Long', 'bson:Int32']], 'NumberLong');
-            if (typeof s === 'number') {
-                printWarning('NumberLong: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead');
-                return bson.Long.fromNumber(s);
-            }
-            return bson.Long.fromString(`${s}`);
-        }, { prototype: bson.Long.prototype }),
-        ISODate: function ISODate(input) {
-            if (!input)
-                input = new Date().toISOString();
-            const isoDateRegex = /^(?<Y>\d{4})-?(?<M>\d{2})-?(?<D>\d{2})([T ](?<h>\d{2})(:?(?<m>\d{2})(:?((?<s>\d{2})(\.(?<ms>\d+))?))?)?(?<tz>Z|([+-])(\d{2}):?(\d{2})?)?)?$/;
-            const match = input.match(isoDateRegex);
-            if (match !== null && match.groups !== undefined) {
-                const { Y, M, D, h, m, s, ms, tz } = match.groups;
-                const normalized = `${Y}-${M}-${D}T${h || '00'}:${m || '00'}:${s || '00'}.${ms || '000'}${tz || 'Z'}`;
-                const date = new Date(normalized);
-                if (date.getTime() >= -62167219200000 && date.getTime() <= 253402300799999) {
-                    return date;
-                }
-            }
-            throw new errors_1.MongoshInvalidInputError(`${JSON.stringify(input)} is not a valid ISODate`, errors_1.CommonErrors.InvalidArgument);
-        },
-        BinData: Object.assign(function BinData(subtype, b64string) {
-            (0, helpers_1.assertArgsDefinedType)([subtype, b64string], ['number', 'string'], 'BinData');
-            const buffer = Buffer.from(b64string, 'base64');
-            return new bson.Binary(buffer, subtype);
-        }, { prototype: bson.Binary.prototype }),
-        HexData: Object.assign(function HexData(subtype, hexstr) {
-            (0, helpers_1.assertArgsDefinedType)([subtype, hexstr], ['number', 'string'], 'HexData');
-            const buffer = Buffer.from(hexstr, 'hex');
-            return new bson.Binary(buffer, subtype);
-        }, { prototype: bson.Binary.prototype }),
-        UUID: Object.assign(function UUID(hexstr) {
-            if (hexstr === undefined) {
-                const uuid = (0, crypto_1.randomBytes)(16);
-                uuid[6] = (uuid[6] & 0x0f) | 0x40;
-                uuid[8] = (uuid[8] & 0x3f) | 0x80;
-                hexstr = uuid.toString('hex');
-            }
-            (0, helpers_1.assertArgsDefinedType)([hexstr], ['string'], 'UUID');
-            const buffer = Buffer.from(hexstr.replace(/-/g, ''), 'hex');
-            return new bson.Binary(buffer, bson.Binary.SUBTYPE_UUID);
-        }, { prototype: bson.Binary.prototype }),
-        MD5: Object.assign(function MD5(hexstr) {
-            (0, helpers_1.assertArgsDefinedType)([hexstr], ['string'], 'MD5');
-            const buffer = Buffer.from(hexstr, 'hex');
-            return new bson.Binary(buffer, bson.Binary.SUBTYPE_MD5);
-        }, { prototype: bson.Binary.prototype }),
-        Decimal128: bson.Decimal128,
-        BSONSymbol: bson.BSONSymbol,
-        Int32: bson.Int32,
-        Long: bson.Long,
-        Binary: bson.Binary,
-        Double: bson.Double,
-        EJSON: bson.EJSON,
-        BSONRegExp: bson.BSONRegExp
-    };
-    for (const className of Object.keys(bsonPkg)) {
-        const help = helps[className] || constructHelp(className);
-        bsonPkg[className].help = () => (help);
-        Object.setPrototypeOf(bsonPkg[className].help, help);
-    }
-    return bsonPkg;
-}
-exports.default = constructShellBson;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("./enums");
+const help_1 = __importDefault(require("./help"));
+const service_provider_core_1 = require("@qp-mongosh/service-provider-core");
+const errors_1 = require("@qp-mongosh/errors");
+const helpers_1 = require("./helpers");
+const crypto_1 = require("crypto");
+function constructHelp(className) {
+    const classHelpKeyPrefix = `shell-api.classes.${className}.help`;
+    const classHelp = {
+        help: `${classHelpKeyPrefix}.description`,
+        example: `${classHelpKeyPrefix}.example`,
+        docs: `${classHelpKeyPrefix}.link`,
+        attr: []
+    };
+    return new help_1.default(classHelp);
+}
+function constructShellBson(bson, printWarning) {
+    const bsonNames = [
+        'Binary', 'Code', 'DBRef', 'Decimal128', 'Double', 'Int32', 'Long',
+        'MaxKey', 'MinKey', 'ObjectId', 'Timestamp', 'Map', 'BSONSymbol',
+        'BSONRegExp'
+    ];
+    if (bson === undefined) {
+        bson = service_provider_core_1.bson;
+    }
+    const helps = {};
+    bsonNames.forEach((className) => {
+        if (!(className in bson)) {
+            throw new errors_1.MongoshInternalError(`${className} does not exist in provided BSON package.`);
+        }
+        const proto = bson[className].prototype;
+        proto.serverVersions = enums_1.ALL_SERVER_VERSIONS;
+        proto.platforms = enums_1.ALL_PLATFORMS;
+        proto.topologies = enums_1.ALL_TOPOLOGIES;
+        const help = constructHelp(className);
+        helps[className] = help;
+        proto.help = () => (help);
+        Object.setPrototypeOf(proto.help, help);
+    });
+    bson.BSONSymbol.prototype.serverVersions = [enums_1.ServerVersions.earliest, '1.6.0'];
+    bson.BSONSymbol.prototype.deprecated = true;
+    const bsonPkg = {
+        DBRef: Object.assign(function DBRef(namespace, oid, db, fields) {
+            (0, helpers_1.assertArgsDefinedType)([namespace, oid, db], ['string', true, [undefined, 'string'], [undefined, 'object']], 'DBRef');
+            return new bson.DBRef(namespace, oid, db, fields);
+        }, { ...bson.DBRef, prototype: bson.DBRef.prototype }),
+        Map: bson.Map,
+        bsonsize: function bsonsize(object) {
+            (0, helpers_1.assertArgsDefinedType)([object], ['object'], 'bsonsize');
+            return bson.calculateObjectSize(object);
+        },
+        MaxKey: Object.assign(function MaxKey() {
+            return new bson.MaxKey();
+        }, { ...bson.MaxKey, toBSON: () => new bson.MaxKey(), prototype: bson.MaxKey.prototype }),
+        MinKey: Object.assign(function MinKey() {
+            return new bson.MinKey();
+        }, { ...bson.MinKey, toBSON: () => new bson.MinKey(), prototype: bson.MinKey.prototype }),
+        ObjectId: Object.assign(function ObjectId(id) {
+            (0, helpers_1.assertArgsDefinedType)([id], [[undefined, 'string', 'number', 'object']], 'ObjectId');
+            return new bson.ObjectId(id);
+        }, { ...bson.ObjectId, prototype: bson.ObjectId.prototype }),
+        Timestamp: Object.assign(function Timestamp(t, i) {
+            (0, helpers_1.assertArgsDefinedType)([t, i], [['number', 'object', undefined], [undefined, 'number']], 'Timestamp');
+            if (typeof t === 'object' && t !== null && 't' in t && 'i' in t) {
+                return new bson.Timestamp(new bson.Long(t.i, t.t));
+            }
+            else if (i !== undefined || typeof t === 'number') {
+                return new bson.Timestamp(new bson.Long((i !== null && i !== void 0 ? i : 0), t));
+            }
+            return new bson.Timestamp(t);
+        }, { ...bson.Timestamp, prototype: bson.Timestamp.prototype }),
+        Code: Object.assign(function Code(c = '', s) {
+            (0, helpers_1.assertArgsDefinedType)([c, s], [[undefined, 'string', 'function'], [undefined, 'object']], 'Code');
+            return new bson.Code(c, s);
+        }, { ...bson.Code, prototype: bson.Code.prototype }),
+        NumberDecimal: Object.assign(function NumberDecimal(s = '0') {
+            (0, helpers_1.assertArgsDefinedType)([s], [['string', 'number', 'bson:Long', 'bson:Int32', 'bson:Decimal128']], 'NumberDecimal');
+            if (typeof s === 'number') {
+                printWarning('NumberDecimal: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead');
+            }
+            return bson.Decimal128.fromString(`${s}`);
+        }, { prototype: bson.Decimal128.prototype }),
+        NumberInt: Object.assign(function NumberInt(v = '0') {
+            v !== null && v !== void 0 ? v : (v = '0');
+            (0, helpers_1.assertArgsDefinedType)([v], [['string', 'number', 'bson:Long', 'bson:Int32']], 'NumberInt');
+            return new bson.Int32(parseInt(`${v}`, 10));
+        }, { prototype: bson.Int32.prototype }),
+        NumberLong: Object.assign(function NumberLong(s = '0') {
+            s !== null && s !== void 0 ? s : (s = '0');
+            (0, helpers_1.assertArgsDefinedType)([s], [['string', 'number', 'bson:Long', 'bson:Int32']], 'NumberLong');
+            if (typeof s === 'number') {
+                printWarning('NumberLong: specifying a number as argument is deprecated and may lead to loss of precision, pass a string instead');
+                return bson.Long.fromNumber(s);
+            }
+            return bson.Long.fromString(`${s}`);
+        }, { prototype: bson.Long.prototype }),
+        ISODate: function ISODate(input) {
+            if (!input)
+                input = new Date().toISOString();
+            const isoDateRegex = /^(?<Y>\d{4})-?(?<M>\d{2})-?(?<D>\d{2})([T ](?<h>\d{2})(:?(?<m>\d{2})(:?((?<s>\d{2})(\.(?<ms>\d+))?))?)?(?<tz>Z|([+-])(\d{2}):?(\d{2})?)?)?$/;
+            const match = input.match(isoDateRegex);
+            if (match !== null && match.groups !== undefined) {
+                const { Y, M, D, h, m, s, ms, tz } = match.groups;
+                const normalized = `${Y}-${M}-${D}T${h || '00'}:${m || '00'}:${s || '00'}.${ms || '000'}${tz || 'Z'}`;
+                const date = new Date(normalized);
+                if (date.getTime() >= -62167219200000 && date.getTime() <= 253402300799999) {
+                    return date;
+                }
+            }
+            throw new errors_1.MongoshInvalidInputError(`${JSON.stringify(input)} is not a valid ISODate`, errors_1.CommonErrors.InvalidArgument);
+        },
+        BinData: Object.assign(function BinData(subtype, b64string) {
+            (0, helpers_1.assertArgsDefinedType)([subtype, b64string], ['number', 'string'], 'BinData');
+            const buffer = Buffer.from(b64string, 'base64');
+            return new bson.Binary(buffer, subtype);
+        }, { prototype: bson.Binary.prototype }),
+        HexData: Object.assign(function HexData(subtype, hexstr) {
+            (0, helpers_1.assertArgsDefinedType)([subtype, hexstr], ['number', 'string'], 'HexData');
+            const buffer = Buffer.from(hexstr, 'hex');
+            return new bson.Binary(buffer, subtype);
+        }, { prototype: bson.Binary.prototype }),
+        UUID: Object.assign(function UUID(hexstr) {
+            if (hexstr === undefined) {
+                const uuid = (0, crypto_1.randomBytes)(16);
+                uuid[6] = (uuid[6] & 0x0f) | 0x40;
+                uuid[8] = (uuid[8] & 0x3f) | 0x80;
+                hexstr = uuid.toString('hex');
+            }
+            (0, helpers_1.assertArgsDefinedType)([hexstr], ['string'], 'UUID');
+            const buffer = Buffer.from(hexstr.replace(/-/g, ''), 'hex');
+            return new bson.Binary(buffer, bson.Binary.SUBTYPE_UUID);
+        }, { prototype: bson.Binary.prototype }),
+        MD5: Object.assign(function MD5(hexstr) {
+            (0, helpers_1.assertArgsDefinedType)([hexstr], ['string'], 'MD5');
+            const buffer = Buffer.from(hexstr, 'hex');
+            return new bson.Binary(buffer, bson.Binary.SUBTYPE_MD5);
+        }, { prototype: bson.Binary.prototype }),
+        Decimal128: bson.Decimal128,
+        BSONSymbol: bson.BSONSymbol,
+        Int32: bson.Int32,
+        Long: bson.Long,
+        Binary: bson.Binary,
+        Double: bson.Double,
+        EJSON: bson.EJSON,
+        BSONRegExp: bson.BSONRegExp
+    };
+    for (const className of Object.keys(bsonPkg)) {
+        const help = helps[className] || constructHelp(className);
+        bsonPkg[className].help = () => (help);
+        Object.setPrototypeOf(bsonPkg[className].help, help);
+    }
+    return bsonPkg;
+}
+exports.default = constructShellBson;
 //# sourceMappingURL=shell-bson.js.map

package/lib/shell-instance-state.d.ts

@@ -1,77 +1,77 @@
-import { AutoEncryptionOptions, ConnectInfo, ServerApi, ServiceProvider } from '@qp-mongosh/service-provider-core';
-import type { ApiEvent, ApiEventWithArguments, ConfigProvider, MongoshBus, ShellUserConfig } from '@qp-mongosh/types';
-import ChangeStreamCursor from './change-stream-cursor';
-import { Topologies } from './enums';
-import { AggregationCursor, Cursor, Database, Mongo, ShellApi, ShellResult } from './index';
-import { InterruptFlag } from './interruptor';
-import { ShellBson } from './shell-bson';
-export interface ShellCliOptions {
-    nodb?: boolean;
-}
-export interface AutocompleteParameters {
-    topology: () => Topologies;
-    apiVersionInfo: () => Required<ServerApi> | undefined;
-    connectionInfo: () => ConnectInfo | undefined;
-    getCollectionCompletionsForCurrentDb: (collName: string) => Promise<string[]>;
-    getDatabaseCompletions: (dbName: string) => Promise<string[]>;
-}
-export interface OnLoadResult {
-    resolvedFilename: string;
-    evaluate(): Promise<void>;
-}
-export interface EvaluationListener extends Partial<ConfigProvider<ShellUserConfig>> {
-    onPrint?: (value: ShellResult[]) => Promise<void> | void;
-    onPrompt?: (question: string, type: 'password' | 'yesno') => Promise<string> | string;
-    onClearCommand?: () => Promise<void> | void;
-    onExit?: (exitCode?: number) => Promise<never>;
-    onLoad?: (filename: string) => Promise<OnLoadResult> | OnLoadResult;
-    startMongocryptd?: () => Promise<AutoEncryptionOptions['extraOptions']>;
-}
-export interface ShellPlugin {
-    transformError?: (err: Error) => Error;
-}
-export default class ShellInstanceState {
-    currentCursor: Cursor | AggregationCursor | ChangeStreamCursor | null;
-    currentDb: Database;
-    messageBus: MongoshBus;
-    initialServiceProvider: ServiceProvider;
-    connectionInfo: any;
-    context: any;
-    mongos: Mongo[];
-    shellApi: ShellApi;
-    shellBson: ShellBson;
-    cliOptions: ShellCliOptions;
-    evaluationListener: EvaluationListener;
-    displayBatchSizeFromDBQuery: number | undefined;
-    isInteractive: boolean;
-    apiCallDepth: number;
-    private warningsShown;
-    readonly interrupted: InterruptFlag;
-    resumeMongosAfterInterrupt: Array<{
-        mongo: Mongo;
-        resume: (() => Promise<void>) | null;
-    }> | undefined;
-    private plugins;
-    private alreadyTransformedErrors;
-    constructor(initialServiceProvider: ServiceProvider, messageBus?: any, cliOptions?: ShellCliOptions);
-    fetchConnectionInfo(): Promise<void>;
-    close(force: boolean): Promise<void>;
-    setDbFunc(newDb: any): Database;
-    setCtx(contextObject: any): void;
-    get currentServiceProvider(): ServiceProvider;
-    emitApiCallWithArgs(event: ApiEventWithArguments): void;
-    emitApiCall(event: Omit<ApiEvent, 'callDepth'>): void;
-    setEvaluationListener(listener: EvaluationListener): void;
-    getAutocompleteParameters(): AutocompleteParameters;
-    apiVersionInfo(): Required<ServerApi> | undefined;
-    onInterruptExecution(): Promise<boolean>;
-    onResumeExecution(): Promise<boolean>;
-    getDefaultPrompt(): Promise<string>;
-    private getDefaultPromptPrefix;
-    private getTopologySpecificPrompt;
-    private getTopologySinglePrompt;
-    registerPlugin(plugin: ShellPlugin): void;
-    transformError(err: any): any;
-    printDeprecationWarning(message: string): Promise<void>;
-    printWarning(message: string): Promise<void>;
-}
+import { AutoEncryptionOptions, ConnectInfo, ServerApi, ServiceProvider } from '@qp-mongosh/service-provider-core';
+import type { ApiEvent, ApiEventWithArguments, ConfigProvider, MongoshBus, ShellUserConfig } from '@qp-mongosh/types';
+import ChangeStreamCursor from './change-stream-cursor';
+import { Topologies } from './enums';
+import { AggregationCursor, Cursor, Database, Mongo, ShellApi, ShellResult } from './index';
+import { InterruptFlag } from './interruptor';
+import { ShellBson } from './shell-bson';
+export interface ShellCliOptions {
+    nodb?: boolean;
+}
+export interface AutocompleteParameters {
+    topology: () => Topologies;
+    apiVersionInfo: () => Required<ServerApi> | undefined;
+    connectionInfo: () => ConnectInfo | undefined;
+    getCollectionCompletionsForCurrentDb: (collName: string) => Promise<string[]>;
+    getDatabaseCompletions: (dbName: string) => Promise<string[]>;
+}
+export interface OnLoadResult {
+    resolvedFilename: string;
+    evaluate(): Promise<void>;
+}
+export interface EvaluationListener extends Partial<ConfigProvider<ShellUserConfig>> {
+    onPrint?: (value: ShellResult[]) => Promise<void> | void;
+    onPrompt?: (question: string, type: 'password' | 'yesno') => Promise<string> | string;
+    onClearCommand?: () => Promise<void> | void;
+    onExit?: (exitCode?: number) => Promise<never>;
+    onLoad?: (filename: string) => Promise<OnLoadResult> | OnLoadResult;
+    startMongocryptd?: () => Promise<AutoEncryptionOptions['extraOptions']>;
+}
+export interface ShellPlugin {
+    transformError?: (err: Error) => Error;
+}
+export default class ShellInstanceState {
+    currentCursor: Cursor | AggregationCursor | ChangeStreamCursor | null;
+    currentDb: Database;
+    messageBus: MongoshBus;
+    initialServiceProvider: ServiceProvider;
+    connectionInfo: any;
+    context: any;
+    mongos: Mongo[];
+    shellApi: ShellApi;
+    shellBson: ShellBson;
+    cliOptions: ShellCliOptions;
+    evaluationListener: EvaluationListener;
+    displayBatchSizeFromDBQuery: number | undefined;
+    isInteractive: boolean;
+    apiCallDepth: number;
+    private warningsShown;
+    readonly interrupted: InterruptFlag;
+    resumeMongosAfterInterrupt: Array<{
+        mongo: Mongo;
+        resume: (() => Promise<void>) | null;
+    }> | undefined;
+    private plugins;
+    private alreadyTransformedErrors;
+    constructor(initialServiceProvider: ServiceProvider, messageBus?: any, cliOptions?: ShellCliOptions);
+    fetchConnectionInfo(): Promise<void>;
+    close(force: boolean): Promise<void>;
+    setDbFunc(newDb: any): Database;
+    setCtx(contextObject: any): void;
+    get currentServiceProvider(): ServiceProvider;
+    emitApiCallWithArgs(event: ApiEventWithArguments): void;
+    emitApiCall(event: Omit<ApiEvent, 'callDepth'>): void;
+    setEvaluationListener(listener: EvaluationListener): void;
+    getAutocompleteParameters(): AutocompleteParameters;
+    apiVersionInfo(): Required<ServerApi> | undefined;
+    onInterruptExecution(): Promise<boolean>;
+    onResumeExecution(): Promise<boolean>;
+    getDefaultPrompt(): Promise<string>;
+    private getDefaultPromptPrefix;
+    private getTopologySpecificPrompt;
+    private getTopologySinglePrompt;
+    registerPlugin(plugin: ShellPlugin): void;
+    transformError(err: any): any;
+    printDeprecationWarning(message: string): Promise<void>;
+    printWarning(message: string): Promise<void>;
+}