@hypertestco/node-sdk-v3 0.0.1-8

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

@@ -0,0 +1,83 @@
+import type { IKeyValue, IRangeRequest, IRangeResponse, MultiRangeBuilder } from 'etcd3';
+import type { JsonSchemaWithoutValues } from '../../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../../../utils/types/jsonableTypes';
+import { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../../instrumentation';
+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 ReadableInput<hasNamespace extends boolean = false> = {
+    namespace: hasNamespace extends true ? string : never;
+    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'>;
+};
+export type ProcessedInput<hasNamespace extends boolean = false> = Pick<ReadableInput<hasNamespace>, 'lexicographicRange' | 'namespace'> & {
+    revision: boolean;
+    max_create_revision: boolean;
+    max_mod_revision: boolean;
+    min_create_revision: boolean;
+    min_mod_revision: boolean;
+};
+export type ProcessedInputSchema<hasNamespace extends boolean = false> = Partial<ProcessedInput<hasNamespace>>;
+type TreatedKeyValue = Omit<IKeyValue, 'key' | 'value'> & {
+    key: string;
+    value: Jsonable;
+};
+export type RealOutput = Pick<IRangeResponse, 'header' | 'count' | 'more'> & {
+    kvs: TreatedKeyValue[];
+};
+type ReadableOutput = Pick<TreatedKeyValue, 'key' | 'value'>[];
+export type OutputMeta = {
+    keyBuffers: Array<{
+        encoding: HtRawEncoding;
+        value: string;
+    }>;
+    valueBuffers: Array<{
+        encoding: HtRawEncoding;
+        value: string;
+    }>;
+};
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare function generateProcessedInputForGetAll<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInput<hasNamespace>;
+export declare function generateProcessedInputSchemaForGetAll<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInputSchema<hasNamespace>;
+export declare class Etcd3MultiRangeBuilderExecMock 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 sanitizeOutputForGetAll(response: IRangeResponse): {
+    realOutput: RealOutput;
+    outputMeta: OutputMeta;
+};
+export declare function sanitizeInputForGetAll<T extends Buffer | undefined>(request: IRangeRequest, namespace?: T): {
+    readableInput: ReadableInput<T extends Buffer ? true : false>;
+    inputMeta: InputMeta<T extends Buffer ? true : false>;
+};
+export declare function deSanitizeOutputForGetAll(output: RealOutput, outputMeta: OutputMeta): IRangeResponse;
+export declare function patchExec(plugin: HtEtcd3Instrumentation): (originalFn: MultiRangeBuilder["exec"]) => (this: MultiRangeBuilder) => ReturnType<MultiRangeBuilder["exec"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/builders/putBuilder/Etcd3PutBuilderExecMock.d.ts

@@ -0,0 +1,74 @@
+import type { IKeyValue, IPutRequest, IPutResponse, PutBuilder } 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 InputMeta<hasNamespace extends boolean = false> = {
+    keyBuffer: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+    valueBuffer?: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+    namespaceBuffer: hasNamespace extends true ? {
+        encoding: HtRawEncoding;
+        value: string;
+    } : never;
+};
+export type ReadableInput<hasNamespace extends boolean = false> = {
+    namespace: hasNamespace extends true ? string : never;
+    key: string;
+    value?: Jsonable;
+    options: Pick<IPutRequest, 'ignore_lease' | 'ignore_value' | 'lease' | 'prev_kv'>;
+};
+export type ProcessedInput<hasNamespace extends boolean = false> = Pick<ReadableInput<hasNamespace>, 'key' | 'value' | 'namespace'>;
+export type ProcessedInputSchema<hasNamespace extends boolean = false> = Partial<Pick<ProcessedInput<hasNamespace>, 'key' | 'namespace'>>;
+type TreatedKeyValue = Omit<IKeyValue, 'key' | 'value'> & {
+    key: string;
+    value: Jsonable;
+};
+export type RealOutput = {
+    prev_kv?: TreatedKeyValue;
+    header?: IPutResponse['header'];
+};
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+export type OutputMeta = {
+    keyBuffer?: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+    valueBuffer?: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+};
+export declare function generateProcessedInputForPut<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInput<hasNamespace>;
+export declare function generateProcessedInputSchemaForPut<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInputSchema<hasNamespace>;
+export declare class Etcd3PutBuilderExecMock 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(): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export declare function sanitizeOutputForPut(response: IPutResponse): {
+    realOutput: RealOutput;
+    outputMeta: OutputMeta;
+};
+export declare function sanitizeInputForPut<T extends Buffer | null>(request: IPutRequest, namespace?: T): {
+    readableInput: ReadableInput<T extends Buffer ? true : false>;
+    inputMeta: InputMeta<T extends Buffer ? true : false>;
+};
+export declare function deSanitizeOutputForPut(output: RealOutput, outputMeta: OutputMeta): IPutResponse;
+export declare function patchExec(plugin: HtEtcd3Instrumentation): (originalFn: PutBuilder["exec"]) => (this: PutBuilder) => ReturnType<PutBuilder["exec"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/builders/singleRangeBuilder/Etcd3SingleRangeBuilderExecMock.d.ts

@@ -0,0 +1,78 @@
+import type { IKeyValue, IRangeRequest, IRangeResponse, SingleRangeBuilder } from 'etcd3';
+import type { JsonSchemaWithoutValues } from '../../../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../../../../../../utils/types/jsonableTypes';
+import { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../../instrumentation';
+export type InputMeta<hasNamespace extends boolean = false> = {
+    keyBuffer: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+    namespaceBuffer: hasNamespace extends true ? {
+        encoding: HtRawEncoding;
+        value: string;
+    } : never;
+};
+export type ReadableInput<hasNamespace extends boolean = false> = {
+    namespace: hasNamespace extends true ? string : never;
+    key: string;
+    options: Pick<IRangeRequest, 'revision' | 'max_create_revision' | 'max_mod_revision' | 'min_create_revision' | 'min_mod_revision' | 'serializable'>;
+};
+export type ProcessedInput<hasNamespace extends boolean = false> = {
+    namespace: hasNamespace extends true ? string : never;
+    key: string;
+    revision: boolean;
+    max_create_revision: boolean;
+    max_mod_revision: boolean;
+    min_create_revision: boolean;
+    min_mod_revision: boolean;
+};
+type TreatedKeyValue = Omit<IKeyValue, 'key' | 'value'> & {
+    key: string;
+    value: Jsonable;
+};
+export type ProcessedInputSchema<hasNamespace extends boolean = false> = Partial<ProcessedInput<hasNamespace>>;
+export type RealOutput = Pick<IRangeResponse, 'header' | 'count' | 'more'> & {
+    kvs: TreatedKeyValue[];
+};
+type ReadableOutput = {
+    value: Jsonable | null;
+};
+export type OutputMeta = {
+    keyBuffer: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+    valueBuffer?: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+};
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare function generateProcessedInputForGet<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInput<hasNamespace>;
+export declare function generateProcessedInputSchemaForGet<hasNamespace extends boolean = false>(readableInput: ReadableInput<hasNamespace>): ProcessedInputSchema<hasNamespace>;
+export declare class Etcd3SingleRangeBuilderExecMock 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 sanitizeOutputForGet(response: IRangeResponse): {
+    realOutput: RealOutput;
+    outputMeta: OutputMeta;
+};
+export declare function sanitizeInputForGet<T extends Buffer | undefined>(request: IRangeRequest, namespace?: T): {
+    readableInput: ReadableInput<T extends Buffer ? true : false>;
+    inputMeta: InputMeta<T extends Buffer ? true : false>;
+};
+export declare function deSanitizeOutputForGet(output: RealOutput, outputMeta: OutputMeta): IRangeResponse;
+export declare function patchExec(plugin: HtEtcd3Instrumentation): (originalFn: SingleRangeBuilder["exec"]) => (this: SingleRangeBuilder) => ReturnType<SingleRangeBuilder["exec"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/builders/singleRangeBuilder/Etcd3SingleRangeBuilderExistsMock.d.ts

@@ -0,0 +1,49 @@
+import type { IRangeRequest, SingleRangeBuilder } from 'etcd3';
+import { HtInstrumentationMockAbstract } from '../../../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { FunctionTypeEnum } from '../../../../../core/types';
+import type { HtEtcd3Instrumentation } from '../../../instrumentation';
+type InputMeta = {
+    keyBuffer: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+    namespaceBuffer: {
+        encoding: HtRawEncoding;
+        value: string;
+    };
+};
+type ReadableInput = {
+    namespace: string;
+    key: string;
+    options: Pick<IRangeRequest, 'revision' | 'max_create_revision' | 'max_mod_revision' | 'min_create_revision' | 'min_mod_revision' | 'serializable'>;
+};
+type ProcessedInput = {
+    namespace: string;
+    key: string;
+    revision: boolean;
+    max_create_revision: boolean;
+    max_mod_revision: boolean;
+    min_create_revision: boolean;
+    min_mod_revision: boolean;
+};
+type ProcessedInputSchema = Partial<ProcessedInput>;
+type RealOutput = boolean;
+type ReadableOutput = RealOutput;
+type EmptyObject = Record<string, never>;
+type OutputMeta = EmptyObject;
+type ProcessedOutputSchema = RealOutput;
+export declare class Etcd3SingleRangeBuilderExistsMock 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 patchExists(plugin: HtEtcd3Instrumentation): (originalFn: SingleRangeBuilder["exists"]) => (this: SingleRangeBuilder) => ReturnType<SingleRangeBuilder["exists"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/client/Etcd3ClientCloseMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/client/Etcd3ClientElectionMock.d.ts

@@ -0,0 +1,3 @@
+import type { Etcd3 as Etcd3Client } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare function patchElection(plugin: HtEtcd3Instrumentation): (originalFn: Etcd3Client["election"]) => (this: Etcd3Client, name: string, ttl?: number) => ReturnType<Etcd3Client["election"]>;

package/instrumentation/libraries/etcd3/modules/client/Etcd3ClientGetRolesMock.d.ts

@@ -0,0 +1,30 @@
+import type { Etcd3, 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 = EmptyObject;
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = {
+    roleNames: string[];
+};
+type RealOutput = ReadableOutput;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3ClientGetRolesMock 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 patchGetRoles(plugin: HtEtcd3Instrumentation, RoleClass: typeof Role): (originalFn: Etcd3["getRoles"]) => (this: Etcd3) => ReturnType<Etcd3["getRoles"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/client/Etcd3ClientGetUsersMock.d.ts

@@ -0,0 +1,30 @@
+import type { Etcd3, 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 = EmptyObject;
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type InputMeta = EmptyObject;
+type ReadableOutput = {
+    userNames: string[];
+};
+type RealOutput = ReadableOutput;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3ClientGetUsersMock 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 patchGetUsers(plugin: HtEtcd3Instrumentation, UserClass: typeof User): (originalFn: Etcd3["getUsers"]) => (this: Etcd3) => ReturnType<Etcd3["getUsers"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/client/Etcd3ClientLeaseMock.d.ts

@@ -0,0 +1,8 @@
+import type { Etcd3, Lease } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare enum LeaseState {
+    Pending = 0,
+    Alive = 1,
+    Revoked = 2
+}
+export declare function patchLease(plugin: HtEtcd3Instrumentation, LeaseClass: typeof Lease): (originalFn: Etcd3["lease"]) => (this: Etcd3, ttl: number, options?: import("etcd3").ILeaseOptions) => ReturnType<Etcd3["lease"]>;

package/instrumentation/libraries/etcd3/modules/kvClient/Etcd3kvClientMock.d.ts

@@ -0,0 +1,3 @@
+import type { KVClient } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare function patchKvClientMethods(plugin: HtEtcd3Instrumentation): (originalFn: KVClient["deleteRange"] | KVClient["put"] | KVClient["range"] | KVClient["txn"]) => (this: KVClient, ...inputArgs: Parameters<KVClient["deleteRange"] | KVClient["put"] | KVClient["range"] | KVClient["txn"]>) => ReturnType<KVClient["deleteRange"] | KVClient["put"] | KVClient["range"] | KVClient["txn"]>;

package/instrumentation/libraries/etcd3/modules/lease/Etcd3LeaseGrantMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/lease/Etcd3LeaseKeepaliveOnceMock.d.ts

@@ -0,0 +1,3 @@
+import type { Lease } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare function patchKeepaliveOnce(plugin: HtEtcd3Instrumentation): (originalFn: Lease["keepaliveOnce"]) => (this: Lease, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Lease["keepaliveOnce"]>;

package/instrumentation/libraries/etcd3/modules/lease/Etcd3LeaseReleaseMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/lease/Etcd3LeaseRevokeMock.d.ts

@@ -0,0 +1,3 @@
+import type { Lease } from 'etcd3';
+import type { HtEtcd3Instrumentation } from '../../instrumentation';
+export declare function patchRevoke(plugin: HtEtcd3Instrumentation): (originalFn: Lease["revoke"]) => (this: Lease, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Lease["revoke"]>;

package/instrumentation/libraries/etcd3/modules/lock/Etcd3LockAcquireMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/lock/Etcd3LockLeaseIdMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/lock/Etcd3LockReleaseMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/lock/Etcd3LockTtlMock.d.ts

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

package/instrumentation/libraries/etcd3/modules/role/Etcd3RoleAddUserMock.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 Etcd3RoleAddUserMock 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 patchAddUser(plugin: HtEtcd3Instrumentation): (originalFn: Role["addUser"]) => (this: Role, user: string | import("etcd3").User, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["addUser"]>;
+export {};

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

@@ -0,0 +1,30 @@
+import type { 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 InputMeta = EmptyObject;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3RoleCreateMock 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 patchCreate(plugin: HtEtcd3Instrumentation): (originalFn: Role["create"]) => (this: Role, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["create"]>;
+export {};

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

@@ -0,0 +1,30 @@
+import type { 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 InputMeta = EmptyObject;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = EmptyObject;
+type RealOutput = EmptyObject;
+type ReadableOutput = EmptyObject;
+type ProcessedOutputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+export declare class Etcd3RoleDeleteMock 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 patchDelete(plugin: HtEtcd3Instrumentation): (originalFn: Role["delete"]) => (this: Role, options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["delete"]>;
+export {};

package/instrumentation/libraries/etcd3/modules/role/Etcd3RoleGrantMock.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 Etcd3RoleGrantMock 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 patchGrant(plugin: HtEtcd3Instrumentation): (originalFn: Role["grant"]) => (this: Role, req: import("etcd3").IPermissionRequest | import("etcd3").IPermissionRequest[], options?: import("@grpc/grpc-js").CallOptions) => ReturnType<Role["delete"]>;
+export {};