@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/etcd3/modules/role/Etcd3RolePermissionsMock.d.ts

@@ -0,0 +1,57 @@
+import type { Range, Role } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    name: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type InputMeta = EmptyObject;
+declare enum Permission {
+    Read = "Read",
+    Write = "Write",
+    Readwrite = "Readwrite"
+}
+type ReadablePermission = {
+    permission: keyof typeof Permission;
+    range: {
+        start: string;
+        end: string;
+    };
+};
+type RealOutput = {
+    permissionResults: ReadablePermission[];
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = {
+    permissionResults: Array<{
+        rangeBuffer: {
+            start: {
+                value: string;
+                encoding: HtRawEncoding;
+            };
+            end: {
+                value: string;
+                encoding: HtRawEncoding;
+            };
+        };
+    }>;
+};
+export declare class Etcd3RolePermissionsMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): EmptyObject;
+}
+export declare function patchPermissions(plugin: HtEtcd3Instrumentation, RangeClass: typeof Range): (originalFn: Role["permissions"]) => (this: Role, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["permissions"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/role/Etcd3RoleRemoveUserMock.d.ts

@@ -0,0 +1,31 @@
+import type { Role } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type ReadableInput = {
+    roleName: string;
+    userName: string;
+};
+type EmptyObject = Record<string, never>;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type RealOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3RoleRemoveUserMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchRemoveUser(plugin: HtEtcd3Instrumentation): (originalFn: Role["removeUser"]) => (this: Role, user: string | import("etcd3").User, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["removeUser"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/role/Etcd3RoleRevokeMock.d.ts

@@ -0,0 +1,66 @@
+import type { Role } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+declare enum Permission {
+    Read = "Read",
+    Write = "Write",
+    Readwrite = "Readwrite"
+}
+type EmptyObject = Record<string, never>;
+type ReadablePermission = {
+    permission: keyof typeof Permission;
+    range: {
+        start: string;
+        end: string;
+    };
+} | {
+    permission: keyof typeof Permission;
+    key: string;
+};
+type ReadableInput = {
+    name: string;
+    permissionRequests: ReadablePermission[];
+};
+type InputMeta = {
+    permissionRequests: Array<{
+        rangeBuffer: {
+            start: {
+                value: string;
+                encoding: HtRawEncoding;
+            };
+            end: {
+                value: string;
+                encoding: HtRawEncoding;
+            };
+        };
+    } | {
+        keyBuffer?: {
+            value: string;
+            encoding: HtRawEncoding;
+        };
+    }>;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = {
+    name: string;
+};
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3RoleRevokeMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): EmptyObject;
+    generateProcessedOutputSchema(): EmptyObject;
+}
+export declare function patchRevoke(plugin: HtEtcd3Instrumentation): (originalFn: Role["revoke"]) => (this: Role, req: import("etcd3").IPermissionRequest | import("etcd3").IPermissionRequest[], options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["revoke"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/transaction/Etcd3TransactionCommitMock.d.ts

@@ -0,0 +1,28 @@
+import type { SoftwareTransaction } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = EmptyObject;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type RealOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3TransactionCommitMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchCommit(plugin: HtEtcd3Instrumentation): (originalFn: SoftwareTransaction["commit"]) => (this: SoftwareTransaction, ...inputArgs: Parameters<SoftwareTransaction["commit"]>) => ReturnType<SoftwareTransaction["commit"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/transaction/Etcd3TransactionTransactMock.d.ts

@@ -0,0 +1,3 @@
+import type { SoftwareTransaction } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare function patchTransact(plugin: HtEtcd3Instrumentation): (originalFn: SoftwareTransaction["transact"]) => (this: SoftwareTransaction, fn: (tx: SoftwareTransaction) => unknown) => ReturnType<SoftwareTransaction["transact"]>;

package/instrumentation/libraries/etcd3/modules/user/Etcd3UserAddRoleMock.d.ts

@@ -0,0 +1,31 @@
+import type { User } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    userName: string;
+    roleName: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type RealOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3UserAddRoleMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchAddRole(plugin: HtEtcd3Instrumentation): (originalFn: User["addRole"]) => (this: User, role: string | import("etcd3").Role, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<User["addRole"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/user/Etcd3UserCreateMock.d.ts

@@ -0,0 +1,33 @@
+import type { User } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    name: string;
+    password: '[REDACTED]';
+};
+type ProcessedInput = {
+    name: string;
+};
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3UserCreateMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchCreate(plugin: HtEtcd3Instrumentation): (originalFn: User["create"]) => (this: User, password: string, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<User["create"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/user/Etcd3UserDeleteMock.d.ts

@@ -0,0 +1,30 @@
+import type { User } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    name: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type RealOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3UserDeleteMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchDelete(plugin: HtEtcd3Instrumentation): (originalFn: User["delete"]) => (this: User, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<User["delete"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/user/Etcd3UserRemoveRole.d.ts

@@ -0,0 +1,31 @@
+import type { User } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    userName: string;
+    roleName: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = EmptyObject;
+type RealOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3UserRemoveRoleMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchRemoveRole(plugin: HtEtcd3Instrumentation): (originalFn: User["removeRole"]) => (this: User, role: string | import("etcd3").Role, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<User["removeRole"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/user/Etcd3UserRolesMock.d.ts

@@ -0,0 +1,32 @@
+import type { Role, User } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    name: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = {
+    roleNames: string[];
+};
+type RealOutput = ReadableOutput;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3UserRolesMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchRoles(plugin: HtEtcd3Instrumentation, RoleClass: typeof Role): (originalFn: User["roles"]) => (this: User, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<User["roles"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/user/Etcd3UserSetPasswordMock.d.ts

@@ -0,0 +1,33 @@
+import type { User } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+type EmptyObject = Record<string, never>;
+type ReadableInput = {
+    name: string;
+    password: '[REDACTED]';
+};
+type ProcessedInput = {
+    name: string;
+};
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3UserSetPasswordMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function patchSetPassword(plugin: HtEtcd3Instrumentation): (originalFn: User["setPassword"]) => (this: User, password: string, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<User["setPassword"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/watchBuilder/Etcd3WatchBuilderWatcherMock.d.ts

@@ -0,0 +1,3 @@
+import type { WatchBuilder } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare function patchWatcher(plugin: HtEtcd3Instrumentation): (originalFn: WatchBuilder["watcher"]) => (this: WatchBuilder) => ReturnType<WatchBuilder["watcher"]>;

package/instrumentation/libraries/express/instrumentation.d.ts

@@ -0,0 +1,12 @@
+import type * as express from 'express';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtExpressInstrumentation extends HtInstrumentationBase {
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<typeof express>;
+    private _getRoutePatch;
+    private _getRouterUsePatch;
+    private _getAppUsePatch;
+    private _patchHandleFn;
+    private _applyPatch;
+}

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

@@ -0,0 +1,3 @@
+export declare const getLayerPath: (arg: any) => string;
+export declare const httpMethodsArr: string[];
+export declare const kLayerPatched: unique symbol;

package/instrumentation/libraries/fastify/instrumentation.d.ts

@@ -0,0 +1,8 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtFastifyInstrumentation extends HtInstrumentationBase {
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<unknown>;
+    private onRequest;
+    private _patchConstructor;
+}

package/instrumentation/libraries/graphql/instrumentation.d.ts

@@ -0,0 +1,24 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtGraphqlInstrumentation extends HtInstrumentationBase {
+    _Original_ApolloServer: any;
+    _HT_Patched_ApolloServer: any;
+    _Original_GraphQLClient: any;
+    _HT_Patched_GraphQLClient: any;
+    _isHT_Express_Graphql_Server: boolean;
+    _isHT_Yoga_Graphql_Server: boolean;
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private _patchCreateYogaServer;
+    private _patchExpressGraphqlHTTP;
+    private _patchExecuteFn;
+    private getPatchedGraphQLClientClass;
+    private getMockGraphQLClientClass;
+    private getPatchedGraphqlRawRequest;
+    private getPatchedGraphqlRequest;
+    private getPatchedGraphqlBatchRequests;
+    private _patchProcessGraphQLRequestFn;
+    private getExtendedApolloServerClass;
+    private getPatchedApolloServerClass;
+    private getResolverPatch;
+}

package/instrumentation/libraries/graphql/mocks/GraphqlClientMock.d.ts

@@ -0,0 +1,41 @@
+import type { GraphQLClientRequestHeaders } from 'graphql-request/src/types';
+import type { JsonSchemaWithoutLangType, JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+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 = {
+    url: string;
+    query: string | Record<string, unknown>;
+    variables: undefined | Record<string, unknown>;
+    headers: GraphQLClientRequestHeaders;
+    clientDefaultHeaders?: Record<string, string>;
+};
+type ProcessedInput = Omit<ReadableInput, 'headers' | 'url'>;
+type ProcessedInputSchema = JsonSchemaWithoutValues;
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+type InputValueWithoutLangType = JsonSchemaWithoutLangType;
+type OutputValueWithoutLangType = JsonSchemaWithoutLangType;
+export default class GraphqlClientMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    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;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(realOutput: RealOutput): OutputValueWithoutLangType;
+}
+export {};

package/instrumentation/libraries/graphql/mocks/GraphqlServerRequestMock.d.ts

@@ -0,0 +1,30 @@
+import { type GQLMeta, type GQLProcessedInputSchema, type GQLProcessedInputType, type GQLReadableInputType, type GQLReqValueWithoutLangType, type GQLResType, type GQLResValueWithoutLangType } from '../../../../../../utils/types';
+import { OutputStatus } from '../../../../../../utils/prismaSchema/hytDb/generatedClient';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtServerMockAbstract } from '../../../core/baseClasses/HtServerMockAbstract';
+export declare class GraphqlServerRequestMock extends HtServerMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ProcessedOutputSchema, InputValueWithoutLangType, OutputValueWithoutLangType> {
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateInputValueWithoutLangType(): InputValueWithoutLangType;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+    generateOutputValueWithoutLangType(): OutputValueWithoutLangType;
+    generateOutputStatus(realOutput: GQLResType): OutputStatus;
+}
+export type ReadableInput = GQLReadableInputType;
+export type ProcessedInput = GQLProcessedInputType;
+export type ProcessedInputSchema = GQLProcessedInputSchema;
+export type InputValueWithoutLangType = GQLReqValueWithoutLangType;
+export type InputMeta = GQLMeta;
+export type RealOutput = GQLResType;
+export type ReadableOutput = GQLResType;
+export type ProcessedOutputSchema = {
+    is_ok: string;
+} | {
+    is_error: string;
+};
+export type OutputValueWithoutLangType = GQLResValueWithoutLangType;
+export type OutputMeta = Record<string, unknown>;

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

@@ -0,0 +1,64 @@
+import type { DocumentNode } from 'graphql';
+import type { BatchRequestDocument, BatchRequestsOptions, GraphQLClientRequestHeaders, RawRequestExtendedOptions, RequestDocument, RequestOptions, Variables, VariablesAndRequestHeadersArgs } from 'graphql-request/src/types';
+import type { ExecutionArgs } from 'graphql/execution/execute';
+import type { OperationDefinitionNode, SelectionNode } from 'graphql/language/ast';
+import type { AnyFunction } from '../../../../../utils/types';
+import type { HtGraphqlInstrumentation } from './instrumentation';
+import type { GraphqlServerRequestMock } from './mocks/GraphqlServerRequestMock';
+export interface DocumentTypeDecoration<TResult, TVariables> {
+    /**
+     * This type is used to ensure that the variables you pass in to the query are assignable to Variables
+     * and that the Result is assignable to whatever you pass your result to. The method is never actually
+     * implemented, but the type is valid because we list it as optional
+     */
+    __apiType?: (variables: TVariables) => TResult;
+}
+export interface TypedDocumentNode<TResult = {
+    [key: string]: unknown;
+}, TVariables = {
+    [key: string]: unknown;
+}> extends DocumentNode, DocumentTypeDecoration<TResult, TVariables> {
+}
+export type RawRequestArgs<V extends Variables> = [
+    options: RawRequestExtendedOptions<V>,
+    query?: string,
+    ...variablesAndRequestHeaders: VariablesAndRequestHeadersArgs<V>
+] | [
+    url: string,
+    query?: string,
+    ...variablesAndRequestHeaders: VariablesAndRequestHeadersArgs<V>
+];
+interface Result<Data extends object = object> {
+    data: Data;
+}
+export type BatchResult = [Result, ...Result[]];
+export declare const getFragments: (payload: Record<string, unknown>) => {}[];
+export declare const getSelectionSetQuery: (payload: SelectionNode) => string;
+export declare const getOperationDefinition: (payload: ExecutionArgs) => OperationDefinitionNode;
+export declare const getCurrentSelection: (payload: ExecutionArgs, topLevelResolverName: string) => SelectionNode;
+export declare const getCurrentResolvers: (payload: Record<string, unknown>, topLevelResolverName: string) => string[];
+export declare const getFragmentsUsed: (currentSelection: SelectionNode) => Set<string>;
+export declare const getInnerUsedFragments: (payload: ExecutionArgs, fragmentsUsed: Set<string>) => Set<any>;
+export declare const getVariablesUsed: (currentSelection: SelectionNode) => Set<string>;
+export declare const getDirectivesUsed: (currentSelection: SelectionNode) => Set<string>;
+export declare const buildGraphqlReqQuery: (payload: ExecutionArgs, topLevelResolverName: string, selectionSetString: string, fragmentQueries: Record<string, string>[]) => string;
+export declare const buildGraphqlReqVars: (payload: ExecutionArgs, topLevelResolverName: string) => Record<string, unknown>;
+export declare const parseRequestArgs: <T, V extends Variables = Variables>(documentOrOptions: RequestDocument | TypedDocumentNode<T, V> | RequestOptions<V>, variables?: Record<string, unknown>, requestHeaders?: GraphQLClientRequestHeaders) => string | DocumentNode | RequestOptions<V> | {
+    document: RequestDocument;
+    variables: Record<string, unknown>;
+    requestHeaders: GraphQLClientRequestHeaders;
+    signal: any;
+};
+export declare const parseRawRequestArgs: (queryOrOptions: string | Record<string, unknown>, variables?: string, requestHeaders?: GraphQLClientRequestHeaders) => string | Record<string, unknown>;
+export declare const parseBatchRequestArgs: (documentsOrOptions: BatchRequestDocument[] | BatchRequestsOptions, requestHeaders: GraphQLClientRequestHeaders) => BatchRequestsOptions<Variables>;
+export declare const recordGraphqlIncomingReq: (finalResult: unknown, headers: Record<string, string>, htExecuteOperationId: string, _args: Record<string, unknown>[], _plugin: HtGraphqlInstrumentation, httpHtRequestId: string) => unknown;
+export declare const replayGraphqlIncomingReq: (gqlResponseObj: unknown, graphqlReqId: string, mock: GraphqlServerRequestMock) => unknown;
+export declare const sendPostHogEvent: (event: string, result: Record<string, unknown>, kind: unknown) => void;
+export declare function patchResolverforEachField(schema: any, fn: AnyFunction): void;
+export declare const getSelectionSetName: (path: Record<string, unknown>) => string;
+export declare const getfieldPath: (path: Record<string, unknown>) => string[];
+export declare const getCurrentSelectionSetFromOpDefn: (operationInfo: Record<string, unknown>, selectionSetName: string) => SelectionNode;
+export declare const insertHeader: (requestHeaders: GraphQLClientRequestHeaders, key: string, value: string) => GraphQLClientRequestHeaders;
+export declare const addParentRequestIdHeader: (requestHeaders?: GraphQLClientRequestHeaders) => GraphQLClientRequestHeaders;
+export declare const addSamplingModeHeader: (requestHeaders?: GraphQLClientRequestHeaders) => GraphQLClientRequestHeaders;
+export {};

package/instrumentation/libraries/grpc/instrumentation.d.ts

@@ -0,0 +1,28 @@
+import type * as GrpcModule from '@grpc/grpc-js';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtGrpcInstrumentation extends HtInstrumentationBase {
+    private readonly initialResponseMetadataMap;
+    private Metadata;
+    private MetadataOfDeprGrpc;
+    private makeUnaryRequestOfDeprGrpc;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<typeof GrpcModule>[];
+    private checkOptionalUnaryResponseArguments;
+    private getInputParameters;
+    private _getMakeUnaryRequestPatchFn;
+    private _getRegisterPatchFn;
+    private _getHandlerPatchFn;
+    private _getCallbackPatchFn;
+    private _getSendMetadataPatchFn;
+    private _storeReplayResult;
+    private _serverErrorToStatus;
+    private _getWaitForReadyPatchFn;
+    private _getClosePatchFn;
+    private _getGetChannelPatchFn;
+    private _getGetDeadlinePatchFn;
+    private _getRequestMethodPatchFn;
+    private _getMakeClientConstructorPatchFn;
+}

package/instrumentation/libraries/grpc/mocks/GetDeadlineMock.d.ts

@@ -0,0 +1,29 @@
+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 = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    deadlineIsoString: string;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = EmptyObject;
+export declare class GetDeadlineMock 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(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export {};