@diia-inhouse/test 6.6.4 → 7.2.0

package/vitest/matchers/index.ts

@@ -0,0 +1,21 @@
+export { toBeAttentionMessageParameter } from './toBeAttentionMessageParameter'
+
+export { toBeAttentionMessage } from './toBeAttentionMessage'
+
+export { toBeTextWithParameters } from './toBeTextWithParameters'
+
+export { toBeContextMenu } from './toBeContextMenu'
+
+export { toInterceptorsBeDone } from './toInterceptorsBeDone'
+
+export { toContainObjects } from './toContainObjects'
+
+export { toBeValueWithLabel } from './toBeValueWithLabel'
+
+export { toBeNavigationPanel } from './toBeNavigationPanel'
+
+export { toBeMainButton } from './toBeMainButton'
+
+export { toEqual } from './toEqual'
+
+export { toBe } from './toBe'

package/vitest/matchers/toBe.ts

@@ -0,0 +1,38 @@
+import type { ExpectationResult, MatcherState } from '@vitest/expect'
+
+import { cleanForDiff, cleanUndefined } from '../utils'
+
+export function toBe(this: MatcherState, received: unknown, expected: unknown): ExpectationResult {
+    if (typeof received !== 'object' || received === null || typeof expected !== 'object' || expected === null) {
+        const pass = Object.is(received, expected)
+
+        return {
+            pass,
+            message: () =>
+                pass
+                    ? `expected ${this.utils.printReceived(received)} not to be ${this.utils.printExpected(expected)}`
+                    : `expected ${this.utils.printReceived(received)} to be ${this.utils.printExpected(expected)}`,
+        }
+    }
+
+    const cleanedReceived = cleanUndefined(received)
+    const cleanedExpected = cleanUndefined(expected)
+
+    const pass = this.equals(cleanedReceived, cleanedExpected, this.customTesters)
+
+    if (pass) {
+        return {
+            pass: true,
+            message: () =>
+                `expected ${this.utils.printReceived(cleanedReceived)} not to deeply equal ${this.utils.printExpected(expected)}`,
+        }
+    }
+
+    const diffExpected = cleanForDiff(expected, cleanedReceived)
+    const diff = this.utils.diff(diffExpected, cleanedReceived)
+
+    return {
+        pass: false,
+        message: () => `toBe diff:\n\n${diff}`,
+    }
+}

package/vitest/matchers/toBeAttentionMessage/index.ts

@@ -0,0 +1,19 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Describe, array, object, optional, string } from 'superstruct'
+
+import { assert } from '../../utils'
+import { AttentionMessageParameterSchema } from '../toBeAttentionMessageParameter'
+import { AttentionMessage } from './interfaces'
+
+const AttentionMessageSchema: Describe<AttentionMessage> = object({
+    icon: string(),
+    title: optional(string()),
+    text: optional(string()),
+    parameters: optional(array(AttentionMessageParameterSchema)),
+})
+
+export function toBeAttentionMessage(received: AttentionMessage): ExpectationResult {
+    const title = 'AttentionMessage matcher'
+
+    return assert(title, received, AttentionMessageSchema)
+}

package/vitest/matchers/toBeAttentionMessage/interfaces.ts

@@ -0,0 +1,8 @@
+import { AttentionMessageParameter } from '../../interfaces'
+
+export interface AttentionMessage {
+    icon: string
+    title?: string
+    text?: string
+    parameters?: AttentionMessageParameter[]
+}

package/vitest/matchers/toBeAttentionMessageParameter.ts

@@ -0,0 +1,20 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Describe, object, string } from 'superstruct'
+
+import { AttentionMessageParameter } from '../interfaces'
+import { assert } from '../utils'
+
+export const AttentionMessageParameterSchema: Describe<AttentionMessageParameter> = object({
+    type: string(),
+    data: object({
+        name: string(),
+        alt: string(),
+        resource: string(),
+    }),
+})
+
+export function toBeAttentionMessageParameter(received: AttentionMessageParameter): ExpectationResult {
+    const message = `AttentionMessageParameter matcher`
+
+    return assert(message, received, AttentionMessageParameterSchema)
+}

package/vitest/matchers/toBeContextMenu/index.ts

@@ -0,0 +1,25 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Describe, array, object, optional, record, string } from 'superstruct'
+
+import { assert } from '../../utils'
+import { PublicServiceContextMenu } from './interfaces'
+
+export const ContextMenuSchema: Describe<PublicServiceContextMenu[]> = array(
+    object({
+        type: string(),
+        name: string(),
+        code: optional(string()),
+        appVersions: optional(
+            object({
+                versions: optional(record(string(), array(string()))),
+                minVersion: optional(record(string(), string())),
+            }),
+        ),
+    }),
+)
+
+export function toBeContextMenu(contextMenu: PublicServiceContextMenu[]): ExpectationResult {
+    const message = `PublicServiceContextMenu[] matcher`
+
+    return assert(message, contextMenu, ContextMenuSchema)
+}

package/vitest/matchers/toBeContextMenu/interfaces.ts

@@ -0,0 +1,9 @@
+export interface PublicServiceContextMenu {
+    type: string
+    name: string
+    code?: string
+    appVersions?: {
+        versions?: Record<string, string[]>
+        minVersion?: Record<string, string>
+    }
+}

package/vitest/matchers/toBeDesignSystemElement/index.ts

@@ -0,0 +1,8 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Struct } from 'superstruct'
+
+import { assert } from '../../utils'
+
+export function toBeDesignSystemElement(received: unknown, schema: Struct<unknown, unknown>): ExpectationResult {
+    return assert('toBeDesignSystemElement matcher', received, schema)
+}

package/vitest/matchers/toBeMainButton/index.ts

@@ -0,0 +1,19 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { array, literal, object, optional, string } from 'superstruct'
+
+import { assert } from '../../utils'
+import { MainButton } from './interfaces'
+
+export function toBeMainButton(received: MainButton, action?: string): ExpectationResult {
+    const message = `MainButton matcher`
+
+    return assert(
+        message,
+        received,
+        object({
+            name: string(),
+            action: action ? literal(action) : optional(string()),
+            checkboxes: optional(array(string())),
+        }),
+    )
+}

package/vitest/matchers/toBeMainButton/interfaces.ts

@@ -0,0 +1,5 @@
+export interface MainButton {
+    name: string
+    action?: string
+    checkboxes?: string[]
+}

package/vitest/matchers/toBeNavigationPanel/index.ts

@@ -0,0 +1,17 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Describe, object, optional, string } from 'superstruct'
+
+import { assert } from '../../utils'
+import { ContextMenuSchema } from '../toBeContextMenu'
+import { NavigationPanel } from './interfaces'
+
+const NavigationPanelSchema: Describe<NavigationPanel> = object({
+    header: optional(string()),
+    contextMenu: optional(ContextMenuSchema),
+})
+
+export function toBeNavigationPanel(navigationPanel: NavigationPanel): ExpectationResult {
+    const message = `NavigationPanel matcher`
+
+    return assert(message, navigationPanel, NavigationPanelSchema)
+}

package/vitest/matchers/toBeNavigationPanel/interfaces.ts

@@ -0,0 +1,6 @@
+import { PublicServiceContextMenu } from '../toBeContextMenu/interfaces'
+
+export interface NavigationPanel {
+    header?: string
+    contextMenu?: PublicServiceContextMenu[]
+}

package/vitest/matchers/toBeTextWithParameters/index.ts

@@ -0,0 +1,17 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Describe, array, object, optional, string } from 'superstruct'
+
+import { assert } from '../../utils'
+import { AttentionMessageParameterSchema } from '../toBeAttentionMessageParameter'
+import { TextWithParameters } from './interfaces'
+
+const textWithParametersSchema: Describe<TextWithParameters> = object({
+    text: string(),
+    parameters: optional(array(AttentionMessageParameterSchema)),
+})
+
+export function toBeTextWithParameters(received: TextWithParameters): ExpectationResult {
+    const message = `TextWithParameters matcher`
+
+    return assert(message, received, textWithParametersSchema)
+}

package/vitest/matchers/toBeTextWithParameters/interfaces.ts

@@ -0,0 +1,6 @@
+import { AttentionMessageParameter } from '../../interfaces'
+
+export interface TextWithParameters {
+    text: string
+    parameters?: AttentionMessageParameter[]
+}

package/vitest/matchers/toBeValueWithLabel/index.ts

@@ -0,0 +1,18 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { literal, object, string } from 'superstruct'
+
+import { assert } from '../../utils'
+import { ValueWithLabel } from './interfaces'
+
+export function toBeValueWithLabel(received: ValueWithLabel, value?: string): ExpectationResult {
+    const message = `ValueWithLabel matcher`
+
+    return assert(
+        message,
+        received,
+        object({
+            label: string(),
+            value: value ? literal(value) : string(),
+        }),
+    )
+}

package/vitest/matchers/toBeValueWithLabel/interfaces.ts

@@ -0,0 +1,4 @@
+export interface ValueWithLabel {
+    label: string
+    value: string
+}

package/vitest/matchers/toContainObjects.ts

@@ -0,0 +1,17 @@
+import type { ExpectationResult, MatcherState } from '@vitest/expect'
+import { expect } from 'vitest'
+
+export function toContainObjects(this: MatcherState, received: unknown, argument: unknown[]): ExpectationResult {
+    const pass = this.equals(received, expect.arrayContaining(argument.map((item) => expect.objectContaining(item))))
+    if (pass) {
+        return {
+            message: () => `expected ${this.utils.printReceived(received)} not to contain objects ${this.utils.printExpected(argument)}`,
+            pass: true,
+        }
+    }
+
+    return {
+        message: () => `expected ${this.utils.printReceived(received)} to contain objects ${this.utils.printExpected(argument)}`,
+        pass: false,
+    }
+}

package/vitest/matchers/toEqual.ts

@@ -0,0 +1,26 @@
+import type { ExpectationResult, MatcherState } from '@vitest/expect'
+
+import { cleanForDiff, cleanUndefined } from '../utils'
+
+export function toEqual(this: MatcherState, received: unknown, expected: unknown): ExpectationResult {
+    const cleanedReceived = cleanUndefined(received)
+    const cleanedExpected = cleanUndefined(expected)
+
+    const pass = this.equals(cleanedReceived, cleanedExpected, this.customTesters)
+
+    if (pass) {
+        return {
+            pass: true,
+            message: () =>
+                `expected ${this.utils.printReceived(cleanedReceived)} not to deeply equal ${this.utils.printExpected(expected)}`,
+        }
+    }
+
+    const diffExpected = cleanForDiff(expected, cleanedReceived)
+    const diff = this.utils.diff(diffExpected, cleanedReceived)
+
+    return {
+        pass: false,
+        message: () => `toEqual diff:\n\n${diff}`,
+    }
+}

package/vitest/matchers/toInterceptorsBeDone.ts

@@ -0,0 +1,18 @@
+import type { ExpectationResult } from '@vitest/expect'
+import { Scope } from 'nock'
+
+export function toInterceptorsBeDone(scope: Scope): ExpectationResult {
+    const message = 'expected nock interceptors to be done'
+
+    if (scope?.isDone()) {
+        return {
+            message: () => message,
+            pass: true,
+        }
+    }
+
+    return {
+        message: () => `${message}. Pending interceptors:\n${scope?.pendingMocks().join('\n')}`,
+        pass: false,
+    }
+}

package/vitest/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "noEmit": true,
+        "strict": false,
+        "skipLibCheck": true
+    },
+    "include": ["./**/*"]
+}

package/vitest/utils.ts

@@ -0,0 +1,144 @@
+import type { AsymmetricMatcherInterface, ExpectationResult } from '@vitest/expect'
+import { Struct, StructError, assert as superstructAssert } from 'superstruct'
+
+function isAsymmetricMatcher(obj: unknown): obj is AsymmetricMatcherInterface {
+    if (obj === null || typeof obj !== 'object') {
+        return false
+    }
+
+    return typeof (obj as AsymmetricMatcherInterface).asymmetricMatch === 'function'
+}
+
+function isPlainObject(obj: unknown): obj is Record<string, unknown> {
+    if (obj === null || typeof obj !== 'object') {
+        return false
+    }
+
+    const proto = Object.getPrototypeOf(obj)
+
+    return proto === null || proto === Object.prototype
+}
+
+/**
+ * Removes undefined fields from an object.
+ */
+export function cleanUndefined<T>(obj: T): T {
+    if (obj === null || obj === undefined) {
+        return obj
+    }
+
+    if (Array.isArray(obj)) {
+        return obj.map((item) => cleanUndefined(item)) as T
+    }
+
+    if (typeof obj === 'object') {
+        if (isAsymmetricMatcher(obj) || !isPlainObject(obj)) {
+            return obj
+        }
+
+        const result: Record<string, unknown> = {}
+
+        for (const [key, value] of Object.entries(obj)) {
+            if (value !== undefined) {
+                result[key] = cleanUndefined(value)
+            }
+        }
+
+        return result as T
+    }
+
+    return obj
+}
+
+/**
+ * Cleans expected object for diff display.
+ * Replaces asymmetric matchers with actual received values where they match.
+ */
+export function cleanForDiff<T>(expected: T, received: T): T {
+    if (expected === null || expected === undefined) {
+        return expected
+    }
+
+    if (Array.isArray(expected)) {
+        const receivedArr = Array.isArray(received) ? received : []
+
+        return expected.map((item, i) => cleanForDiff(item, receivedArr[i])) as T
+    }
+
+    if (typeof expected === 'object') {
+        if (isAsymmetricMatcher(expected)) {
+            if (expected.asymmetricMatch(received)) {
+                return received
+            }
+
+            return expected
+        }
+
+        if (!isPlainObject(expected)) {
+            return expected
+        }
+
+        const result: Record<string, unknown> = {}
+        const receivedObj = (typeof received === 'object' && received !== null ? received : {}) as Record<string, unknown>
+
+        for (const [key, value] of Object.entries(expected)) {
+            if (value !== undefined) {
+                result[key] = cleanForDiff(value, receivedObj[key])
+            }
+        }
+
+        return result as T
+    }
+
+    return expected
+}
+
+function getPrettyMessage(data: unknown): string {
+    return JSON.stringify(data, null, 2)
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function assert(matcherMessage: string, data: unknown, schema: Struct<any>): ExpectationResult {
+    try {
+        superstructAssert(data, schema)
+
+        return {
+            pass: true,
+            message: () => `${matcherMessage} is satisfied`,
+        }
+    } catch (err) {
+        if (err instanceof StructError) {
+            const errors = []
+
+            for (const failure of err.failures()) {
+                const { message, value, type, path, branch } = failure
+
+                const errorItem = {
+                    message,
+                    value,
+                    expectedType: type,
+                    path,
+                    branch,
+                }
+
+                errors.push(errorItem)
+            }
+
+            const errorMessage = {
+                matcherMessage,
+                receivedData: data,
+                errors,
+            }
+
+            return {
+                pass: false,
+                message: () => getPrettyMessage(errorMessage),
+            }
+        }
+
+        return {
+            pass: false,
+            message: () => `${matcherMessage}: Unexpected error caused. ${getPrettyMessage(err)}`,
+        }
+    }
+}

package/dist/mock.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockInstance = exports.mockAnyClass = exports.mockClass = void 0;
-const jest_mock_1 = require("jest-mock");
-/**
- * @deprecated
- * This function is not compatible with Vitest.
- * For Vitest compatibility, please use the 'vitest-mock-extended' package instead.
- */
-function mockClass(classToMock) {
-    const mocker = new jest_mock_1.ModuleMocker(global);
-    const metadata = mocker.getMetadata(classToMock);
-    if (!metadata) {
-        throw new Error(`Cannot find metadata to mock ${classToMock.name}`);
-    }
-    return mocker.generateFromMetadata(metadata);
-}
-exports.mockClass = mockClass;
-/**
- * @deprecated
- * This function is not compatible with Vitest.
- * For Vitest compatibility, please use the 'vitest-mock-extended' package instead.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function mockAnyClass(classToMock) {
-    return mockClass(classToMock);
-}
-exports.mockAnyClass = mockAnyClass;
-/**
- * @deprecated
- * This function is not compatible with Vitest.
- * For Vitest compatibility, please use the 'vitest-mock-extended' package instead.
- */
-function mockInstance(classToMock, props = {}) {
-    const mockedClass = mockClass(classToMock);
-    const mockedInstance = new mockedClass();
-    const keys = Object.keys(props);
-    for (const key of keys) {
-        Object.defineProperty(mockedInstance, key, { value: props[key] });
-    }
-    return mockedInstance;
-}
-exports.mockInstance = mockInstance;
-//# sourceMappingURL=mock.js.map

package/dist/mock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock.js","sourceRoot":"","sources":["../src/mock.ts"],"names":[],"mappings":";;;AAAA,yCAAmD;AAEnD;;;;GAIG;AACH,SAAgB,SAAS,CAAsB,WAAc;IACzD,MAAM,MAAM,GAAG,IAAI,wBAAY,CAAC,MAAM,CAAC,CAAA;IAEvC,MAAM,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAA;IAChD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,gCAAgC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAA;IACvE,CAAC;IAED,OAA4B,MAAM,CAAC,oBAAoB,CAAI,QAAQ,CAAC,CAAA;AACxE,CAAC;AATD,8BASC;AAED;;;;GAIG;AACH,8DAA8D;AAC9D,SAAgB,YAAY,CAAsB,WAAc;IAC5D,OAAO,SAAS,CAAC,WAAW,CAAC,CAAA;AACjC,CAAC;AAFD,oCAEC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CACxB,WAAc,EACd,QAAyD,EAAE;IAE3D,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC,CAAA;IAC1C,MAAM,cAAc,GAAG,IAAI,WAAW,EAAE,CAAA;IAExC,MAAM,IAAI,GAAgB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAE5C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACrB,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACrE,CAAC;IAED,OAAO,cAAc,CAAA;AACzB,CAAC;AAdD,oCAcC"}

package/dist/mongooseMock.js

@@ -1,43 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const mongoose = __importStar(require("mongoose"));
-class MongooseMock {
-    setResult(operation, result, repeat = 1) {
-        for (let i = 0; i < repeat; i++) {
-            jest.spyOn(mongoose.Query.prototype, operation).mockReturnValueOnce(result);
-        }
-    }
-    setResultChain(operations, result, repeat = 1) {
-        for (let i = 0; i < repeat; i++) {
-            for (const operation of operations) {
-                jest.spyOn(mongoose.Query.prototype, operation).mockReturnThis();
-            }
-            jest.spyOn(mongoose.Query.prototype, 'exec').mockResolvedValueOnce(result);
-        }
-    }
-}
-exports.default = MongooseMock;
-//# sourceMappingURL=mongooseMock.js.map

package/dist/mongooseMock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mongooseMock.js","sourceRoot":"","sources":["../src/mongooseMock.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mDAAoC;AAIpC,MAAqB,YAAY;IAC7B,SAAS,CAAC,SAA+B,EAAE,MAAe,EAAE,MAAM,GAAG,CAAC;QAClE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAA;QAC/E,CAAC;IACL,CAAC;IAED,cAAc,CAAC,UAAkC,EAAE,MAAe,EAAE,MAAM,GAAG,CAAC;QAC1E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACjC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,cAAc,EAAE,CAAA;YACpE,CAAC;YAED,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAA;QAC9E,CAAC;IACL,CAAC;CACJ;AAhBD,+BAgBC"}

package/dist/types/mock.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="jest" />
-import { ClassLike } from 'jest-mock';
-/**
- * @deprecated
- * This function is not compatible with Vitest.
- * For Vitest compatibility, please use the 'vitest-mock-extended' package instead.
- */
-export declare function mockClass<T extends ClassLike>(classToMock: T): jest.MockedClass<T>;
-/**
- * @deprecated
- * This function is not compatible with Vitest.
- * For Vitest compatibility, please use the 'vitest-mock-extended' package instead.
- */
-export declare function mockAnyClass<T extends ClassLike>(classToMock: T): jest.MockedClass<any>;
-/**
- * @deprecated
- * This function is not compatible with Vitest.
- * For Vitest compatibility, please use the 'vitest-mock-extended' package instead.
- */
-export declare function mockInstance<T extends ClassLike>(classToMock: T, props?: Partial<Record<keyof InstanceType<T>, unknown>>): InstanceType<T>;

package/dist/types/mongooseMock.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="jest" />
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
-import * as mongoose from 'mongoose';
-type MockedQueryOperation = jest.FunctionPropertyNames<mongoose.Query<unknown, unknown>>;
-export default class MongooseMock {
-    setResult(operation: MockedQueryOperation, result: unknown, repeat?: number): void;
-    setResultChain(operations: MockedQueryOperation[], result: unknown, repeat?: number): void;
-}
-export {};