@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/mongodb/modules/db/MongoDbProfilingLevel.d.ts

@@ -0,0 +1,40 @@
+import type { Db as Db_v4 } from 'mongov4';
+import type { Db as Db_v5 } from 'mongov5';
+import type { Db as Db_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['profilingLevel'] | Db_v5['profilingLevel'] | Db_v6['profilingLevel']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = string;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbProfilingLevelMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export declare function patchProfilingLevel(plugin: HtMongoDbInstrumentation): (originalFn: Db["profilingLevel"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongoDbRemoveUserMock.d.ts

@@ -0,0 +1,43 @@
+import type { Db as Db_v4 } from 'mongov4';
+import type { Db as Db_v5 } from 'mongov5';
+import type { Db as Db_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['removeUser'] | Db_v5['removeUser'] | Db_v6['removeUser']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    username: string;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    username: string;
+};
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = boolean;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbRemoveUserMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export declare function patchRemoveUser(plugin: HtMongoDbInstrumentation): (originalFn: Db["removeUser"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongoDbRenameCollection.d.ts

@@ -0,0 +1,48 @@
+import type { Db as Db_v4 } from 'mongov4';
+import type { Db as Db_v5 } from 'mongov5';
+import type { Db as Db_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['renameCollection'] | Db_v5['renameCollection'] | Db_v6['renameCollection']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    fromCollection: string;
+    toCollection: string;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    fromCollection: string;
+    toCollection: string;
+};
+type ProcessedInputSchema = {
+    fromCollection: JsonSchemaWithoutValues;
+    toCollection: JsonSchemaWithoutValues;
+};
+type RealOutput = EmptyObject;
+type OutputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export declare class MongoDbRenameCollectionMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchRenameCollection(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["renameCollection"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongoDbRunCursorCommandMock.d.ts

@@ -0,0 +1,48 @@
+import type { Db as Db_v5 } from 'mongov5';
+import type { Db as Db_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { JsonableArray } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta, Sanitized } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v5['runCursorCommand'] | Db_v6['runCursorCommand']>;
+type QueryCommand = Parameters<Db_v6['runCursorCommand'] | Db_v5['runCursorCommand']>[0];
+type QueryOptions = Parameters<Db_v6['runCursorCommand'] | Db_v5['runCursorCommand']>[1];
+type Db = Db_v5 | Db_v6;
+type InputMeta = {
+    commandPathMeta: PathMeta;
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    command: Sanitized<QueryCommand>;
+    options: Sanitized<QueryOptions>;
+};
+type ProcessedInput = {
+    command: Sanitized<QueryCommand>;
+};
+type ProcessedInputSchema = {
+    command: JsonSchemaWithoutValues;
+};
+type RealOutput = JsonableArray;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbRunCursorCommandMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchRunCursorCommand(plugin: HtMongoDbInstrumentation, version: string): (originalFn: any) => (this: Db, ...args: InputArgs) => any;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongoDbSetProfilingLevelMock.d.ts

@@ -0,0 +1,46 @@
+import type { Db as Db_v4 } from 'mongov4';
+import type { Db as Db_v5 } from 'mongov5';
+import type { Db as Db_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['setProfilingLevel'] | Db_v5['setProfilingLevel'] | Db_v6['setProfilingLevel']>;
+type QueryLevel = Parameters<Db_v6['setProfilingLevel'] | Db_v5['setProfilingLevel'] | Db_v4['setProfilingLevel']>[0];
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    level: QueryLevel;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    level: QueryLevel;
+};
+type ProcessedInputSchema = {
+    level: JsonSchemaWithoutValues;
+};
+type RealOutput = string;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbSetProfilingLevelMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export declare function patchSetProfilingLevel(plugin: HtMongoDbInstrumentation): (originalFn: Db["setProfilingLevel"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongoDbUnrefMock.d.ts

@@ -0,0 +1,2 @@
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+export declare function patchDbUnref(plugin: HtMongoDbInstrumentation): (originalFn: any) => (this: any, ...args: any[]) => void;

package/instrumentation/libraries/mongodb/modules/db/MongodbStatsMock.d.ts

@@ -0,0 +1,42 @@
+import type { Db as Db_v4 } from 'mongov4';
+import type { Db as Db_v5 } from 'mongov5';
+import type { Db as Db_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import { type Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['stats'] | Db_v5['stats'] | Db_v6['stats']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = Record<string, Jsonable>;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongodbStatsMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchDbStats(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["stats"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongodbWatchMock.d.ts

@@ -0,0 +1,2 @@
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+export declare function patchDbWatch(plugin: HtMongoDbInstrumentation, version: string): (originalFn: any) => (this: unknown, ...args: unknown[]) => any;

package/instrumentation/libraries/mongodb/mongoHelpers/FakeBulkWriteResult.d.ts

@@ -0,0 +1,113 @@
+export declare class FakeBulkWriteResult {
+    [x: string]: unknown;
+    /**
+     * Create a new BulkWriteResult instance
+     *
+     * **NOTE:** Internal Type, do not instantiate directly
+     */
+    constructor(bulkResult: any);
+    /**
+     * Evaluates to true if the bulk operation correctly executes
+     * @type {boolean}
+     */
+    get ok(): any;
+    /**
+     * The number of inserted documents
+     * @type {number}
+     */
+    get nInserted(): any;
+    /**
+     * Number of upserted documents
+     * @type {number}
+     */
+    get nUpserted(): any;
+    /**
+     * Number of matched documents
+     * @type {number}
+     */
+    get nMatched(): any;
+    /**
+     * Number of documents updated physically on disk
+     * @type {number}
+     */
+    get nModified(): any;
+    /**
+     * Number of removed documents
+     * @type {number}
+     */
+    get nRemoved(): any;
+    /**
+     * Returns an array of all inserted ids
+     *
+     * @return {object[]}
+     */
+    getInsertedIds(): any;
+    /**
+     * Returns an array of all upserted ids
+     *
+     * @return {object[]}
+     */
+    getUpsertedIds(): any;
+    /**
+     * Returns the upserted id at the given index
+     *
+     * @param {number} index the number of the upserted id to return, returns undefined if no result for passed in index
+     * @return {object}
+     */
+    getUpsertedIdAt(index: any): any;
+    /**
+     * Returns raw internal result
+     *
+     * @return {object}
+     */
+    getRawResponse(): unknown;
+    /**
+     * Returns true if the bulk operation contains a write error
+     *
+     * @return {boolean}
+     */
+    hasWriteErrors(): boolean;
+    /**
+     * Returns the number of write errors off the bulk operation
+     *
+     * @return {number}
+     */
+    getWriteErrorCount(): any;
+    /**
+     * Returns a specific write error object
+     *
+     * @param {number} index of the write error to return, returns null if there is no result for passed in index
+     * @return {WriteError}
+     */
+    getWriteErrorAt(index: any): any;
+    /**
+     * Retrieve all write errors
+     *
+     * @return {WriteError[]}
+     */
+    getWriteErrors(): any;
+    /**
+     * Retrieve lastOp if available
+     *
+     * @return {object}
+     */
+    getLastOp(): any;
+    /**
+     * Retrieve the write concern error if any
+     *
+     * @return {WriteConcernError}
+     */
+    getWriteConcernError(): any;
+    /**
+     * @return {object}
+     */
+    toJSON(): unknown;
+    /**
+     * @return {string}
+     */
+    toString(): string;
+    /**
+     * @return {boolean}
+     */
+    isOk(): boolean;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/FakeTopology.d.ts

@@ -0,0 +1,7 @@
+import { EventEmitter } from 'events';
+export default class FakeTopology extends EventEmitter {
+    private s;
+    constructor();
+    lastHello(): {};
+    lastIsMaster(): {};
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v3/HtFakeAggregationCursor.d.ts

@@ -0,0 +1,28 @@
+import type { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { SetReadableInput } from '../../../modules/cursor/MongoDbCursorMock';
+import { HtFakeCursor } from './HtFakeCursor';
+export declare class HtFakeAggregationCursor extends HtFakeCursor {
+    operation: {
+        pipeline: Record<string, unknown>[];
+        options: Record<string, unknown>;
+    };
+    mock: HtInstrumentationMockAbstract;
+    setReadableInput: SetReadableInput;
+    version: string;
+    constructor(mock: HtInstrumentationMockAbstract, setReadableInput: SetReadableInput, version: string, pipeline: Record<string, unknown>[], options: Record<string, unknown>);
+    setReadableInputAndExtractDataFromMock(): void;
+    clone(): HtFakeAggregationCursor;
+    batchSize(value: number): this;
+    limit($limit: number): this;
+    lookup(document: any): this;
+    project(document: any): this;
+    group(document: any): this;
+    match(document: any): this;
+    out(destination: any): this;
+    redact(document: any): this;
+    skip(value: any): this;
+    sort(document: any): this;
+    unwind(field: any): this;
+    geoNear(document: any): this;
+    maxTimeMS(value: any): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v3/HtFakeChangeStream.d.ts

@@ -0,0 +1,4 @@
+import { HtFakeCursor } from './HtFakeCursor';
+export declare class HtFakeChangeStream extends HtFakeCursor {
+    setReadableInputAndExtractDataFromMock(): void;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v3/HtFakeCommandCursor.d.ts

@@ -0,0 +1,16 @@
+import type { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { SetReadableInput } from '../../../modules/cursor/MongoDbCursorMock';
+import { HtFakeCursor } from './HtFakeCursor';
+export declare class HtFakeCommandCursor extends HtFakeCursor {
+    options: Record<string, unknown>;
+    mock: HtInstrumentationMockAbstract;
+    setReadableInput: SetReadableInput;
+    version: string;
+    ReadPreference: new (..._args: unknown[]) => unknown;
+    constructor(mock: HtInstrumentationMockAbstract, setReadableInput: SetReadableInput, version: string, options: Record<string, unknown>);
+    setReadableInputAndExtractDataFromMock(): void;
+    clone(): HtFakeCommandCursor;
+    batchSize(value: number): this;
+    maxTimeMS(value: any): this;
+    setReadPreference(readPreference: any): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v3/HtFakeCoreCursor.d.ts

@@ -0,0 +1,26 @@
+import { Readable, Transform } from 'node:stream';
+import type { InstrumentationMockReplayValue } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+export declare abstract class HtFakeCoreCursor extends Readable {
+    mockReplayValue: InstrumentationMockReplayValue<unknown[], unknown>;
+    closed: boolean;
+    iterator: number;
+    streamOptions?: Record<string, unknown>;
+    transform: (doc: unknown) => unknown;
+    abstract setReadableInputAndExtractDataFromMock(): void;
+    constructor();
+    closeCursor(): void;
+    toArray(callback?: (...args: unknown[]) => unknown): Promise<unknown>;
+    next(callback?: (...args: unknown[]) => unknown): Promise<unknown>;
+    hasNext(callback?: (...args: unknown[]) => unknown): Promise<unknown>;
+    each(callback: (err: any, output: any) => void): void;
+    forEach(iterator: (doc: any) => void, secondCallback?: (err: Error) => void): Promise<unknown>;
+    close(callback?: (err: any, output: any) => void): Promise<unknown>;
+    [Symbol.asyncIterator](): Generator<unknown, void, unknown>;
+    _read(): boolean;
+    stream(options: any): this;
+    transformStream(options: any): Transform;
+    explain(): void;
+    isClosed(): boolean;
+    rewind(): void;
+    map(transform: typeof this.transform): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v3/HtFakeCursor.d.ts

@@ -0,0 +1,30 @@
+import { HtFakeCoreCursor } from './HtFakeCoreCursor';
+export declare abstract class HtFakeCursor extends HtFakeCoreCursor {
+    cmd: {
+        query?: unknown;
+        fields?: unknown;
+    };
+    constructor(filter?: unknown, options?: unknown);
+    filter(filter: any): this;
+    maxScan(): this;
+    hint(): this;
+    min(): this;
+    max(): this;
+    returnKey(): this;
+    showRecordId(): this;
+    snapshot(): this;
+    setCursorOption(): this;
+    addCursorFlag(): this;
+    addQueryModifier(name: any, value: any): this;
+    comment(): this;
+    maxAwaitTimeMS(): this;
+    maxTimeMS(): this;
+    project(value: any): this;
+    sort(): this;
+    batchSize(): this;
+    collation(): this;
+    limit(): this;
+    skip(): this;
+    count(): void;
+    destroy(err?: Error): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v3/HtFakeFindCursor.d.ts

@@ -0,0 +1,15 @@
+import type { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { SetReadableInput } from '../../../modules/cursor/MongoDbCursorMock';
+import { HtFakeCursor } from './HtFakeCursor';
+export declare class HtFakeFindCursor extends HtFakeCursor {
+    mock: HtInstrumentationMockAbstract;
+    setReadableInput: SetReadableInput;
+    version: string;
+    argsFilter: Record<string, unknown>;
+    options: Record<string, unknown>;
+    constructor(mock: HtInstrumentationMockAbstract, setReadableInput: SetReadableInput, version: string, filter: Record<string, unknown>, options: Record<string, unknown>);
+    setReadableInputAndExtractDataFromMock(): void;
+    clone(): HtFakeFindCursor;
+    batchSize(): this;
+    setReadPreference(): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v4AndAbove/HtFakeAggregationCursor.d.ts

@@ -0,0 +1,27 @@
+import type { Document } from 'mongoose';
+import type { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { SetReadableInput } from '../../../modules/cursor/MongoDbCursorMock';
+import { HtFakeCoreCursor } from './HtFakeCoreCursor';
+export declare class HtFakeAggregationCursor extends HtFakeCoreCursor {
+    pipeline: Record<string, unknown>[];
+    mock: HtInstrumentationMockAbstract;
+    setReadableInput: SetReadableInput;
+    version: string;
+    constructor(mock: HtInstrumentationMockAbstract, setReadableInput: SetReadableInput, version: string, pipeline: Record<string, unknown>[], options: Record<string, unknown>);
+    setReadableInputAndExtractDataFromMock(): void;
+    clone(): HtFakeAggregationCursor;
+    limit($limit: number): this;
+    lookup($lookup: Document): this;
+    project($project: Document): this;
+    group($group: Document): this;
+    match($match: Document): this;
+    out($out: {
+        db: string;
+        coll: string;
+    } | string): this;
+    redact($redact: Document): this;
+    skip($skip: number): this;
+    sort($sort: any): this;
+    unwind($unwind: Document | string): this;
+    geoNear($geoNear: Document): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v4AndAbove/HtFakeChangeStream.d.ts

@@ -0,0 +1,4 @@
+import { HtFakeCoreCursor } from './HtFakeCoreCursor';
+export declare class HtFakeChangeStream extends HtFakeCoreCursor {
+    setReadableInputAndExtractDataFromMock(): void;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v4AndAbove/HtFakeCoreCursor.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'events';
+import { Readable } from 'node:stream';
+import type { CursorFlag, CursorStreamOptions, ReadConcern, ReadConcernLike, ReadPreference, ReadPreferenceLike } from 'mongov4';
+import type { InstrumentationMockReplayValue } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+export declare const CURSOR_FLAGS: readonly ["tailable", "oplogReplay", "noCursorTimeout", "awaitData", "exhaust", "partial"];
+export declare abstract class HtFakeCoreCursor extends EventEmitter {
+    mockReplayValue: InstrumentationMockReplayValue<unknown[], unknown>;
+    closed: boolean;
+    iterator: number;
+    version: string;
+    options: Record<string, unknown>;
+    transform?: (doc: unknown) => unknown;
+    ReadPreference: typeof ReadPreference;
+    ReadConcern: typeof ReadConcern;
+    abstract setReadableInputAndExtractDataFromMock(): void;
+    constructor(version: string);
+    closeCursor(err?: Error): void;
+    toArray(callback?: (...args: unknown[]) => unknown): Promise<unknown>;
+    next(callback?: (...args: unknown[]) => unknown): Promise<unknown>;
+    hasNext(callback?: (...args: unknown[]) => unknown): Promise<unknown>;
+    forEach(iterator: (doc: any) => void, secondCallback?: (err: Error) => void): Promise<unknown>;
+    close(callback?: (err: any, output: any) => void): Promise<unknown>;
+    [Symbol.asyncIterator](): Generator<unknown, void, unknown>;
+    tryNext: (callback?: (...args: unknown[]) => unknown) => Promise<unknown>;
+    stream(options?: CursorStreamOptions): Readable & AsyncIterable<unknown>;
+    explain(): void;
+    batchSize(value: number): this;
+    maxTimeMS(value: number): this;
+    rewind(): void;
+    addCursorFlag(flag: CursorFlag, value: boolean): this;
+    currentBufferBoundary(): number;
+    bufferedCount(): number;
+    readBufferedDocuments(number: number): unknown[];
+    map(transform: typeof this.transform): this;
+    withReadPreference(readPreference: ReadPreferenceLike): this;
+    withReadConcern(readConcern: ReadConcernLike): this;
+}

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v4AndAbove/HtFakeFindCursor.d.ts

@@ -0,0 +1,33 @@
+import type { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { SetReadableInput } from '../../../modules/cursor/MongoDbCursorMock';
+import { HtFakeCoreCursor } from './HtFakeCoreCursor';
+declare const kFilter: unique symbol;
+declare const kBuiltOptions: unique symbol;
+export declare class HtFakeFindCursor extends HtFakeCoreCursor {
+    mock: HtInstrumentationMockAbstract;
+    setReadableInput: SetReadableInput;
+    version: string;
+    [kFilter]: Record<string, unknown>;
+    [kBuiltOptions]: Record<string, unknown>;
+    constructor(mock: HtInstrumentationMockAbstract, setReadableInput: SetReadableInput, version: string, filter: Record<string, unknown>, options: Record<string, unknown>);
+    setReadableInputAndExtractDataFromMock(): void;
+    clone(): HtFakeFindCursor;
+    count(): void;
+    filter(filter: any): this;
+    hint(): this;
+    min(): this;
+    max(): this;
+    returnKey(): this;
+    showRecordId(): this;
+    addQueryModifier(name: string, value: unknown): this;
+    comment(): this;
+    maxAwaitTimeMS(): this;
+    maxTimeMS(): this;
+    project(value: any): this;
+    sort(): this;
+    allowDiskUse(): this;
+    collation(): this;
+    limit(): this;
+    skip(): this;
+}
+export {};

package/instrumentation/libraries/mongodb/mongoHelpers/fakeCursors/v4AndAbove/HtFakeListCollectionsCursor.d.ts

@@ -0,0 +1,12 @@
+import type { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { SetReadableInput } from '../../../modules/cursor/MongoDbCursorMock';
+import { HtFakeCoreCursor } from './HtFakeCoreCursor';
+export declare class HtFakeListCollectionsCursor extends HtFakeCoreCursor {
+    pipeline: Record<string, unknown>[];
+    mock: HtInstrumentationMockAbstract;
+    setReadableInput: SetReadableInput;
+    version: string;
+    constructor(mock: HtInstrumentationMockAbstract, setReadableInput: SetReadableInput, version: string, options: Record<string, unknown>);
+    setReadableInputAndExtractDataFromMock(): void;
+    clone(): HtFakeListCollectionsCursor;
+}