@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/jsonwebtoken/mocks/JwtVerifyMock.d.ts

@@ -0,0 +1,27 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+type EmpytyObject = Record<string, never>;
+type InputMeta = EmpytyObject;
+type ReadableInput = EmpytyObject;
+type ProcessedInput = EmpytyObject;
+type ProcessedInputSchema = EmpytyObject;
+type OutputMeta = EmpytyObject;
+type RealOutput = EmpytyObject;
+type ReadableOutput = EmpytyObject;
+type ProcessedOutputSchema = EmpytyObject;
+export default class JwtVerifyMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): {};
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateReadableOutput(): ReadableOutput;
+}
+export {};

package/instrumentation/libraries/kafka/instrumentation.d.ts

@@ -0,0 +1,68 @@
+import type * as kafkaJs from 'kafkajs';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export type KafkaContextForConsumerHooks = {
+    groupId: string;
+};
+export declare class HtKafkaInstrumentation extends HtInstrumentationBase {
+    private Batch;
+    private consumerTopicsMap;
+    private consumerGroupIdMap;
+    constructor(config?: {});
+    manuallyPatchKafka(orignalKafka: typeof kafkaJs, version: string): typeof kafkaJs;
+    protected init(): HtInstrumentationNodeModule<typeof kafkaJs>[];
+    private _getAdminPatch;
+    private patchAsyncFunctions;
+    private _getAdminConnectPatch;
+    private _getAdminDisconnectPatch;
+    private _getAdminListTopicsPatch;
+    private _getAdminCreateTopicsPatch;
+    private _getAdminDeleteTopicsPatch;
+    private _getAdminCreatePartitionsPatch;
+    private _getAdminFetchTopicMetaDataPatch;
+    private _getAdminFetchOffsetsPatch;
+    private _getAdminFetchTopicOffsetsPatch;
+    private _getAdminFetchTopicByOffsetsByTimestampPatch;
+    private _getAdminDescribeClusterPatch;
+    private _getAdminSetOffsetsPatch;
+    private _getAdminResetOffsetsPatch;
+    private _getAdminDescribeConfigsPatch;
+    private _getAdminAlterConfigsPatch;
+    private _getAdminListGroupsPatch;
+    private _getAdminDeleteGroupsPatch;
+    private _getAdminDescribeGroupsPatch;
+    private _getAdminDescribeAclsPatch;
+    private _getAdminDeleteAclsPatch;
+    private _getAdminCreateAclsPatch;
+    private _getAdminDeleteTopicRecordsPatch;
+    private _getAdminAlterPartitionReassignmentsPatch;
+    private _getAdminListPartitionReassignmentsPatch;
+    private _getConsumerFnsInputOutputArgs;
+    private _getConsumerPatch;
+    private _getConsumerSeekPatch;
+    private _getConsumerDescribeGroup;
+    private _getConsumerPause;
+    private _getConsumerPaused;
+    private _getConsumerResume;
+    private _getConsumerCommitOffsets;
+    private _getConsumerStopPatch;
+    private _getConsumerSubscribePatch;
+    private _getConsumerDisconnectPatch;
+    private _getConsumerConnectPatch;
+    private _getConsumerRunPatch;
+    private createNewBatch;
+    private convertBatchToSingleMessageBatches;
+    private _getConsumerEachBatchPatch;
+    private _getConsumerEachMessagePatch;
+    private _getProducerPatch;
+    private _getProducerSendPatch;
+    private _getProducerSendBatchPatch;
+    private _getProducerConnectPatch;
+    private _getProducerDisconnectPatch;
+    private _getProducerTransactionPatch;
+    private _getProducerTransactionSendOffsetsPatch;
+    private _getProducerTransactionCommitPatch;
+    private _getProducerTransactionAbortPatch;
+    private patchSyncFunctions;
+    private _getProducerTransactionIsActivePatch;
+}

package/instrumentation/libraries/kafka/mocks/KafkaClientMock.d.ts

@@ -0,0 +1,29 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable, JsonableMap } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = JsonableMap;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class KafkaClientMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/kafka/mocks/KafkaSendBatchMock.d.ts

@@ -0,0 +1,55 @@
+import type { CompressionTypes, Producer, RecordMetadata } from 'kafkajs';
+import type { JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtKafkaJsonValue, KafkaHeaderType } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtKafkaInstrumentation } from '../instrumentation';
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    bufferMap: Record<string, {
+        valueString: string;
+        valueStringEncoding: HtRawEncoding;
+    }>;
+};
+type ReadableMessage = {
+    key: string;
+    value: string | HtKafkaJsonValue;
+    headers?: KafkaHeaderType;
+    partition?: number;
+    timestamp?: string;
+};
+type ReadableTopicMessages = {
+    topic: string;
+    messages: ReadableMessage[];
+};
+type ReadableInput = {
+    acks?: number;
+    timeout?: number;
+    compression?: CompressionTypes;
+    topicMessages: ReadableTopicMessages[];
+};
+type ProcessedInput = {
+    topicMessages: Array<Pick<ReadableTopicMessages, 'topic'> & {
+        messages: Pick<ReadableMessage, 'value'>[];
+    }>;
+};
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+type OutputMeta = EmptyObject;
+type RealOutput = RecordMetadata[];
+type ReadableOutput = RecordMetadata[];
+type ProcessedOutputSchema = EmptyObject;
+export default class KafkaSendBatchMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchSendBatchFn(plugin: HtKafkaInstrumentation, packageName: string, submoduleName: string, sendBatchFnInputArgs: Parameters<Producer['sendBatch']>, originalFn: Producer['sendBatch']): ReturnType<Producer['sendBatch']>;
+export {};

package/instrumentation/libraries/kafka/mocks/KafkaSendMock.d.ts

@@ -0,0 +1,51 @@
+import type { CompressionTypes, Producer, RecordMetadata } from 'kafkajs';
+import type { JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtKafkaJsonValue, KafkaHeaderType } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { HtKafkaInstrumentation } from '../instrumentation';
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    bufferMap: Record<string, {
+        valueString: string;
+        valueStringEncoding: HtRawEncoding;
+    }>;
+};
+type ReadableMessage = {
+    key: string;
+    value: string | HtKafkaJsonValue;
+    headers?: KafkaHeaderType;
+    partition?: number;
+    timestamp?: string;
+};
+type ReadableInput = {
+    topic: string;
+    acks?: number;
+    timeout?: number;
+    compression?: CompressionTypes;
+    messages: ReadableMessage[];
+};
+type ProcessedInput = {
+    topic: ReadableInput['topic'];
+    messages: Pick<ReadableMessage, 'value'>[];
+};
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+type OutputMeta = EmptyObject;
+type RealOutput = RecordMetadata[];
+type ReadableOutput = RecordMetadata[];
+type ProcessedOutputSchema = EmptyObject;
+export default class KafkaSendMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchSendFn(plugin: HtKafkaInstrumentation, packageName: string, submoduleName: string, sendFnInputArgs: Parameters<Producer['send']>, originalFn: Producer['send']): ReturnType<Producer['send']>;
+export {};

package/instrumentation/libraries/kafka/mocks/KafkaServerMock.d.ts

@@ -0,0 +1,35 @@
+import { type KafkaInputMeta, type KafkaOutput, type KafkaOutputMeta, type KafkaReqType, OutputStatus } from '../../../../../../utils/types';
+import type { JsonSchemaWithoutLangType, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import type { JsonableMap } from '../../../../../../utils/types/jsonableTypes';
+import { HtServerMockAbstract } from '../../../core/baseClasses/HtServerMockAbstract';
+export declare class KafkaServerRequestMock extends HtServerMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ProcessedOutputSchema, UserMeta> {
+    constructor({ plugin, packageName, submoduleName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    generateOutputStatus(): OutputStatus;
+    save(): void;
+}
+export type ReadableInput = KafkaReqType;
+export type ProcessedInput = Pick<ReadableInput, 'groupId' | 'topic' | 'jsonValue'>;
+export type ProcessedInputSchema = Omit<ProcessedInput, 'jsonValue'> & {
+    jsonBodySchema: JsonSchemaWithoutValues;
+};
+type InputValueWithoutLangType = Omit<ProcessedInput, 'jsonValue'> & {
+    jsonBodySchema: JsonSchemaWithoutLangType;
+};
+export type InputMeta = KafkaInputMeta;
+export type RealOutput = KafkaOutput;
+export type ReadableOutput = RealOutput;
+export type ProcessedOutputSchema = RealOutput;
+type OutputValueWithoutLangType = null;
+export type OutputMeta = KafkaOutputMeta;
+export type UserMeta = JsonableMap;
+export {};

package/instrumentation/libraries/kafka/replayModeHandlers.d.ts

@@ -0,0 +1,18 @@
+import type { EachBatchHandler, EachMessageHandler } from 'kafkajs';
+import type { KafkaReqTypeMinimal } from '../../../../../utils/types';
+export declare enum KafkaHandlerType {
+    EACH_MESSAGE = "EACH_MESSAGE",
+    EACH_BATCH = "EACH_BATCH"
+}
+export declare function setPluginInstance(plugin: any): void;
+export declare function registerKafkaConsumer<HandlerType extends KafkaHandlerType>(messageHandler: HandlerType extends KafkaHandlerType.EACH_MESSAGE ? EachMessageHandler : EachBatchHandler, groupId: string, topics: Array<string | RegExp>, handlerType: HandlerType): void;
+type GetKafkaConsumerResult = {
+    handler: EachMessageHandler;
+    handlerType: KafkaHandlerType.EACH_MESSAGE;
+} | {
+    handler: EachBatchHandler;
+    handlerType: KafkaHandlerType.EACH_BATCH;
+} | undefined;
+export declare function getKafkaConsumer(groupId: string, topic: string): GetKafkaConsumerResult;
+export declare function runKafkaConsumer<HandlerType extends KafkaHandlerType>(handler: HandlerType extends KafkaHandlerType.EACH_MESSAGE ? EachMessageHandler : EachBatchHandler, handlerType: HandlerType, kafkaReqObjMinimal: KafkaReqTypeMinimal, requestId: string): Promise<void>;
+export {};

package/instrumentation/libraries/kafka/utils.d.ts

@@ -0,0 +1,30 @@
+import type { EachBatchPayload, EachMessagePayload, ProducerBatch, ProducerRecord } from 'kafkajs';
+import type { InputMeta, ReadableInput } from './mocks/KafkaServerMock';
+export declare function createKafkaReqObj(payload: EachMessagePayload | EachBatchPayload, groupId: string): {
+    readableInput: ReadableInput;
+    inputMeta: InputMeta;
+};
+export declare function getReadableKey(key: Buffer | string | null): string;
+export declare function createKafkaReqObjForSend(record: ProducerRecord): {
+    readableInput: {
+        topic: string;
+        messages: unknown[];
+        acks: number;
+        timeout: number;
+        compression: import("kafkajs").CompressionTypes;
+    };
+    inputMeta: {
+        bufferMap: {};
+    };
+};
+export declare function createKafkaReqObjForSendBatch(batch: ProducerBatch): {
+    readableInput: {
+        acks: number;
+        timeout: number;
+        compression: import("kafkajs").CompressionTypes;
+        topicMessages: unknown[];
+    };
+    inputMeta: {
+        bufferMap: {};
+    };
+};

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

@@ -0,0 +1,8 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtMongoDbInstrumentation extends HtInstrumentationBase {
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<any>[];
+}

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminAddUserMock.d.ts

@@ -0,0 +1,45 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_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<Admin_v4['addUser'] | Admin_v5['addUser']>;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type Admin = Admin_v4 | Admin_v5;
+type EmptyObject = Record<string, never>;
+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 MongoDbAdminAddUserMock 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 patchAdminAddUser(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["addUser"]) => (this: Admin, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminCommandMock.d.ts

@@ -0,0 +1,48 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_v5 } from 'mongov5';
+import type { Admin as Admin_v6 } from 'mongov6';
+import type { JsonSchemaWithoutValues } from '../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { FunctionTypeEnum } from '../../../../../../../utils/types';
+import type { Jsonable, 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<Admin_v4['command'] | Admin_v5['command'] | Admin_v6['command']>;
+type OutputType = ReturnType<Admin_v4['command'] | Admin_v5['command'] | Admin_v6['command']>;
+type Admin = Admin_v4 | Admin_v5 | Admin_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 = JsonableMap;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbAdminCommandMock 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 patchAdminCommand(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["command"]) => (this: Admin, ...args: InputArgs) => OutputType;
+export {};

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminListDatabasesMock.d.ts

@@ -0,0 +1,51 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_v5 } from 'mongov5';
+import type { Admin as Admin_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<Admin_v4['listDatabases'] | Admin_v5['listDatabases'] | Admin_v6['listDatabases']>;
+type Admin = Admin_v4 | Admin_v5 | Admin_v6;
+type InputMeta = {
+    optionsPathMeta: PathMeta;
+};
+type ReadableInput = {
+    options?: Record<string, Jsonable> & {
+        filter?: Record<string, Jsonable>;
+    };
+};
+type ProcessedInput = {
+    options: {
+        filter?: Record<string, Jsonable>;
+    };
+};
+type ProcessedInputSchema = {
+    options: {
+        filter?: Record<string, Jsonable>;
+    };
+};
+type RealOutput = Record<string, Jsonable>;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbAdminListDatabasesMock 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 patchAdminListDatabases(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["listDatabases"]) => (this: Admin, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminPingMock.d.ts

@@ -0,0 +1,42 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_v5 } from 'mongov5';
+import type { Admin as Admin_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<Admin_v4['ping'] | Admin_v5['ping'] | Admin_v6['ping']>;
+type Admin = Admin_v4 | Admin_v5 | Admin_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 MongoDbAdminPingMock 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 patchAdminPing(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["ping"]) => (this: Admin, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminRemoveUserMock.d.ts

@@ -0,0 +1,45 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_v5 } from 'mongov5';
+import type { Admin as Admin_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<Admin_v4['removeUser'] | Admin_v5['removeUser'] | Admin_v6['removeUser']>;
+type Admin = Admin_v4 | Admin_v5 | Admin_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 = Record<string, Jsonable>;
+type OutputMeta = {
+    pathMeta: PathMeta;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class MongoDbAdminValidateCollectionMock 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 patchAdminRemoveUser(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["removeUser"]) => (this: Admin, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminReplGetSetStatusMock.d.ts

@@ -0,0 +1,42 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_v5 } from 'mongov5';
+import type { Admin as Admin_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<Admin_v4['replSetGetStatus'] | Admin_v5['replSetGetStatus'] | Admin_v6['replSetGetStatus']>;
+type Admin = Admin_v4 | Admin_v5 | Admin_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 MongoDbAdminReplSetGetStatusMock 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 patchAdminReplSetGetStatus(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["replSetGetStatus"]) => (this: Admin, ...args: InputArgs) => unknown;
+export {};

package/instrumentation/libraries/mongodb/modules/admin/MongoDbAdminServerInfoMock.d.ts

@@ -0,0 +1,42 @@
+import type { Admin as Admin_v4 } from 'mongov4';
+import type { Admin as Admin_v5 } from 'mongov5';
+import type { Admin as Admin_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<Admin_v4['serverInfo'] | Admin_v5['serverInfo'] | Admin_v6['serverInfo']>;
+type Admin = Admin_v4 | Admin_v5 | Admin_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 MongoDbAdminServerInfoMock 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 patchAdminServerInfo(plugin: HtMongoDbInstrumentation, version: string): (originalFn: Admin["serverInfo"]) => (this: Admin, ...args: InputArgs) => unknown;
+export {};