@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/mongodb/modules/cursor/MongoDbCursorMock.d.ts

@@ -0,0 +1,25 @@
+import type { Readable } from 'node:stream';
+import type { AbstractCursor as AbstractCursor_v4 } from 'mongov4';
+import type { AbstractCursor as AbstractCursor_v5 } from 'mongov5';
+import type { AbstractCursor as AbstractCursor_v6 } from 'mongov6';
+import type { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+export type SetReadableInput = (cursor: Cursor) => void;
+export type Cursor = AbstractCursor_v4 | AbstractCursor_v5 | AbstractCursor_v6;
+export type OutputMeta = {
+    pathMeta: PathMeta;
+};
+export declare function patchToArray(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, submoduleName: string, setReadableInput: SetReadableInput): (originalFn: Cursor["toArray"]) => (this: Cursor, ...args: any[]) => void | Promise<any[]>;
+export declare function patchEachV3(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, submoduleName: string, setReadableInput: SetReadableInput): (originalFn: (...args: unknown[]) => unknown) => (this: Cursor, ...args: any[]) => unknown;
+export declare function patchForEach(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, submoduleName: string, setReadableInput: SetReadableInput): (originalFn: Cursor["forEach"]) => (this: Cursor, ...args: any[]) => void | Promise<void>;
+export declare function patchAsyncIterator(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, _submoduleName: string, setReadableInput: SetReadableInput): (originalFn: () => Generator<unknown, unknown, unknown>) => (this: Cursor) => AsyncGenerator<any, void, unknown>;
+export declare function patchGetMore(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, documents: unknown[]): (originalFn: (...args: unknown[]) => unknown) => (this: Cursor, ...args: unknown[]) => any;
+export declare function patchInitialize(plugin: HtMongoDbInstrumentation, version: string, mock: HtInstrumentationMockAbstract, documents: unknown[]): (originalFn: (...args: unknown[]) => unknown) => (this: Cursor, ...args: unknown[]) => any;
+export declare function patchNext(plugin: HtMongoDbInstrumentation, version: string, mock: HtInstrumentationMockAbstract, submoduleName: string, documents: unknown[], setReadableInput: SetReadableInput): (originalFn: Cursor["next"]) => (this: Cursor, ...args: any[]) => void | Promise<any>;
+export declare function patchHasNext(plugin: HtMongoDbInstrumentation, version: string, mock: HtInstrumentationMockAbstract, submoduleName: string, documents: unknown[], setReadableInput: SetReadableInput): (originalFn: Cursor["hasNext"]) => (this: Cursor, ...args: any[]) => void | Promise<boolean>;
+export declare function patchTryNext(plugin: HtMongoDbInstrumentation, version: string, mock: HtInstrumentationMockAbstract, submoduleName: string, documents: unknown[], setReadableInput: SetReadableInput): (originalFn: Cursor["tryNext"]) => (this: Cursor, ...args: any[]) => void | Promise<any>;
+export declare function patchStream(plugin: HtMongoDbInstrumentation, version: string, mock: HtInstrumentationMockAbstract, submoduleName: string, setReadableInput: SetReadableInput): (originalFn: (...args: unknown[]) => Readable) => (...args: unknown[]) => Readable;
+export declare function patchEmit(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, submoduleName: string): (originalFn: (...args: unknown[]) => unknown) => (args_0: string, ...args: unknown[]) => unknown;
+export declare function patchClose(plugin: HtMongoDbInstrumentation, mock: HtInstrumentationMockAbstract, submoduleName: string, setReadableInput: SetReadableInput): (originalFn: Cursor["close"]) => (this: Cursor, ...args: any[]) => void | Promise<void>;
+export declare function patchCursorDynamicMethods(plugin: HtMongoDbInstrumentation, cursor: Cursor, mock: HtInstrumentationMockAbstract, submoduleName: string, setReadableInput: SetReadableInput, version: string): void;

package/instrumentation/libraries/mongodb/modules/cursor/MongoDbExplainMock.d.ts

@@ -0,0 +1,35 @@
+import type { AggregationCursor, ExplainVerbosityLike } from 'mongov4';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    verbosity: ExplainVerbosityLike;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type RealOutput = ReturnType<AggregationCursor['explain']>;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbExplainMock 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 patchExplain(plugin: HtMongoDbInstrumentation, submoduleName: string, version: string): (originalFn: AggregationCursor["explain"]) => (callback: import("mongov4").Callback<any>) => void | Promise<void> | Promise<import("bson").Document>;
+export {};

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

@@ -0,0 +1,45 @@
+import type { Db as Db_v4 } from 'mongov4';
+import type { Db as Db_v5 } from 'mongov5';
+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['addUser'] | Db_v5['addUser']>;
+type Db = Db_v4 | Db_v5;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    username: string;
+    password: '[REDACTED]';
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    username: string;
+};
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = Record<string, Jsonable>;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbAddUserMock 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 patchAddUser(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["addUser"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

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

@@ -0,0 +1,41 @@
+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 { 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['collections'] | Db_v5['collections'] | Db_v6['collections']>;
+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 = Array<{
+    collectionName: string;
+}>;
+type OutputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export declare class MongoDbAddUserMock 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 patchCollections(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["collections"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

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

@@ -0,0 +1,47 @@
+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['command'] | Db_v5['command'] | Db_v6['command']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type InputMeta = {
+    commandPathMeta: PathMeta;
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    command: Record<string, Jsonable>;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    command: Record<string, Jsonable>;
+};
+type ProcessedInputSchema = {
+    command: Record<string, Jsonable>;
+};
+type RealOutput = Record<string, Jsonable>;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbCommandMock 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 patchCommand(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["command"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

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

@@ -0,0 +1,45 @@
+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['createCollection'] | Db_v5['createCollection'] | Db_v6['createCollection']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    name: string;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    name: string;
+};
+type ProcessedInputSchema = {
+    name: JsonSchemaWithoutValues;
+};
+type RealOutput = EmptyObject;
+type OutputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export declare class MongoDbCommandMock 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 patchCreateCollection(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["createCollection"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

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

@@ -0,0 +1,56 @@
+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 { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import { type Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['createIndex'] | Db_v5['createIndex'] | Db_v6['createIndex']>;
+type OutputType = ReturnType<Db_v4['createIndex'] | Db_v5['createIndex'] | Db_v6['createIndex']>;
+type QueryName = Parameters<Db_v6['createIndex'] | Db_v5['createIndex'] | Db_v4['createIndex']>[0];
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+    indexSpecMeta: PathMeta;
+};
+type ReadableInput = {
+    name: string;
+    indexSpec: Jsonable;
+    options: Record<string, Jsonable> & {
+        wildcardProjection?: Record<string, Jsonable>;
+    };
+};
+type ProcessedInput = {
+    name: QueryName;
+    indexSpec: Jsonable;
+    options: {
+        wildcardProjection?: Record<string, Jsonable>;
+    };
+};
+type ProcessedInputSchema = {
+    name: QueryName;
+    indexSpec: JsonSchemaWithoutValues;
+};
+type RealOutput = string;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbCreateIndexMock 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 patchDbCreateIndex(plugin: HtMongoDbInstrumentation): (originalFn: Db["createIndex"]) => (this: Db, ...args: InputArgs) => OutputType;
+export {};

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

@@ -0,0 +1,50 @@
+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 { 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, type Sanitized } from '../../mongoHelpers/processPayloadHelpers';
+type InputArgs = Parameters<Db_v4['aggregate'] | Db_v5['aggregate'] | Db_v6['aggregate']>;
+type QueryPipeline = Parameters<Db_v6['aggregate'] | Db_v5['aggregate'] | Db_v4['aggregate']>[0];
+type QueryOptions = Parameters<Db_v6['aggregate'] | Db_v5['aggregate'] | Db_v4['aggregate']>[1];
+type Db = Db_v4 | Db_v5 | Db_v6;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+    pipelinePathMeta: PathMeta;
+};
+type ReadableInput = {
+    pipeline: Sanitized<QueryPipeline>;
+    options: Sanitized<QueryOptions>;
+};
+type ProcessedInput = {
+    pipeline: Sanitized<QueryPipeline>;
+};
+type StageName = string;
+type ProcessedInputSchema = {
+    pipeline: StageName[];
+};
+type RealOutput = JsonableArray;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export default class MongoDbDbAggregateMock 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 patchDbAggregate(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["aggregate"]) => (this: Db, ...args: InputArgs) => any;
+export {};

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

@@ -0,0 +1,44 @@
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    fieldOrSpecMeta: PathMeta;
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    name: string;
+    fieldOrSpec: Jsonable;
+    options?: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    name: string;
+    fieldOrSpec: Jsonable;
+};
+type ProcessedInputSchema = {
+    name: string;
+    fieldOrSpec: Jsonable;
+};
+type RealOutput = string;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbDbEnsureIndexMock 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 patchDbEnsureIndex(plugin: HtMongoDbInstrumentation): (originalFn: any) => (this: any, ...args: any[]) => any;
+export {};

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

@@ -0,0 +1,45 @@
+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['dropCollection'] | Db_v5['dropCollection'] | Db_v6['dropCollection']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    name: string;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    name: string;
+};
+type ProcessedInputSchema = {
+    name: string;
+};
+type RealOutput = boolean;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbDropCollectionMock 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 patchDropCollection(plugin: HtMongoDbInstrumentation): (originalFn: Db["dropCollection"]) => (this: Db, ...args: InputArgs) => unknown;
+export {};

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

@@ -0,0 +1,41 @@
+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['dropDatabase'] | Db_v5['dropDatabase'] | Db_v6['dropDatabase']>;
+type OutputType = ReturnType<Db_v4['dropDatabase'] | Db_v5['dropDatabase'] | Db_v6['dropDatabase']>;
+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 = boolean;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbDropDatabaseMock 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 patchDropDatabase(plugin: HtMongoDbInstrumentation): (originalFn: Db["dropDatabase"]) => (this: Db, ...args: InputArgs) => OutputType;
+export {};

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

@@ -0,0 +1,46 @@
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { Db } from 'mongodb';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../../utils/types/jsonableTypes';
+import type { HtMongoDbInstrumentation } from '../../instrumentation';
+import type { Meta as PathMeta } from '../../mongoHelpers/processPayloadHelpers';
+type InputMeta = {
+    commandPathMeta: PathMeta;
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    command: Record<string, Jsonable>;
+    options?: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    command: Record<string, Jsonable>;
+};
+type ProcessedInputSchema = {
+    command: Record<string, Jsonable>;
+};
+type RealOutput = Record<string, Jsonable>;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbExecuteDbAdminCommand 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 patchDbExecuteDbAdminCommand(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Db["executeDbAdminCommand"]) => (this: any, command: object, options: {
+    readPreference?: import("mongodb").ReadPreferenceOrMode | undefined;
+    session?: import("mongodb").ClientSession | undefined;
+}, callback: import("mongodb").MongoCallback<any>) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/db/MongoDbIndexInformationMock.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['indexInformation'] | Db_v5['indexInformation'] | Db_v6['indexInformation']>;
+type OutputType = ReturnType<Db_v4['indexInformation'] | Db_v5['indexInformation'] | Db_v6['indexInformation']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    name: string;
+    options: Record<string, Jsonable>;
+};
+type ProcessedInput = {
+    name: string;
+};
+type ProcessedInputSchema = {
+    name: string;
+};
+type RealOutput = Record<string, Jsonable>;
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbIndexInformationMock 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 patchDbIndexInformation(plugin: HtMongoDbInstrumentation): (originalFn: Db["indexInformation"]) => (this: Db, ...args: InputArgs) => OutputType;
+export {};

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

@@ -0,0 +1,50 @@
+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 { JsonableArray, JsonableMap } 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['listCollections'] | Db_v5['listCollections'] | Db_v6['listCollections']>;
+type Db = Db_v4 | Db_v5 | Db_v6;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+    filterPathMeta: PathMeta;
+};
+type ReadableInput = {
+    databaseName: string;
+    filter: JsonableMap;
+    options: JsonableMap;
+};
+type ProcessedInput = {
+    databaseName: string;
+    filter: JsonableMap;
+};
+type ProcessedInputSchema = {
+    databaseName: string;
+    filter: JsonSchemaWithoutValues;
+};
+type RealOutput = JsonableArray;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = JsonableArray;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbListCollectionsMock 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 patchListCollections(plugin: HtMongoDbInstrumentation, version: string): (originalFn: any) => (this: Db, ...args: InputArgs) => any;
+export {};