@hypertestco/node-sdk-v3 0.0.1-8

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

@@ -0,0 +1,10 @@
+import { type Span } from '@opentelemetry/api';
+import type { InstrumentationMockObj } from '../../../../../utils/types';
+export declare function isObjectWithTextString(it: unknown): it is ObjectWithText;
+export type ObjectWithText = {
+    [k: string]: unknown;
+    text: string;
+};
+export declare function getCurrTraceId(): string;
+export declare function getPatchedQueryCbForTestMode(originalCb: any): () => void;
+export declare function patchedCallbackHelper(mock: InstrumentationMockObj, span: Span, originalCallback: any, plugin: any): (...cbArgs: unknown[]) => any;

package/instrumentation/libraries/couchbase/instrumentation.d.ts

@@ -0,0 +1,37 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtCouchbaseInstrumentation extends HtInstrumentationBase {
+    _HtClusterPrototype: unknown;
+    _HtBucketImplPrototype: unknown;
+    _HtBucketManagerPrototype: unknown;
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private patchErrOnlyCallbackFns;
+    private patchCallbackFns;
+    private bucketMutateInBuilderPatch;
+    private bucketLookupInBuilderPatch;
+    private bucketBuilderExecutepatch;
+    private getOpenBucketPatch;
+    private bucketGetPatch;
+    private bucketGetMultiPatch;
+    private bucketTouchPatch;
+    private bucketUpsertPatch;
+    private bucketAppendPatch;
+    private bucketCounterPatch;
+    private bucketUnlockPatch;
+    private bucketQueryPatch;
+    private bucketGetManagerpatch;
+    private getClusterManagerpatch;
+    private getClusterUsersPatch;
+    private removeClusterUserPatch;
+    private upsertClusterUserPatch;
+    private createBucketPatch;
+    private getDesignDocumentsPatch;
+    private insertDesignDocumentPatch;
+    private getDesignDocumentPatch;
+    private createIndexPatch;
+    private createPrimaryIndexPatch;
+    private dropIndexPatch;
+    private watchIndexesPatch;
+    private bucketPingPatch;
+}

package/instrumentation/libraries/couchbase/mocks/CouchbaseMock.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 = Record<string, Jsonable>;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class CouchbaseMock 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;
+    setOutput(realOutput: Jsonable, emptyDefaultPathMeta?: {}): void;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export {};

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

@@ -0,0 +1 @@
+export declare function removeCas(options: unknown): unknown;

package/instrumentation/libraries/date/helpers/dateInstrumentationConfigHelpers.d.ts

@@ -0,0 +1,49 @@
+import type { HttpMethodEnum } from '../../../../../../utils/types';
+type DateInstrumentationConfig = {
+    whitelistedRequests: {
+        http?: {
+            path: string | RegExp;
+            method?: string;
+        }[];
+        grpc?: {
+            service: string;
+            method: string;
+        }[];
+        kafka?: {
+            groupId: string;
+            topic: string;
+        }[];
+        amqp?: {
+            queue: string;
+        }[];
+        graphql?: {
+            selectionSet: string;
+        }[];
+        manualRequest?: {
+            name: string;
+        }[];
+    };
+};
+export declare function setDateInstrumentationConfig({ whitelistedRequests: { http, grpc, kafka, amqp, graphql, manualRequest, }, }: DateInstrumentationConfig): void;
+export declare function shouldInstrumentDateInHttpRequest({ incomingRequestPath, incomingRequestMethod, }: {
+    incomingRequestPath: string;
+    incomingRequestMethod: HttpMethodEnum;
+}): boolean;
+export declare function shouldInstrumentDateInGrpcRequest({ incomingRequestService, incomingRequestMethod, }: {
+    incomingRequestService: string;
+    incomingRequestMethod: string;
+}): boolean;
+export declare function shouldInstrumentDateInKafkaRequest({ incomingRequestGroupId, incomingRequestTopic, }: {
+    incomingRequestGroupId: string;
+    incomingRequestTopic: string;
+}): boolean;
+export declare function shouldInstrumentDateInAmqpRequest({ incomingRequestQueue, }: {
+    incomingRequestQueue: string;
+}): boolean;
+export declare function shouldInstrumentDateInGraphqlRequest({ incomingRequestSelectionSet, }: {
+    incomingRequestSelectionSet: string;
+}): boolean;
+export declare function shouldInstrumentDateInManualRequest({ incomingRequestName, }: {
+    incomingRequestName: string;
+}): boolean;
+export {};

package/instrumentation/libraries/date/instrumentation.d.ts

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

package/instrumentation/libraries/elastic-search/instrumentation.d.ts

@@ -0,0 +1,20 @@
+import type * as elasticV7Types from 'elasticsearchv7';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+type TransportType = typeof elasticV7Types.Transport & {
+    prototype: {
+        productCheck: () => void;
+        request: () => unknown;
+    };
+};
+export declare class HtElasticSearchInstrumentation extends HtInstrumentationBase {
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<TransportType>[];
+    private _getInfoLikePatch;
+    private _getProductCheckStaticPatch;
+    private _getUndiciRequestPatch;
+    private _getEsV7TransportRequestPatch;
+}
+export {};

package/instrumentation/libraries/elastic-search/mocks/EsInfoMock.d.ts

@@ -0,0 +1,32 @@
+import type { RequestEvent } from 'elasticsearchv7';
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { 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;
+export type ReadableInput = {
+    params?: JsonableMap;
+    options?: JsonableMap;
+};
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = RequestEvent;
+type OutputMeta = EmptyObject;
+type ReadableOutput = Pick<RealOutput, 'body' | 'statusCode'>;
+type ProcessedOutputSchema = EmptyObject;
+export declare class EsInfoMock 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(_realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/elastic-search/mocks/EsTransportV7RequestMock.d.ts

@@ -0,0 +1,51 @@
+import type { JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { JsonableArray, 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;
+export type ReadableInput = {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body: string | null | JsonableMap | JsonableArray;
+};
+type ProcessedInput = {
+    method: string;
+    path: string;
+    query: Record<string, string>;
+    body: string | null | JsonableMap | JsonableArray;
+};
+type ProcessedInputSchema = {
+    method: string;
+    path: string;
+    query: JsonSchemaWithoutValues;
+    body: JsonSchemaWithoutValues;
+};
+type RealOutput = {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string | null | JsonableMap | JsonableArray;
+};
+type OutputMeta = {
+    bodyType: string;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = {
+    statusCode: number;
+    body: JsonSchemaWithoutValues;
+};
+export declare class EsTransportV7RequestMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/elastic-search/mocks/EsTransportV8RequestMock.d.ts

@@ -0,0 +1,51 @@
+import type { JsonSchemaWithoutValues } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { JsonableArray, 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;
+export type ReadableInput = {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body: string | null | JsonableMap | JsonableArray;
+};
+type ProcessedInput = {
+    method: string;
+    path: string;
+    query: Record<string, string>;
+    body: string | null | JsonableMap | JsonableArray;
+};
+type ProcessedInputSchema = {
+    method: string;
+    path: string;
+    query: JsonSchemaWithoutValues;
+    body: JsonSchemaWithoutValues;
+};
+type RealOutput = {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string | null | JsonableMap | JsonableArray;
+};
+type OutputMeta = {
+    bodyType: string;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = {
+    statusCode: number;
+    body: JsonSchemaWithoutValues;
+};
+export declare class EsTransportV8RequestMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/elastic-search/utils.d.ts

@@ -0,0 +1,13 @@
+import type elasticTransportV8ConnectionType from '@elastic/transport/lib/connection/UndiciConnection';
+import type { AnyFunction } from '../../../../../utils/types';
+import type { JsonableArray, JsonableMap } from '../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationMockAbstract } from '../../core/baseClasses/HtInstrumentationMockAbstract';
+export declare function normalizeArguments<Params, Options, Callback>(params: Params, options: Options, callback: Callback): {
+    params: Params;
+    options: Options;
+    callback: Callback;
+};
+export declare function getPatchedCbForTestMode<OriginalFunction>(originalCb: OriginalFunction & AnyFunction, mockReplayValue: ReturnType<HtInstrumentationMockAbstract['getReplayValue']>): () => void;
+type OriginalBody = Parameters<elasticTransportV8ConnectionType['request']>[0]['body'];
+export declare function getParsedBodyFromOriginalBody(originalBody: OriginalBody): Promise<string | JsonableArray | JsonableMap>;
+export {};

package/instrumentation/libraries/etcd3/helpers/processBuffers.d.ts

@@ -0,0 +1,4 @@
+export declare function stringifyBuffer(buffer: Buffer): {
+    value: string;
+    encoding: HtRawEncoding;
+};

package/instrumentation/libraries/etcd3/htFakeClasses/HtFakeCampaign.d.ts

@@ -0,0 +1,7 @@
+import { EventEmitter } from 'events';
+export declare class HtFakeCampaign extends EventEmitter {
+    wait(): Promise<this>;
+    proclaim(): Promise<void>;
+    getCampaignKey(): 'HYPERTEST_NOOP_ELECTION';
+    resign(): Promise<void>;
+}

package/instrumentation/libraries/etcd3/htFakeClasses/HtFakeElection.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'events';
+import { HtFakeCampaign } from './HtFakeCampaign';
+import { HtFakeElectionObserver } from './HtFakeElectionObserver';
+export declare class HtFakeElection extends EventEmitter {
+    readonly name: string;
+    /**
+     * Prefix used in the namespace for election-based operations.
+     */
+    static readonly prefix = "election";
+    campaign(): HtFakeCampaign;
+    leader(): Promise<undefined>;
+    observe(): Promise<HtFakeElectionObserver>;
+}

package/instrumentation/libraries/etcd3/htFakeClasses/HtFakeElectionObserver.d.ts

@@ -0,0 +1,6 @@
+import { EventEmitter } from 'events';
+export declare class HtFakeElectionObserver extends EventEmitter {
+    get hasLeader(): boolean;
+    cancel(): Promise<void>;
+    leader(): undefined;
+}

package/instrumentation/libraries/etcd3/htFakeClasses/HtFakeWatcher.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'events';
+import type { IWatchCreateRequest } from 'etcd3';
+import type { NSApplicator } from 'etcd3/lib/util';
+import type { WatchManager } from 'etcd3/lib/watch';
+export declare class HtFakeWatcher extends EventEmitter {
+    /**
+     * id is the watcher's ID in etcd. This is `null` initially and during
+     * reconnections, only populated while the watcher is idle.
+     */
+    readonly id: string | null;
+    readonly request: IWatchCreateRequest;
+    constructor(_manager: WatchManager, _namespace: NSApplicator, request: IWatchCreateRequest);
+    lastRevision(): number | null;
+    cancel(): Promise<void>;
+}

package/instrumentation/libraries/etcd3/instrumentation.d.ts

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

package/instrumentation/libraries/etcd3/modules/builders/comparatorBuilder/Etcd3ComparatorBuilderMock.d.ts

@@ -0,0 +1,107 @@
+import type { ComparatorBuilder, ITxnResponse } from 'etcd3';
+import type { JsonSchemaWithoutValues } from '../../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../../instrumentation';
+import { type InputMeta as DeleteInputMeta, type OutputMeta as DeleteOutputMeta, type ProcessedInput as DeleteProcessedInput, type ProcessedInputSchema as DeleteProcessedInputSchema, type ReadableInput as DeleteReadableInput, type RealOutput as DeleteRealOutput } from '../deleteBuilder/Etcd3DeleteBuilderExecMock';
+import { type InputMeta as GetAllInputMeta, type OutputMeta as GetAllOutputMeta, type ProcessedInput as GetAllProcessedInput, type ProcessedInputSchema as GetAllProcessedInputSchema, type ReadableInput as GetAllReadableInput, type RealOutput as GetAllRealOutput } from '../multiRangeBuilder/Etcd3MultiRangeBuilderExecMock';
+import { type InputMeta as PutInputMeta, type OutputMeta as PutOutputMeta, type ProcessedInput as PutProcessedInput, type ProcessedInputSchema as PutProcessedInputSchema, type ReadableInput as PutReadableInput, type RealOutput as PutRealOutput } from '../putBuilder/Etcd3PutBuilderExecMock';
+import { type InputMeta as GetInputMeta, type OutputMeta as GetOutputMeta, type ProcessedInput as GetProcessedInput, type ProcessedInputSchema as GetProcessedInputSchema, type ReadableInput as GetReadableInput, type RealOutput as GetRealOutput } from '../singleRangeBuilder/Etcd3SingleRangeBuilderExecMock';
+type CommonInputMeta = PutInputMeta | DeleteInputMeta | GetAllInputMeta | GetInputMeta;
+type InputMeta = {
+    successCaseBuffers: CommonInputMeta[];
+    failureCaseBuffers: CommonInputMeta[];
+};
+type ReadableRequest = {
+    method: 'get';
+    request: GetReadableInput;
+} | {
+    method: 'put';
+    request: PutReadableInput;
+} | {
+    method: 'delete';
+    request: DeleteReadableInput;
+} | {
+    method: 'getAll';
+    request: GetAllReadableInput;
+};
+type ReadableInput = {
+    namespace: string;
+    compare: {
+        key: string;
+        comparator: '==' | '===' | '>' | '<' | '!=' | '!==';
+        column: 'Version' | 'Create' | 'Mod' | 'Value' | 'Lease';
+        value: string | number;
+    }[];
+    success: ReadableRequest[];
+    failure: ReadableRequest[];
+};
+type ProcessedInput = {
+    namespace: string;
+    compare: {
+        key: string;
+        comparator: '==' | '===' | '>' | '<' | '!=' | '!==';
+        column: 'Version' | 'Create' | 'Mod' | 'Value' | 'Lease';
+        value: string | number;
+    }[];
+    success: {
+        method: 'get' | 'put' | 'delete' | 'getAll';
+        request: GetProcessedInput | PutProcessedInput | DeleteProcessedInput | GetAllProcessedInput;
+    }[];
+    failure: {
+        method: 'get' | 'put' | 'delete' | 'getAll';
+        request: GetProcessedInput | PutProcessedInput | DeleteProcessedInput | GetAllProcessedInput;
+    }[];
+};
+type ProcessedInputSchema = {
+    namespace: string;
+    success: {
+        method: 'get' | 'put' | 'delete' | 'getAll';
+        request: GetProcessedInputSchema | PutProcessedInputSchema | DeleteProcessedInputSchema | GetAllProcessedInputSchema;
+    }[];
+    failure: {
+        method: 'get' | 'put' | 'delete' | 'getAll';
+        request: GetProcessedInputSchema | PutProcessedInputSchema | DeleteProcessedInputSchema | GetAllProcessedInputSchema;
+    }[];
+};
+type RealOutput = {
+    header: ITxnResponse['header'];
+    succeeded: ITxnResponse['succeeded'];
+    responses: {
+        method: 'get' | 'put' | 'delete' | 'getAll';
+        response: GetRealOutput | PutRealOutput | DeleteRealOutput | GetAllRealOutput;
+    }[];
+};
+type ReadableOutput = Pick<RealOutput, 'succeeded'>;
+type ProcessedOutputSchema = {
+    responses: ({
+        method: 'put';
+    } | {
+        method: 'delete';
+    } | {
+        method: 'get';
+        response: JsonSchemaWithoutValues;
+    } | {
+        method: 'getAll';
+        response: JsonSchemaWithoutValues;
+    })[];
+};
+type OutputMeta = {
+    responseBuffers: (GetOutputMeta | PutOutputMeta | DeleteOutputMeta | GetAllOutputMeta)[];
+};
+export declare class Etcd3ComparatorBuilderMock 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(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export declare function patchAnd(): (originalFn: ComparatorBuilder["and"]) => (this: ComparatorBuilder, key: string | Buffer, column: "Version" | "Create" | "Mod" | "Value" | "Lease", cmp: "==" | "===" | ">" | "<" | "!=" | "!==", value: string | number | Buffer) => ReturnType<ComparatorBuilder["and"]>;
+export declare function patchCommit(plugin: HtEtcd3Instrumentation): (originalFn: ComparatorBuilder["commit"]) => (this: ComparatorBuilder) => ReturnType<ComparatorBuilder["commit"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/builders/deleteBuilder/Etcd3DeleteBuilderExecMock.d.ts

@@ -0,0 +1,77 @@
+import type { DeleteBuilder, IDeleteRangeRequest, IDeleteRangeResponse, IKeyValue } from 'etcd3';
+import type { Jsonable } from '../../../../../../../../utils/types/jsonableTypes';
+import { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../../instrumentation';
+type EmptyObject = Record<string, never>;
+export type ReadableInput<hasNamespace extends boolean = false> = {
+    namespace: hasNamespace extends true ? string : never;
+    lexicographicRange: {
+        start: string;
+        end?: string;
+    };
+    options: Pick<IDeleteRangeRequest, 'prev_kv'>;
+};
+export type InputMeta<hasNamespace extends boolean = false> = {
+    lexicographicRangeBuffers: {
+        start: {
+            encoding: HtRawEncoding;
+            value: string;
+        };
+        end?: {
+            encoding: HtRawEncoding;
+            value: string;
+        };
+    };
+    namespaceBuffer: hasNamespace extends true ? {
+        encoding: HtRawEncoding;
+        value: string;
+    } : never;
+};
+export type ProcessedInput<hasNamespace extends boolean = false> = Pick<ReadableInput<hasNamespace>, 'lexicographicRange' | 'namespace'>;
+export type ProcessedInputSchema<hasNamespace extends boolean = false> = Partial<ProcessedInput<hasNamespace>>;
+type TreatedKeyValue = Omit<IKeyValue, 'key' | 'value'> & {
+    key: string;
+    value: Jsonable;
+};
+export type RealOutput = Omit<IDeleteRangeResponse, 'prev_kvs'> & {
+    prev_kvs: TreatedKeyValue[];
+};
+type ReadableOutput = Pick<RealOutput, 'deleted'>;
+type ProcessedOutputSchema = EmptyObject;
+export type OutputMeta = {
+    keyBuffers: Array<{
+        encoding: HtRawEncoding;
+        value: string;
+    }>;
+    valueBuffers: Array<{
+        encoding: HtRawEncoding;
+        value: string;
+    }>;
+};
+export declare function generateProcessedInputForDelete<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInput<hasNamespace>;
+export declare function generateProcessedInputSchemaForDelete<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInputSchema<hasNamespace>;
+export declare class Etcd3DeleteBuilderExecMock extends HtInstrumentationMockAbstract<InputMeta<true>, ReadableInput<true>, ProcessedInput<true>, ProcessedInputSchema<true>, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtEtcd3Instrumentation;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput<true>;
+    generateProcessedInputSchema(): ProcessedInputSchema<true>;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function sanitizeOutputForDelete(response: IDeleteRangeResponse): {
+    realOutput: RealOutput;
+    outputMeta: OutputMeta;
+};
+export declare function sanitizeInputForDelete<T extends Buffer | undefined>(request: IDeleteRangeRequest, namespace?: T): {
+    readableInput: ReadableInput<T extends Buffer ? true : false>;
+    inputMeta: InputMeta<T extends Buffer ? true : false>;
+};
+export declare function deSanitizeOutputForDelete(output: RealOutput, outputMeta: OutputMeta): IDeleteRangeResponse;
+export declare function patchExec(plugin: HtEtcd3Instrumentation): (originalFn: DeleteBuilder["exec"]) => (this: DeleteBuilder) => ReturnType<DeleteBuilder["exec"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/builders/multiRangeBuilder/Etcd3MultiRangeBuilderCountMock.d.ts

@@ -0,0 +1,56 @@
+import type { IRangeRequest, MultiRangeBuilder } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../../instrumentation';
+type EmptyObject = Record<string, never>;
+type InputMeta = {
+    lexicographicRangeBuffers: {
+        start: {
+            encoding: HtRawEncoding;
+            value: string;
+        };
+        end: {
+            encoding: HtRawEncoding;
+            value: string;
+        };
+    };
+    namespaceBuffer: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+};
+type ReadableInput = {
+    namespace: string;
+    lexicographicRange: {
+        start: string;
+        end: string;
+    };
+    options: Pick<IRangeRequest, 'revision' | 'max_create_revision' | 'max_mod_revision' | 'min_create_revision' | 'min_mod_revision' | 'serializable' | 'limit' | 'sort_target' | 'sort_order'>;
+};
+type ProcessedInput = Pick<ReadableInput, 'lexicographicRange' | 'namespace'> & {
+    revision: boolean;
+    max_create_revision: boolean;
+    max_mod_revision: boolean;
+    min_create_revision: boolean;
+    min_mod_revision: boolean;
+};
+type ProcessedInputSchema = Partial<ProcessedInput>;
+type RealOutput = number;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = Record<string, never>;
+export declare class Etcd3MultiRangeBuilderCountMock 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(): ProcessedOutputSchema;
+}
+export declare function patchCount(plugin: HtEtcd3Instrumentation): (originalFn: MultiRangeBuilder["count"]) => (this: MultiRangeBuilder) => ReturnType<MultiRangeBuilder["count"]>;
+export {};