@tailor-platform/sdk 2.0.0-next.2 → 2.0.0-next.4

package/dist/mock-FPxmnt-y.mjs

@@ -1,759 +0,0 @@
-import { t as TRIGGER_DEFAULT } from "./registry-DH4m7eYo.mjs";
-import { a as writeWorkflowTestEnv, n as clearWorkflowTestEnv } from "./test-env-key-D7UkZp99.mjs";
-import { t as assertDefined } from "./assert-DBxo8jPo.mjs";
-import { i as platformSerialize } from "./globals-Cf0sxIt8.mjs";
-import { vi } from "vitest";
-
-//#region src/vitest/mock.ts
-/**
-* Mock controls for Tailor Platform APIs (vitest).
-*
-* Each `xMock()` factory installs `vi.fn()`-backed mocks for one platform
-* namespace onto `globalThis` when acquired, and restores the previous value
-* when the `using` scope exits. State lives in the per-acquisition vi.fns /
-* closures — there is no shared global state bag — so nested/sequential scopes
-* are isolated and namespaces never interfere with each other.
-*
-* Acquire a mock with a `using` declaration:
-*
-* ```ts
-* test("...", () => {
-*   using wf = mockWorkflow();
-*   wf.setJobHandler(() => ({ ok: true }));
-* }); // previous workflow mock restored here
-* ```
-*
-* The friendly helpers (`setJobHandler`, `enqueueResult`, `triggeredJobs`, …)
-* are thin wrappers over the underlying vi.fns, which are also exposed directly
-* (`wf.triggerJobFunction`) for native matchers like
-* `expect(wf.triggerJobFunction).toHaveBeenCalledWith(...)`.
-*/
-function withDispose(facade, dispose) {
-	Object.defineProperty(facade, Symbol.dispose, {
-		value: dispose,
-		enumerable: false,
-		writable: true,
-		configurable: true
-	});
-	return facade;
-}
-function tailorRoot() {
-	const g = globalThis;
-	if (!g.tailor) g.tailor = { context: { getInvoker: () => null } };
-	return g.tailor;
-}
-function tailordbRoot() {
-	const g = globalThis;
-	if (!g.tailordb) g.tailordb = {};
-	return g.tailordb;
-}
-var MockQueryResult = class {
-	command;
-	rowCount;
-	rows;
-	constructor(rows) {
-		this.command = "";
-		this.rowCount = rows.length;
-		this.rows = rows;
-	}
-};
-/**
-* Acquire a disposable mock for TailorDB operations. Installs a mock
-* `tailordb.Client` whose `queryObject` is a shared `vi.fn()` (so query
-* responses can be staged before the client is constructed). Restored on
-* dispose.
-* @returns Disposable TailorDB mock control object
-* @example
-* ```typescript
-* import { mockTailordb } from "@tailor-platform/sdk/vitest";
-*
-* test("order-based", async () => {
-*   using db = mockTailordb();
-*   db.enqueueResults([], [{ age: 30 }], []); // BEGIN / SELECT / COMMIT
-*   // …
-*   expect(db.queryObject).toHaveBeenCalledTimes(3);
-*   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
-* });
-* ```
-*/
-function mockTailordb() {
-	const root = tailordbRoot();
-	const prevClient = root.Client;
-	const queryObject = vi.fn(async (_query, _params = []) => new MockQueryResult([]));
-	const connect = vi.fn(async () => {});
-	const createdClients = [];
-	const Client = vi.fn(function(config) {
-		const record = {
-			namespace: config?.namespace,
-			ended: false
-		};
-		createdClients.push(record);
-		this.connect = connect;
-		this.end = vi.fn(async () => {
-			record.ended = true;
-		});
-		this.queryObject = queryObject;
-		this.createTransaction = (name) => {
-			if (!name) throw new Error("Transaction name must be a non-empty string");
-			return {
-				begin: async () => {},
-				commit: async () => {},
-				rollback: async () => {},
-				queryObject
-			};
-		};
-	});
-	root.Client = Client;
-	return withDispose({
-		/** The mock `tailordb.Client` constructor (`vi.fn`). */
-		Client,
-		/** The shared `queryObject` `vi.fn` used by every client and transaction. */
-		queryObject,
-		/**
-		* Set a fallback query resolver. Called when the enqueue queue is empty.
-		* @param resolver - Function that returns rows for a given query and params
-		*/
-		setQueryResolver(resolver) {
-			queryObject.mockImplementation(async (query, params = []) => new MockQueryResult(resolver(query, params) ?? []));
-		},
-		/**
-		* Enqueue rows for the next `queryObject` call (FIFO; takes priority over
-		* `setQueryResolver`). Call with no arguments for an empty result.
-		* @param rows - Row objects to return from the next `queryObject` call
-		*/
-		enqueueResult(...rows) {
-			queryObject.mockImplementationOnce(async () => new MockQueryResult(rows));
-		},
-		/**
-		* Enqueue rows for multiple subsequent `queryObject` calls (FIFO).
-		* @param rowsList - Rows arrays, one per upcoming query
-		*/
-		enqueueResults(...rowsList) {
-			for (const rows of rowsList) queryObject.mockImplementationOnce(async () => new MockQueryResult(rows));
-		},
-		/**
-		* All queries executed via `queryObject`, in order, derived from the vi.fn
-		* call records.
-		* @returns Executed queries array
-		*/
-		get executedQueries() {
-			return queryObject.mock.calls.map(([query, params]) => ({
-				query,
-				params: params ?? []
-			}));
-		},
-		/**
-		* All TailorDB clients created, with their namespace and end state.
-		* @returns Created clients array
-		*/
-		get createdClients() {
-			return createdClients;
-		},
-		/** Reset query responses and recorded calls (keeps the mock installed). */
-		reset() {
-			queryObject.mockReset();
-			queryObject.mockImplementation(async () => new MockQueryResult([]));
-			connect.mockClear();
-			Client.mockClear();
-			createdClients.length = 0;
-		}
-	}, () => {
-		root.Client = prevClient;
-	});
-}
-/**
-* Acquire a disposable mock for workflow operations (`tailor.workflow`).
-* Restored on dispose.
-* @returns Disposable workflow mock control object
-* @example
-* ```typescript
-* import { mockWorkflow } from "@tailor-platform/sdk/vitest";
-*
-* test("job handler", async () => {
-*   using wf = mockWorkflow();
-*   wf.setJobHandler((name) => (name === "validate" ? { valid: true } : null));
-*   await runWorkflowUnderTest(); // calls tailor.workflow.triggerJobFunction("validate", {})
-*   expect(wf.triggerJobFunction).toHaveBeenCalledWith("validate", {});
-* });
-* ```
-*/
-function mockWorkflow() {
-	const root = tailorRoot();
-	const prev = root.workflow;
-	const defaultTriggerJob = (jobName, _args) => {
-		throw new Error(`No workflow job mock for "${jobName}". Call mockWorkflow().setJobHandler(...) or enqueueResult(...), or use runWorkflowLocally() for local workflow execution.`);
-	};
-	const defaultTriggerWorkflow = async (_workflowName, _args, _options) => {
-		return TRIGGER_DEFAULT;
-	};
-	const triggerJobFunction = vi.fn(defaultTriggerJob);
-	const triggerWorkflow = vi.fn(defaultTriggerWorkflow);
-	const wait = vi.fn((_key, _payload) => null);
-	const resolve = vi.fn(async (_executionId, _key, _callback) => {});
-	const installedTriggerJobFunction = (jobName, args) => {
-		const out = triggerJobFunction(jobName, platformSerialize(args));
-		return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
-	};
-	root.workflow = {
-		triggerJobFunction: installedTriggerJobFunction,
-		triggerWorkflow: (...call) => call.length >= 3 ? triggerWorkflow(call[0], platformSerialize(call[1]), call[2]) : triggerWorkflow(call[0], platformSerialize(call[1])),
-		wait: (key, payload) => wait(key, platformSerialize(payload)),
-		resolve: (executionId, key, callback) => resolve(executionId, key, (payload) => {
-			const out = callback(payload);
-			return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
-		})
-	};
-	return withDispose({
-		/** The `triggerJobFunction` `vi.fn`. */
-		triggerJobFunction,
-		/** The `triggerWorkflow` `vi.fn`. */
-		triggerWorkflow,
-		/** The `wait` `vi.fn`. */
-		wait,
-		/** The `resolve` `vi.fn`. */
-		resolve,
-		/**
-		* Set a fallback job handler. Called when the enqueue queue is empty.
-		* @param handler - Function returning a result for a job name and args
-		*/
-		setJobHandler(handler) {
-			triggerJobFunction.mockImplementation((name, args) => handler(name, args));
-		},
-		/**
-		* Enqueue a single result for the next `triggerJobFunction` call (FIFO;
-		* takes priority over `setJobHandler`).
-		* @param result - Result to return from the next call
-		*/
-		enqueueResult(result) {
-			triggerJobFunction.mockImplementationOnce(() => result);
-		},
-		/**
-		* Enqueue results for multiple subsequent `triggerJobFunction` calls (FIFO).
-		* @param results - Results to enqueue, one per upcoming call
-		*/
-		enqueueResults(...results) {
-			for (const result of results) triggerJobFunction.mockImplementationOnce(() => result);
-		},
-		/**
-		* All jobs triggered via `triggerJobFunction`, in order.
-		* @returns Triggered jobs array
-		*/
-		get triggeredJobs() {
-			return triggerJobFunction.mock.calls.map(([jobName, args]) => ({
-				jobName,
-				args
-			}));
-		},
-		/**
-		* Configure what `triggerWorkflow` returns. Pass a string (same id every
-		* call) or `(name, args, options) => string`. Default: a placeholder UUID.
-		* @param handler - Static execution ID or a function returning one
-		*/
-		setTriggerHandler(handler) {
-			triggerWorkflow.mockImplementation(typeof handler === "function" ? async (name, args, options) => handler(name, args, options) : async () => handler);
-		},
-		/**
-		* Configure what `wait` returns. Pass `(key, payload) => unknown` or any
-		* other value to return it for every call. Default: `null`.
-		* @param handler - Static value or a function returning one
-		*/
-		setWaitHandler: ((handler) => {
-			wait.mockImplementation(typeof handler === "function" ? (key, payload) => handler(key, payload) : () => handler);
-		}),
-		/**
-		* Set the `env` passed to job bodies invoked via `runWorkflowLocally()`.
-		* Cleared on dispose / reset.
-		* @param env - Env passed to job bodies.
-		*/
-		setEnv(env) {
-			writeWorkflowTestEnv({ ...env });
-		},
-		/**
-		* Configure how `resolve` runs the user-supplied callback. Default: callback
-		* is not invoked (records the call only).
-		* @param handler - Function invoked per `resolve` call
-		*/
-		setResolveHandler(handler) {
-			resolve.mockImplementation(async (executionId, key, callback) => {
-				await handler(executionId, key, callback);
-			});
-		},
-		/**
-		* `wait` calls reshaped as `{ key, payload }` for assertions.
-		* @returns Wait call records
-		*/
-		get waitCalls() {
-			return wait.mock.calls.map(([key, payload]) => ({
-				key,
-				payload
-			}));
-		},
-		/**
-		* `resolve` calls reshaped as `{ executionId, key }` for assertions.
-		* @returns Resolve call records
-		*/
-		get resolveCalls() {
-			return resolve.mock.calls.map(([executionId, key]) => ({
-				executionId,
-				key
-			}));
-		},
-		/** Reset all workflow responses and recorded calls (keeps the mock installed). */
-		reset() {
-			triggerJobFunction.mockReset();
-			triggerJobFunction.mockImplementation(defaultTriggerJob);
-			triggerWorkflow.mockReset();
-			triggerWorkflow.mockImplementation(defaultTriggerWorkflow);
-			wait.mockReset();
-			wait.mockImplementation(() => null);
-			resolve.mockReset();
-			resolve.mockImplementation(async () => {});
-			clearWorkflowTestEnv();
-		}
-	}, () => {
-		root.workflow = prev;
-		clearWorkflowTestEnv();
-	});
-}
-const SECRET_STORE = Symbol("tailorSecretStore");
-/**
-* Acquire a disposable mock for `tailor.secretmanager`. The secret store is
-* inherited (cloned) from the currently-installed mock on acquisition and
-* restored on dispose, so secrets seeded outside the test survive across
-* `using` scopes while per-test `setSecrets()` overrides stay isolated.
-* @returns Disposable SecretManager mock control object
-* @example
-* ```typescript
-* import { mockSecretmanager } from "@tailor-platform/sdk/vitest";
-*
-* test("reads secrets from vault", async () => {
-*   using sm = mockSecretmanager();
-*   sm.setSecrets({ "my-vault": { API_KEY: "sk-123" } });
-*   // …
-* });
-* ```
-*/
-function mockSecretmanager() {
-	const root = tailorRoot();
-	const prev = root.secretmanager;
-	const holder = { store: structuredClone(prev?.[SECRET_STORE]?.store ?? {}) };
-	const getSecret = vi.fn(async (vault, name) => holder.store[vault]?.[name]);
-	const getSecrets = vi.fn(async (vault, names) => {
-		const vaultData = holder.store[vault] ?? {};
-		const result = {};
-		for (const name of names) if (name in vaultData) result[name] = assertDefined(vaultData[name], `vault entry missing for: ${name}`);
-		return result;
-	});
-	root.secretmanager = {
-		getSecret,
-		getSecrets,
-		[SECRET_STORE]: holder
-	};
-	return withDispose({
-		/** The `getSecret` `vi.fn`. */
-		getSecret,
-		/** The `getSecrets` `vi.fn`. */
-		getSecrets,
-		setSecrets(secrets) {
-			holder.store = secrets;
-		},
-		get calls() {
-			return [...getSecret.mock.calls.map((args, i) => ({
-				order: getSecret.mock.invocationCallOrder[i] ?? 0,
-				call: {
-					method: "getSecret",
-					vault: args[0],
-					name: args[1]
-				}
-			})), ...getSecrets.mock.calls.map((args, i) => ({
-				order: getSecrets.mock.invocationCallOrder[i] ?? 0,
-				call: {
-					method: "getSecrets",
-					vault: args[0],
-					names: args[1]
-				}
-			}))].toSorted((a, b) => a.order - b.order).map((e) => e.call);
-		},
-		reset() {
-			holder.store = {};
-			getSecret.mockClear();
-			getSecrets.mockClear();
-		}
-	}, () => {
-		root.secretmanager = prev;
-	});
-}
-/**
-* Acquire a disposable mock for `tailor.authconnection`. Restored on dispose.
-* @returns Disposable AuthConnection mock control object
-* @example
-* ```typescript
-* import { mockAuthconnection } from "@tailor-platform/sdk/vitest";
-*
-* test("returns configured token", async () => {
-*   using ac = mockAuthconnection();
-*   ac.setTokens({ google: { access_token: "ya29.xxx" } });
-*   // …
-* });
-* ```
-*/
-function mockAuthconnection() {
-	const root = tailorRoot();
-	const prev = root.authconnection;
-	let tokens = {};
-	const getConnectionToken = vi.fn(async (connectionName) => tokens[connectionName] ?? { access_token: "mock-token" });
-	root.authconnection = { getConnectionToken };
-	return withDispose({
-		/** The `getConnectionToken` `vi.fn`. */
-		getConnectionToken,
-		setTokens(value) {
-			tokens = value;
-		},
-		get calls() {
-			return getConnectionToken.mock.calls.map(([connectionName]) => ({ connectionName }));
-		},
-		reset() {
-			tokens = {};
-			getConnectionToken.mockClear();
-		}
-	}, () => {
-		root.authconnection = prev;
-	});
-}
-const IDP_DEFAULTS = {
-	users: {
-		users: [],
-		nextPageToken: null,
-		totalCount: 0
-	},
-	user: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	userByName: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	createUser: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	updateUser: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	deleteUser: true,
-	sendPasswordResetEmail: true
-};
-/**
-* Acquire a disposable mock for `tailor.idp`. Restored on dispose.
-* @returns Disposable IDP mock control object
-* @example
-* ```typescript
-* import { mockIdp } from "@tailor-platform/sdk/vitest";
-*
-* test("resolver-based", async () => {
-*   using idp = mockIdp();
-*   idp.setResolver((method) =>
-*     method === "user" ? { id: "u-1", name: "alice", disabled: false } : null,
-*   );
-*   // …
-* });
-* ```
-*/
-function mockIdp() {
-	const root = tailorRoot();
-	const prev = root.idp;
-	const queue = [];
-	let resolver = () => null;
-	const calls = [];
-	function handle(method, args, namespace) {
-		calls.push({
-			method,
-			args,
-			namespace
-		});
-		if (queue.length > 0) return queue.shift();
-		const resolved = resolver(method, args, namespace);
-		if (resolved != null) return resolved;
-		const fallback = IDP_DEFAULTS[method];
-		return fallback === void 0 ? void 0 : structuredClone(fallback);
-	}
-	const Client = vi.fn(function(config) {
-		const namespace = config.namespace;
-		this.users = async (options) => handle("users", [options], namespace);
-		this.user = async (userId) => handle("user", [userId], namespace);
-		this.userByName = async (name) => handle("userByName", [name], namespace);
-		this.createUser = async (input) => handle("createUser", [input], namespace);
-		this.updateUser = async (input) => handle("updateUser", [input], namespace);
-		this.deleteUser = async (userId) => handle("deleteUser", [userId], namespace);
-		this.sendPasswordResetEmail = async (input) => handle("sendPasswordResetEmail", [input], namespace);
-	});
-	root.idp = { Client };
-	return withDispose({
-		/** The mock IDP `Client` constructor (`vi.fn`). */
-		Client,
-		setResolver(value) {
-			resolver = value;
-		},
-		/**
-		* Enqueue a single result for the next IDP call (FIFO; falls back to
-		* `setResolver` when exhausted).
-		* @param result - Result to return from the next IDP call
-		*/
-		enqueueResult(result) {
-			queue.push(result);
-		},
-		/**
-		* Enqueue results for multiple subsequent IDP calls.
-		* @param results - Results to enqueue, one per upcoming call
-		*/
-		enqueueResults(...results) {
-			queue.push(...results);
-		},
-		get calls() {
-			return calls;
-		},
-		reset() {
-			queue.length = 0;
-			resolver = () => null;
-			calls.length = 0;
-		}
-	}, () => {
-		root.idp = prev;
-	});
-}
-function isUtf8(encoding) {
-	return encoding === "UTF8" || encoding === "UTF-8";
-}
-function defaultIconvResult(method, args) {
-	switch (method) {
-		case "convert":
-		case "convertBuffer": return isUtf8(args[2]) ? "" : new Uint8Array();
-		case "decode": return "";
-		case "encode": return isUtf8(args[1]) ? "" : new Uint8Array();
-		case "encodings": return [];
-		default: return;
-	}
-}
-/**
-* Acquire a disposable mock for `tailor.iconv`. Restored on dispose.
-* @returns Disposable Iconv mock control object
-* @example
-* ```typescript
-* import { mockIconv } from "@tailor-platform/sdk/vitest";
-*
-* test("mock encoding conversion", () => {
-*   using iconv = mockIconv();
-*   iconv.setResolver((method) => (method === "decode" ? "decoded-text" : null));
-*   // …
-* });
-* ```
-*/
-function mockIconv() {
-	const root = tailorRoot();
-	const prev = root.iconv;
-	let resolver = null;
-	const calls = [];
-	function handle(method, args) {
-		calls.push({
-			method,
-			args: [...args]
-		});
-		if (resolver) {
-			const result = resolver(method, args);
-			if (result != null) return result;
-		}
-		return defaultIconvResult(method, args);
-	}
-	class MockIconv {
-		#fromEncoding;
-		#toEncoding;
-		constructor(fromEncoding, toEncoding) {
-			this.#fromEncoding = fromEncoding;
-			this.#toEncoding = toEncoding;
-		}
-		convert(input) {
-			return handle("convert", [
-				input,
-				this.#fromEncoding,
-				this.#toEncoding
-			]);
-		}
-	}
-	root.iconv = {
-		convert: (str, from, to) => handle("convert", [
-			str,
-			from,
-			to
-		]),
-		convertBuffer: (buf, from, to) => handle("convertBuffer", [
-			buf,
-			from,
-			to
-		]),
-		decode: (buf, encoding) => handle("decode", [buf, encoding]),
-		encode: (str, encoding) => handle("encode", [str, encoding]),
-		encodings: () => handle("encodings", []),
-		Iconv: MockIconv
-	};
-	return withDispose({
-		setResolver(value) {
-			resolver = value;
-		},
-		get calls() {
-			return calls;
-		},
-		reset() {
-			resolver = null;
-			calls.length = 0;
-		}
-	}, () => {
-		root.iconv = prev;
-	});
-}
-const FILE_DEFAULTS = {
-	upload: { metadata: {
-		fileSize: 0,
-		sha256sum: ""
-	} },
-	download: {
-		data: new Uint8Array(),
-		metadata: {
-			contentType: "",
-			fileSize: 0,
-			sha256sum: "",
-			lastUploadedAt: ""
-		}
-	},
-	downloadAsBase64: {
-		data: "",
-		metadata: {
-			contentType: "",
-			fileSize: 0,
-			sha256sum: "",
-			lastUploadedAt: ""
-		}
-	},
-	delete: void 0,
-	getMetadata: {
-		contentType: "",
-		fileSize: 0,
-		sha256sum: "",
-		urlPath: ""
-	},
-	downloadStream: null,
-	uploadStream: { metadata: {
-		fileSize: 0,
-		sha256sum: ""
-	} }
-};
-/**
-* Acquire a disposable mock for `tailordb.file`. Restored on dispose.
-* @returns Disposable File mock control object
-* @example
-* ```typescript
-* import { mockFile } from "@tailor-platform/sdk/vitest";
-*
-* test("mock file download", async () => {
-*   using file = mockFile();
-*   file.enqueueResult({ data: new Uint8Array([1, 2, 3]), metadata: { ... } });
-*   // …
-* });
-* ```
-*/
-function mockFile() {
-	const root = tailordbRoot();
-	const prev = root.file;
-	const queue = [];
-	let resolver = () => null;
-	const calls = [];
-	function handle(method, namespace, typeName, fieldName, recordId) {
-		const call = {
-			method,
-			namespace,
-			typeName,
-			fieldName,
-			recordId
-		};
-		calls.push(call);
-		if (queue.length > 0) return queue.shift();
-		const resolved = resolver(method, call);
-		if (resolved != null) return resolved;
-		const fallback = FILE_DEFAULTS[method];
-		return fallback === void 0 ? void 0 : structuredClone(fallback);
-	}
-	root.file = {
-		async upload(namespace, typeName, fieldName, recordId) {
-			return handle("upload", namespace, typeName, fieldName, recordId);
-		},
-		async download(namespace, typeName, fieldName, recordId) {
-			return handle("download", namespace, typeName, fieldName, recordId);
-		},
-		async downloadAsBase64(namespace, typeName, fieldName, recordId) {
-			return handle("downloadAsBase64", namespace, typeName, fieldName, recordId);
-		},
-		async delete(namespace, typeName, fieldName, recordId) {
-			handle("delete", namespace, typeName, fieldName, recordId);
-		},
-		async getMetadata(namespace, typeName, fieldName, recordId) {
-			return handle("getMetadata", namespace, typeName, fieldName, recordId);
-		},
-		async downloadStream(namespace, typeName, fieldName, recordId) {
-			const resolved = handle("downloadStream", namespace, typeName, fieldName, recordId);
-			if (resolved != null) return resolved;
-			return {
-				body: new ReadableStream({ start(c) {
-					c.close();
-				} }),
-				metadata: {
-					contentType: "",
-					fileSize: 0,
-					sha256sum: "",
-					lastUploadedAt: ""
-				}
-			};
-		},
-		async uploadStream(namespace, typeName, fieldName, recordId) {
-			return handle("uploadStream", namespace, typeName, fieldName, recordId);
-		}
-	};
-	return withDispose({
-		setResolver(value) {
-			resolver = value;
-		},
-		/**
-		* Enqueue a single result for the next `tailordb.file` call (FIFO; falls
-		* back to `setResolver` when exhausted).
-		* @param result - Result to return from the next file call
-		*/
-		enqueueResult(result) {
-			queue.push(result);
-		},
-		/**
-		* Enqueue results for multiple subsequent `tailordb.file` calls.
-		* @param results - Results to enqueue, one per upcoming call
-		*/
-		enqueueResults(...results) {
-			queue.push(...results);
-		},
-		get calls() {
-			return calls;
-		},
-		reset() {
-			queue.length = 0;
-			resolver = () => null;
-			calls.length = 0;
-		}
-	}, () => {
-		root.file = prev;
-	});
-}
-
-//#endregion
-export { mockSecretmanager as a, mockIdp as i, mockFile as n, mockTailordb as o, mockIconv as r, mockWorkflow as s, mockAuthconnection as t };
-//# sourceMappingURL=mock-FPxmnt-y.mjs.map