@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/pg/mocks/CursorReadMock.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 EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = EmptyObject;
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export default class PgCursorReadMock 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(): EmptyObject;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): unknown;
+}
+export {};

package/instrumentation/libraries/pg/mocks/CursorSubmitMock.d.ts

@@ -0,0 +1,30 @@
+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 = {
+    rawArgsArr: unknown[];
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmpytyObject;
+type RealOutput = unknown;
+type ReadableOutput = unknown;
+type ProcessedOutputSchema = unknown;
+export default class PgCursorSubmitMock 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(): unknown;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: unknown): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/pg/mocks/PgQueryMock.d.ts

@@ -0,0 +1,44 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { QueryInput, QueryResult } from '../internalTypes';
+import { type HT_AST } from '../../../helpers/sqlParser';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = QueryInput;
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: any[];
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+};
+type OutputMeta = EmptyObject;
+type RealOutput = QueryResult;
+type ReadableOutput = {
+    rows: any[];
+};
+type ProcessedOutputSchema = {
+    columnTypes: Record<string, number>;
+};
+export default class PgQueryMock 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;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+/**
+ * The readable input generated here would have different formatting for the SQL string than the original one.
+ * Always compare the two re-generated inputs from this function to get accurate results
+ */
+export declare const generateReadableInputFromProcessedInputPgQueryMock: (processedInput: ProcessedInput) => ReadableInput;
+export {};

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

@@ -0,0 +1,12 @@
+import { type AnyFunction } from '../../../../../utils/types';
+import type { HtPgInstrumentation } from './instrumentation';
+import type { QueryInput } from './internalTypes';
+import type ConnectMock from './mocks/ConnectMock';
+export declare function isObjectWithTextString(it: unknown): it is ObjectWithText;
+export type ObjectWithText = {
+    [k: string]: unknown;
+    text: string;
+};
+export declare const getPatchedConnectCallback: (callback: AnyFunction, mock: ConnectMock) => (...args: unknown[]) => undefined;
+export declare function getPatchedQueryCbForTestMode(originalCb: AnyFunction, packageName: string, submoduleName: string, plugin: HtPgInstrumentation, readableInput: QueryInput): () => void;
+export declare function getPatchedCursorReadCbForTestMode(originalCb: AnyFunction, packageName: string, submoduleName: string, plugin: HtPgInstrumentation, inputArgsObj: any): () => void;

package/instrumentation/libraries/prisma/instrumentation.d.ts

@@ -0,0 +1,14 @@
+import type { AnyFunction } from 'sequelize/types/utils';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtPrismaInstrumentation extends HtInstrumentationBase {
+    constructor(config?: {});
+    _PrismaCustomErrorClasses: {
+        prismaErrClass: AnyFunction;
+        name: string;
+    }[];
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private _getPrismaV5Patch;
+    private getPrismaErrorClassName;
+    private getPrismaErrorClassFromName;
+}

package/instrumentation/libraries/prisma/mocks/PrismaMock.d.ts

@@ -0,0 +1,45 @@
+import type { JsonSchema, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } 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 = {
+    model: string;
+    operation: string;
+    args: Jsonable | (bigint & Jsonable);
+};
+type ProcessedInput = {
+    model: string;
+    operation: string;
+    args: JsonSchema;
+};
+type ProcessedInputSchema = {
+    model: string;
+    operation: string;
+    args: JsonSchemaWithoutValues;
+};
+type OutputMeta = EmptyObject;
+type RealOutput = object;
+type ReadableOutput = {
+    prismaResult: object;
+};
+type ProcessedOutputSchema = {
+    prismaResult: JsonSchemaWithoutValues;
+};
+export declare class PrismaMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, }: {
+        plugin: HtInstrumentationBase;
+    });
+    generateProcessedInput(): {
+        model: string;
+        operation: string;
+        args: JsonSchema;
+    };
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/redis/instrumentation.d.ts

@@ -0,0 +1,16 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtRedisInstrumentation extends HtInstrumentationBase {
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<RedisClientTypes.RedisClientType>[];
+    private _traceClientCommand;
+    private _getPatchedClientSelect;
+    private _getPatchRedisClientSendCommand;
+    private _getPatchRedisClientCommandsExecutor;
+    private _getPatchedClientConnect;
+    private _getPatchMultiCommandsExec;
+    private _getPatchExtendWithCommands;
+    private _getInitInstrumentationNodeModuleDefinition;
+}

package/instrumentation/libraries/redis/mocks/RedisMock.d.ts

@@ -0,0 +1,41 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { JsonSchema, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+export type InputMeta = Record<number, {
+    bufferMeta?: string;
+    encoding: HtRawEncoding;
+    isValueJson?: boolean;
+}>;
+type ReadableInput = {
+    functionArgs: Record<number, Jsonable>;
+};
+type ProcessedInput = JsonSchema;
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+export type OutputMeta = {
+    value?: string;
+    encoding?: HtRawEncoding;
+    isValueJson?: boolean;
+};
+type RealOutput = {
+    returnValue: Jsonable;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export default class RedisMock 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(): JsonSchema;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import type { Jsonable } from '../../../../../utils/types/jsonableTypes';
+export declare const convertValueToOriginalType: (value: string | Jsonable, bufferMeta: string, encoding: HtRawEncoding, isValueJson: boolean) => string | Buffer;
+export declare const convertValueToJsonable: (value: Buffer | Jsonable) => {
+    value: any;
+    bufferMeta: any;
+    encoding: string;
+    isValueJson: boolean;
+} | {
+    value: string;
+    bufferMeta: string;
+    encoding: string;
+    isValueJson?: undefined;
+} | {
+    value: string | number | boolean | import("../../../../../utils/types/jsonableTypes").JsonableArray | import("../../../../../utils/types/jsonableTypes").JsonableMap;
+    bufferMeta: any;
+    encoding: string;
+    isValueJson?: undefined;
+};

package/instrumentation/libraries/redis3/instrumentation.d.ts

@@ -0,0 +1,10 @@
+import type * as RedisTypes from '@types/redis';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtRedis3Instrumentation extends HtInstrumentationBase {
+    redisClientPrototype: RedisTypes.RedisClient | undefined;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<unknown>[];
+}

package/instrumentation/libraries/redis3/mocks/CreateClientMock.d.ts

@@ -0,0 +1,6 @@
+import { type AnyFunction } from '../../../../../../utils/types';
+import type * as RedisTypes from '@types/redis';
+import type { HtRedis3Instrumentation } from '../instrumentation';
+type EmptyObject = Record<string, never>;
+export declare function getPatchedCreateClient(plugin: HtRedis3Instrumentation, executeOriginalFnWithContext: HtRedis3Instrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: AnyFunction) => (this: unknown, ...args: unknown[]) => Error | RedisTypes.RedisClient | EmptyObject;
+export {};

package/instrumentation/libraries/redis3/mocks/InternalSendCommandMock.d.ts

@@ -0,0 +1,13 @@
+import type * as RedisTypes from '@types/redis';
+import type { HtRedis3Instrumentation } from '../instrumentation';
+export type InputMeta = Record<number, {
+    bufferMeta?: string;
+    encoding: HtRawEncoding;
+    isValueJson?: boolean;
+}>;
+export type OutputMeta = {
+    value?: string;
+    encoding?: HtRawEncoding;
+    isValueJson?: boolean;
+};
+export declare function getInternalSendCommandPatch(plugin: HtRedis3Instrumentation, executeOriginalFnWithContext: HtRedis3Instrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: typeof RedisTypes.RedisClient.prototype.internal_send_command) => (this: any, ...args: any[]) => unknown;

package/instrumentation/libraries/redis3/mocks/MultiMock.d.ts

@@ -0,0 +1,13 @@
+import type * as RedisTypes from '@types/redis';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtRedis3Instrumentation } from '../instrumentation';
+export type OutputMeta = {
+    value?: string;
+    encoding?: HtRawEncoding;
+    isValueJson?: boolean;
+};
+type RealOutput = {
+    returnValue: Jsonable;
+};
+export declare function getPatchedRedisMultiExec(plugin: HtRedis3Instrumentation, executeOriginalFnWithContext: HtRedis3Instrumentation['executeOriginalFnWithContext'], submoduleName: string, packageName: string): (originalFn: typeof RedisTypes.Multi.prototype.exec) => (this: any, ...args: any[]) => Jsonable | RealOutput;
+export {};

package/instrumentation/libraries/sentry/instrumentation.d.ts

@@ -0,0 +1,10 @@
+import type { AnyFunction } from '../../../../../utils/types';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtSentryInstrumentation extends HtInstrumentationBase {
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<{
+        init: AnyFunction;
+    }>[];
+    private patchInitFn;
+}

package/instrumentation/libraries/sequelize/helpers/processPayloadHelpers.d.ts

@@ -0,0 +1,12 @@
+import type { Model } from 'sequelize/types/model';
+import type { JsonableArray, JsonableMap } from '../../../../../../utils/types/jsonableTypes';
+type NonEmptyPath = [string, ...string[]];
+export type Meta = {
+    [key: string]: NonEmptyPath[];
+};
+export declare const sanitizePayload: <T>(payload: T, models: Record<string, typeof Model>) => {
+    sanitizedPayload: T extends unknown[] ? JsonableArray : JsonableMap;
+    meta: Meta;
+};
+export declare const convertSanitizedPayloadToRealPayload: (sanitizedPayload: JsonableArray | JsonableMap, meta: Meta, ObjectConstructor: Record<string, typeof Model>) => void;
+export {};

package/instrumentation/libraries/sequelize/instrumentation.d.ts

@@ -0,0 +1,36 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtSequelizeInstrumentation extends HtInstrumentationBase {
+    _HtTransaction: any;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private patchAsyncFunctions;
+    private _getPatchModelFindAll;
+    private _getPatchModelBulkCreate;
+    private _getPatchModelFindOne;
+    private _getPatchModelUpdate;
+    private _getPatchModelCreate;
+    private _getPatchModelInstanceDestroy;
+    private _getPatchModelDestroy;
+    private _getPatchModelRestore;
+    private _getPatchModelInstanceRestore;
+    private _getPatchModelDrop;
+    private _getPatchModelInstanceReload;
+    private _getPatchModelFindOrCreate;
+    private _getPatchModelFindByPk;
+    private _getPatchModelFindOrBuild;
+    private _getPatchModelMaxOrMinOrSum;
+    private _getPatchModelIncOrDec;
+    private _getPatchModelInstanceIncOrDec;
+    private _getPatchModelSave;
+    private _getPatchModelCount;
+    private _getPatchModelDescribe;
+    private _getPatchModelUpsert;
+    private _getPatchQuery;
+    private _getPatchedSyncFn;
+    private _getPatchedAuthenticateFn;
+    private _getPatchedTransactionFn;
+    private _getPatchedCommitAndRollbackFn;
+}

package/instrumentation/libraries/sequelize/internalTypes.d.ts

@@ -0,0 +1,22 @@
+import type { Model } from 'sequelize/types/model';
+import type { AnyFunction, FunctionTypeEnum } from '../../../../../utils/types';
+import type { HtSequelizeInstrumentation } from './instrumentation';
+export type RawQueryReadableInput = {
+    queryText: string;
+    values: unknown[];
+    dialect?: string;
+    model?: string;
+};
+export type AsyncFunctionPatchParams = {
+    plugin: HtSequelizeInstrumentation;
+    submoduleName: string;
+    inputArgs: unknown[];
+    readableInput: Record<string, unknown> | RawQueryReadableInput;
+    originalFn: AnyFunction;
+    functionType: FunctionTypeEnum;
+    thisValue: Record<string, unknown>;
+    models: Record<string, typeof Model>;
+    isQueryMock?: string;
+    isRaw?: boolean;
+    shouldLogMockNotFoundError?: boolean;
+};

package/instrumentation/libraries/sequelize/mocks/SequelizeMock.d.ts

@@ -0,0 +1,38 @@
+import type { Model } from 'sequelize/types/model';
+import { type 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 Meta } from '../helpers/processPayloadHelpers';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = Record<string, unknown>;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject | {
+    pathMeta: Meta;
+};
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class SequelizeMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    unsantizedRealOutput: unknown;
+    models: Record<string, typeof Model>;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, isImportantMock, models, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+        models?: Record<string, typeof Model>;
+    });
+    setReadableInput(readableInput: ReadableInput, inputMeta: InputMeta): void;
+    generateProcessedInput(): ProcessedInput;
+    setOutput(realOutput: RealOutput, emptyDefaultPathMeta?: {}): void;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/sequelize/mocks/SequelizeRawQueryMock.d.ts

@@ -0,0 +1,55 @@
+import type { Model } from 'sequelize/types/model';
+import { type 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 HT_AST } from '../../../helpers/sqlParser';
+import { type Meta } from '../helpers/processPayloadHelpers';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    queryText: string;
+    values: unknown[];
+    dialect?: string;
+    model?: string;
+};
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: unknown[];
+    dialect?: string;
+    model?: string;
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+};
+type OutputMeta = EmptyObject | {
+    pathMeta: Meta;
+};
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class SequelizeRawQueryMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    unsantizedRealOutput: unknown;
+    models: Record<string, typeof Model>;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, isImportantMock, models, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+        models?: Record<string, typeof Model>;
+    });
+    generateProcessedInput(): ProcessedInput;
+    setOutput(realOutput: RealOutput, emptyDefaultPathMeta?: {}): void;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+/**
+ * The readable input generated here would have different formatting for the SQL string than the original one.
+ * Always compare the two re-generated inputs from this function to get accurate results
+ */
+export declare const generateReadableInputFromSequelizeRawQueryMock: (processedInput: ProcessedInput) => ReadableInput;
+export {};

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

@@ -0,0 +1,6 @@
+import type * as DataTypes from 'sequelize';
+export declare function modulesArray(moduleExports: typeof DataTypes): {
+    module: any;
+    method: string;
+    submoduleName: string;
+}[];

package/instrumentation/libraries/socket.io/instrumentation.d.ts

@@ -0,0 +1,26 @@
+import type SocketIoModule from 'socket.io';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtSocketIoInstrumentation extends HtInstrumentationBase {
+    private HT_PATCHED_NAMESPACE;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    manuallyPatchSocketIo(originalSocketIoModule: typeof SocketIoModule, version: string): typeof SocketIoModule;
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private getEmitV3PatchFn;
+    private getSocketJoinPatchFn;
+    private getUsePatchFn;
+    private getAllSocketsPatchFn;
+    private getOfPatchFn;
+    private getFetchSocketsPatchFn;
+    private getBindPatchFn;
+    private getAttachAppPatchFn;
+    private getAttachPatchFn;
+    private getAdapterPatchFn;
+    private getEmitPatchFn;
+    private getEmitWithAckPatchFn;
+    private getOpenPatchFn;
+    private getClosePatchFn;
+    private getOnPatchFn;
+}

package/instrumentation/libraries/sqlite3/instrumentation.d.ts

@@ -0,0 +1,20 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtSqlite3Instrumentaion extends HtInstrumentationBase {
+    _HtStatement: any;
+    _HtDatabase: any;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private _getDatabasePatchFn;
+    private _getDbPreparePatchFn;
+    private _getDatabaseRunQueryPatchFn;
+    private _getStatementPatchFn;
+    private _getStatementFinalizePatchFn;
+    private _getDatabaseClosePatchFn;
+    private _getStatementRunPatchFn;
+    private _getDatabaseEachPatchFn;
+    private _getStatementEachPatchFn;
+    private _getMapPatchFn;
+}

package/instrumentation/libraries/sqlite3/mocks/sqlite3DatabaseMock.d.ts

@@ -0,0 +1,38 @@
+import { type 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 HT_AST } from '../../../helpers/sqlParser';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    queryText?: string;
+    values: string[] | number[];
+    fileName?: string;
+};
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: ReadableInput['values'];
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+};
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class Sqlite3DatabaseMock 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(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+export {};

package/instrumentation/libraries/sqlite3/mocks/sqlite3DbCloseMock.d.ts

@@ -0,0 +1,30 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } 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 = {
+    fileName?: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class Sqlite3DbCloseMock 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(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/sqlite3/mocks/sqlite3DbPrepareMock.d.ts

@@ -0,0 +1,37 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { type HT_AST } from '../../../helpers/sqlParser';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    queryText?: string;
+    values: string[] | number[];
+    fileName?: string;
+};
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: ReadableInput['values'];
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+};
+type OutputMeta = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class Sqlite3DbPrepareMock 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(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateReadableOutput(): ReadableOutput;
+}
+export {};