@tailor-platform/sdk 1.46.0 → 1.47.0

package/dist/mock-BP-9O5On.mjs

@@ -0,0 +1,796 @@
+
+//#region src/vitest/mock.ts
+const STATE_KEY = "__tailorMockState";
+const RUNTIME_FLAG_KEY = "__tailorRuntimeActive";
+function getState() {
+	const g = globalThis;
+	if (!g["__tailorMockState"]) g[STATE_KEY] = createDefaultState();
+	return g[STATE_KEY];
+}
+function createDefaultState() {
+	return {
+		queryResolver: () => [],
+		queryResultQueue: [],
+		executedQueries: [],
+		createdClients: [],
+		jobHandler: () => null,
+		jobResultQueue: [],
+		triggeredJobs: [],
+		triggerHandler: "mock-execution-id",
+		waitHandler: null,
+		resolveHandler: null,
+		workflowCalls: [],
+		secretStore: {},
+		secretCalls: [],
+		authTokens: {},
+		authCalls: [],
+		idpResolver: () => null,
+		idpResultQueue: [],
+		idpCalls: [],
+		fileResolver: () => null,
+		fileResultQueue: [],
+		fileCalls: [],
+		iconvResolver: null,
+		iconvCalls: []
+	};
+}
+/**
+* Mock control object for TailorDB operations.
+*
+* Automatically injected into `globalThis.tailordb` by the tailor-runtime environment.
+* Use this object to configure query responses and assert on executed queries.
+* @example
+* ```typescript
+* import { tailordbMock } from "@tailor-platform/sdk/vitest";
+*
+* beforeEach(() => tailordbMock.reset());
+*
+* test("content-based", () => {
+*   tailordbMock.setQueryResolver((query) => {
+*     if (query.includes("SELECT")) return [{ id: "1" }];
+*     return [];
+*   });
+* });
+*
+* test("order-based", () => {
+*   tailordbMock.enqueueResults(
+*     [],            // BEGIN (empty result)
+*     [{ age: 30 }], // SELECT (one row)
+*     [],            // COMMIT (empty result)
+*   );
+* });
+* ```
+*/
+const tailordbMock = {
+	/**
+	* Set a fallback query resolver. Called when the result queue is empty.
+	* @param resolver - Function that returns rows for a given query and params
+	*/
+	setQueryResolver(resolver) {
+		getState().queryResolver = resolver;
+	},
+	/**
+	* Enqueue rows for the next `queryObject` call. Arguments are the row objects returned
+	* by that single query. Call with no arguments for an empty result. Consumed in FIFO
+	* order; when the queue is exhausted, subsequent calls fall back to `setQueryResolver`
+	* (default: empty rows). Use `enqueueResults` to stage rows for multiple queries in one
+	* call.
+	* @param rows - Row objects to return from the next `queryObject` call
+	*/
+	enqueueResult(...rows) {
+		getState().queryResultQueue.push(rows);
+	},
+	/**
+	* Enqueue rows for multiple subsequent `queryObject` calls. Each argument is a rows
+	* array for one query, consumed in FIFO order.
+	* @param rowsList - Rows arrays, one per upcoming query
+	*/
+	enqueueResults(...rowsList) {
+		getState().queryResultQueue.push(...rowsList);
+	},
+	/**
+	* All queries executed via `queryObject`, in order.
+	* @returns Executed queries array
+	*/
+	get executedQueries() {
+		return getState().executedQueries;
+	},
+	/**
+	* All TailorDB clients created, with their namespace and end state.
+	* @returns Created clients array
+	*/
+	get createdClients() {
+		return getState().createdClients;
+	},
+	/** Reset all TailorDB mock state. Call in `beforeEach`. */
+	reset() {
+		const state = getState();
+		state.queryResolver = () => [];
+		state.queryResultQueue.length = 0;
+		state.executedQueries.length = 0;
+		state.createdClients.length = 0;
+	}
+};
+/**
+* Mock control object for workflow operations.
+*
+* Automatically injected into `globalThis.tailor.workflow` by the tailor-runtime environment.
+* @example
+* ```typescript
+* import { workflowMock } from "@tailor-platform/sdk/vitest";
+*
+* beforeEach(() => workflowMock.reset());
+*
+* test("job handler", () => {
+*   workflowMock.setJobHandler((jobName, args) => {
+*     if (jobName === "validate") return { valid: true };
+*     return null;
+*   });
+* });
+*
+* test("wait point", () => {
+*   workflowMock.setWaitHandler(() => ({ approved: true }));
+*   // …
+*   expect(workflowMock.waitCalls).toEqual([{ key: "approval", payload: undefined }]);
+* });
+*
+* test("resolve point", () => {
+*   workflowMock.setResolveHandler((_executionId, _key, callback) =>
+*     callback({ approved: true }),
+*   );
+*   // …
+*   expect(workflowMock.resolveCalls).toEqual([
+*     { executionId: "mock-execution-id", key: "approval" },
+*   ]);
+* });
+* ```
+*/
+const workflowMock = {
+	/**
+	* Set a fallback job handler. Called when the result queue is empty.
+	* @param handler - Function that returns a result for a given job name and args
+	*/
+	setJobHandler(handler) {
+		getState().jobHandler = handler;
+	},
+	/**
+	* Enqueue a single result for the next `triggerJobFunction` call. Consumed in FIFO
+	* order; when the queue is exhausted, subsequent calls fall back to `setJobHandler`
+	* (default: null). Use `enqueueResults` to stage multiple results in one call.
+	* @param result - Result to return from the next `triggerJobFunction` call
+	*/
+	enqueueResult(result) {
+		getState().jobResultQueue.push(result);
+	},
+	/**
+	* Enqueue results for multiple subsequent `triggerJobFunction` calls.
+	* @param results - Results to enqueue, one per upcoming call
+	*/
+	enqueueResults(...results) {
+		const queue = getState().jobResultQueue;
+		for (const result of results) queue.push(result);
+	},
+	/**
+	* All jobs triggered via `triggerJobFunction`, in order.
+	* @returns Triggered jobs array
+	*/
+	get triggeredJobs() {
+		return getState().triggeredJobs;
+	},
+	/**
+	* Configure what `tailor.workflow.triggerWorkflow` returns. Pass a string to return
+	* the same execution ID for every call, or a function `(name, args, options) => string`
+	* to compute one per call. Default: `"mock-execution-id"`.
+	* @param handler - Static execution ID or a function that returns one
+	*/
+	setTriggerHandler(handler) {
+		getState().triggerHandler = handler;
+	},
+	/**
+	* Configure what `tailor.workflow.wait` returns. Pass a function `(key, payload) => unknown`
+	* to compute one per call, or any other value to return it for every call. Default: `null`.
+	* @param handler - Static value or a function that returns one
+	*/
+	setWaitHandler: ((handler) => {
+		getState().waitHandler = handler;
+	}),
+	/**
+	* Configure how `tailor.workflow.resolve` runs the user-supplied callback. The handler
+	* receives `(executionId, key, callback)` — invoke `callback(payload)` to drive
+	* resolve→wait wiring in tests. Default: callback is not invoked (records the call only).
+	* @param handler - Function invoked per `resolve` call
+	*/
+	setResolveHandler(handler) {
+		getState().resolveHandler = handler;
+	},
+	/**
+	* Calls to triggerWorkflow, wait, resolve (not triggerJobFunction — use triggeredJobs).
+	* @returns Workflow calls array
+	*/
+	get calls() {
+		return getState().workflowCalls;
+	},
+	/**
+	* `tailor.workflow.wait` calls reshaped as `{ key, payload }` for assertions.
+	* @returns Wait call records
+	*/
+	get waitCalls() {
+		return getState().workflowCalls.filter((c) => c.method === "wait").map((c) => ({
+			key: c.args[0],
+			payload: c.args[1]
+		}));
+	},
+	/**
+	* `tailor.workflow.resolve` calls reshaped as `{ executionId, key }` for assertions.
+	* @returns Resolve call records
+	*/
+	get resolveCalls() {
+		return getState().workflowCalls.filter((c) => c.method === "resolve").map((c) => ({
+			executionId: c.args[0],
+			key: c.args[1]
+		}));
+	},
+	/** Reset all workflow mock state. Call in `beforeEach`. */
+	reset() {
+		const state = getState();
+		state.jobHandler = () => null;
+		state.jobResultQueue.length = 0;
+		state.triggeredJobs.length = 0;
+		state.triggerHandler = "mock-execution-id";
+		state.waitHandler = null;
+		state.resolveHandler = null;
+		state.workflowCalls.length = 0;
+	}
+};
+/** Mock control for `tailor.secretmanager` — secret store and call recording. */
+const secretmanagerMock = {
+	setSecrets(secrets) {
+		getState().secretStore = secrets;
+	},
+	get calls() {
+		return getState().secretCalls;
+	},
+	reset() {
+		const state = getState();
+		state.secretStore = {};
+		state.secretCalls.length = 0;
+	}
+};
+/** Mock control for `tailor.authconnection` — token store and call recording. */
+const authconnectionMock = {
+	setTokens(tokens) {
+		getState().authTokens = tokens;
+	},
+	get calls() {
+		return getState().authCalls;
+	},
+	reset() {
+		const state = getState();
+		state.authTokens = {};
+		state.authCalls.length = 0;
+	}
+};
+/** Mock control for `tailor.idp` — IDP client responses and call recording. */
+const idpMock = {
+	setResolver(resolver) {
+		getState().idpResolver = resolver;
+	},
+	/**
+	* Enqueue a single result for the next IDP call. Consumed in FIFO order; falls back
+	* to `setResolver` when exhausted. Use `enqueueResults` to stage multiple in one call.
+	* @param result - Result to return from the next IDP call
+	*/
+	enqueueResult(result) {
+		getState().idpResultQueue.push(result);
+	},
+	/**
+	* Enqueue results for multiple subsequent IDP calls.
+	* @param results - Results to enqueue, one per upcoming call
+	*/
+	enqueueResults(...results) {
+		const queue = getState().idpResultQueue;
+		for (const result of results) queue.push(result);
+	},
+	get calls() {
+		return getState().idpCalls;
+	},
+	reset() {
+		const state = getState();
+		state.idpResolver = () => null;
+		state.idpResultQueue.length = 0;
+		state.idpCalls.length = 0;
+	}
+};
+/** Mock control for `tailordb.file` — file operation responses and call recording. */
+const fileMock = {
+	setResolver(resolver) {
+		getState().fileResolver = resolver;
+	},
+	/**
+	* Enqueue a single result for the next `tailordb.file` call. Consumed in FIFO order;
+	* falls back to `setResolver` when exhausted. Use `enqueueResults` to stage multiple
+	* in one call.
+	* @param result - Result to return from the next file call
+	*/
+	enqueueResult(result) {
+		getState().fileResultQueue.push(result);
+	},
+	/**
+	* Enqueue results for multiple subsequent `tailordb.file` calls.
+	* @param results - Results to enqueue, one per upcoming call
+	*/
+	enqueueResults(...results) {
+		const queue = getState().fileResultQueue;
+		for (const result of results) queue.push(result);
+	},
+	get calls() {
+		return getState().fileCalls;
+	},
+	reset() {
+		const state = getState();
+		state.fileResolver = () => null;
+		state.fileResultQueue.length = 0;
+		state.fileCalls.length = 0;
+	}
+};
+/** Mock control for `tailor.iconv` — encoding call recording. */
+const iconvMock = {
+	setResolver(resolver) {
+		getState().iconvResolver = resolver;
+	},
+	get calls() {
+		return getState().iconvCalls;
+	},
+	reset() {
+		const state = getState();
+		state.iconvResolver = null;
+		state.iconvCalls.length = 0;
+	}
+};
+var MockQueryResult = class {
+	command;
+	rowCount;
+	rows;
+	constructor(rows) {
+		this.command = "";
+		this.rowCount = rows.length;
+		this.rows = rows;
+	}
+};
+var MockTransaction = class {
+	async begin() {}
+	async commit() {}
+	async rollback() {}
+	async queryObject(query, params = []) {
+		return resolveQuery(query, params);
+	}
+};
+var MockTailordbClient = class {
+	#record;
+	constructor(config) {
+		this.#record = {
+			namespace: config?.namespace,
+			ended: false
+		};
+		getState().createdClients.push(this.#record);
+	}
+	async connect() {}
+	async end() {
+		this.#record.ended = true;
+	}
+	async queryObject(query, params = []) {
+		return resolveQuery(query, params);
+	}
+	createTransaction(name) {
+		if (!name) throw new Error("Transaction name must be a non-empty string");
+		return new MockTransaction();
+	}
+};
+function resolveQuery(query, params) {
+	const state = getState();
+	state.executedQueries.push({
+		query,
+		params
+	});
+	if (state.queryResultQueue.length > 0) return new MockQueryResult(state.queryResultQueue.shift());
+	return new MockQueryResult(state.queryResolver(query, params) ?? []);
+}
+function mockTriggerJobFunction(jobName, args) {
+	const state = getState();
+	state.triggeredJobs.push({
+		jobName,
+		args
+	});
+	if (state.jobResultQueue.length > 0) return state.jobResultQueue.shift();
+	return state.jobHandler(jobName, args);
+}
+async function mockTriggerWorkflow(workflowName, args, options) {
+	const state = getState();
+	state.workflowCalls.push({
+		method: "triggerWorkflow",
+		args: [
+			workflowName,
+			args,
+			options
+		]
+	});
+	const handler = state.triggerHandler;
+	return typeof handler === "function" ? handler(workflowName, args, options) : handler;
+}
+function mockWait(key, payload) {
+	const state = getState();
+	state.workflowCalls.push({
+		method: "wait",
+		args: [key, payload]
+	});
+	const handler = state.waitHandler;
+	return typeof handler === "function" ? handler(key, payload) : handler;
+}
+async function mockResolve(executionId, key, callback) {
+	const state = getState();
+	state.workflowCalls.push({
+		method: "resolve",
+		args: [
+			executionId,
+			key,
+			callback
+		]
+	});
+	if (state.resolveHandler) await state.resolveHandler(executionId, key, callback);
+}
+function mockGetInvoker() {
+	return null;
+}
+async function mockGetSecrets(vault, names) {
+	const state = getState();
+	state.secretCalls.push({
+		method: "getSecrets",
+		vault,
+		names
+	});
+	const vaultData = state.secretStore[vault] ?? {};
+	const result = {};
+	for (const name of names) if (name in vaultData) result[name] = vaultData[name];
+	return result;
+}
+async function mockGetSecret(vault, name) {
+	const state = getState();
+	state.secretCalls.push({
+		method: "getSecret",
+		vault,
+		name
+	});
+	return state.secretStore[vault]?.[name];
+}
+async function mockGetConnectionToken(connectionName) {
+	const state = getState();
+	state.authCalls.push({ connectionName });
+	return state.authTokens[connectionName] ?? { access_token: "mock-token" };
+}
+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
+};
+function resolveIdpCall(method, args, namespace) {
+	const state = getState();
+	state.idpCalls.push({
+		method,
+		args,
+		namespace
+	});
+	if (state.idpResultQueue.length > 0) return state.idpResultQueue.shift();
+	const resolved = state.idpResolver(method, args, namespace);
+	if (resolved != null) return resolved;
+	const fallback = IDP_DEFAULTS[method];
+	return fallback === void 0 ? void 0 : structuredClone(fallback);
+}
+var MockIdpClient = class {
+	#namespace;
+	constructor(config) {
+		this.#namespace = config.namespace;
+	}
+	async users(options) {
+		return resolveIdpCall("users", [options], this.#namespace);
+	}
+	async user(userId) {
+		return resolveIdpCall("user", [userId], this.#namespace);
+	}
+	async userByName(name) {
+		return resolveIdpCall("userByName", [name], this.#namespace);
+	}
+	async createUser(input) {
+		return resolveIdpCall("createUser", [input], this.#namespace);
+	}
+	async updateUser(input) {
+		return resolveIdpCall("updateUser", [input], this.#namespace);
+	}
+	async deleteUser(userId) {
+		return resolveIdpCall("deleteUser", [userId], this.#namespace);
+	}
+	async sendPasswordResetEmail(input) {
+		return resolveIdpCall("sendPasswordResetEmail", [input], this.#namespace);
+	}
+};
+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;
+	}
+}
+function resolveIconvCall(method, args) {
+	const state = getState();
+	state.iconvCalls.push({
+		method,
+		args: [...args]
+	});
+	if (state.iconvResolver) {
+		const result = state.iconvResolver(method, args);
+		if (result != null) return result;
+	}
+	return defaultIconvResult(method, args);
+}
+function mockConvert(str, fromEncoding, toEncoding) {
+	return resolveIconvCall("convert", [
+		str,
+		fromEncoding,
+		toEncoding
+	]);
+}
+function mockConvertBuffer(buffer, fromEncoding, toEncoding) {
+	return resolveIconvCall("convertBuffer", [
+		buffer,
+		fromEncoding,
+		toEncoding
+	]);
+}
+function mockDecode(buffer, encoding) {
+	return resolveIconvCall("decode", [buffer, encoding]);
+}
+function mockEncode(str, encoding) {
+	return resolveIconvCall("encode", [str, encoding]);
+}
+function mockEncodings() {
+	return resolveIconvCall("encodings", []);
+}
+var MockIconv = class {
+	#fromEncoding;
+	#toEncoding;
+	constructor(fromEncoding, toEncoding) {
+		this.#fromEncoding = fromEncoding;
+		this.#toEncoding = toEncoding;
+	}
+	convert(input) {
+		return resolveIconvCall("convert", [
+			input,
+			this.#fromEncoding,
+			this.#toEncoding
+		]);
+	}
+};
+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: ""
+	}
+};
+function resolveFileCall(method, namespace, typeName, fieldName, recordId) {
+	const state = getState();
+	const call = {
+		method,
+		namespace,
+		typeName,
+		fieldName,
+		recordId
+	};
+	state.fileCalls.push(call);
+	if (state.fileResultQueue.length > 0) return state.fileResultQueue.shift();
+	const resolved = state.fileResolver(method, call);
+	if (resolved != null) return resolved;
+	const fallback = FILE_DEFAULTS[method];
+	return fallback === void 0 ? void 0 : structuredClone(fallback);
+}
+const mockTailordbFile = {
+	async upload(namespace, typeName, fieldName, recordId, _data, _options) {
+		return resolveFileCall("upload", namespace, typeName, fieldName, recordId);
+	},
+	async download(namespace, typeName, fieldName, recordId) {
+		return resolveFileCall("download", namespace, typeName, fieldName, recordId);
+	},
+	async downloadAsBase64(namespace, typeName, fieldName, recordId) {
+		return resolveFileCall("downloadAsBase64", namespace, typeName, fieldName, recordId);
+	},
+	async delete(namespace, typeName, fieldName, recordId) {
+		resolveFileCall("delete", namespace, typeName, fieldName, recordId);
+	},
+	async getMetadata(namespace, typeName, fieldName, recordId) {
+		return resolveFileCall("getMetadata", namespace, typeName, fieldName, recordId);
+	},
+	openDownloadStream(namespace, typeName, fieldName, recordId) {
+		const resolved = resolveFileCall("openDownloadStream", namespace, typeName, fieldName, recordId);
+		return Promise.resolve(toFileStream(resolved));
+	}
+};
+function toFileStream(value) {
+	if (value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value.close === "function") return value;
+	if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return toFileStream([value]);
+	if (value !== null && typeof value === "object" && (Symbol.iterator in value || Symbol.asyncIterator in value)) {
+		const source = value;
+		const inner = Symbol.asyncIterator in source ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+		const stream = {
+			async next() {
+				const r = await inner.next();
+				return r.done ? {
+					done: true,
+					value: void 0
+				} : r;
+			},
+			async close() {},
+			[Symbol.asyncIterator]() {
+				return stream;
+			}
+		};
+		return stream;
+	}
+	const empty = {
+		async next() {
+			return {
+				done: true,
+				value: void 0
+			};
+		},
+		async close() {},
+		[Symbol.asyncIterator]() {
+			return empty;
+		}
+	};
+	return empty;
+}
+var TailorErrorsMock = class extends Error {
+	errors;
+	constructor(errors) {
+		if (!Array.isArray(errors)) throw new TypeError("TailorErrors: errors must be an array");
+		const validated = errors.map((e, i) => {
+			if (typeof e.message !== "string") throw new TypeError(`TailorErrors: errors[${i}].message must be a string`);
+			if (!Array.isArray(e.path)) throw new TypeError(`TailorErrors: errors[${i}].path must be an array`);
+			return {
+				message: e.message,
+				path: e.path
+			};
+		});
+		super(`TailorErrors: ${JSON.stringify({ errors: validated })}`);
+		this.name = "TailorErrors";
+		this.errors = validated;
+	}
+};
+var TailorErrorMessageMock = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TailorErrorMessage";
+	}
+};
+var TailorDBFileErrorMock = class extends Error {
+	code;
+	cause;
+	constructor(message, code, cause) {
+		super(message);
+		this.name = "TailorDBFileError";
+		this.code = code;
+		this.cause = cause;
+	}
+};
+/**
+* Inject all platform API mocks into globalThis.
+* Called by the tailor-runtime Vitest environment during setup.
+* @param global - The global object to inject mocks into
+*/
+function injectMocks(global) {
+	const g = global;
+	g[STATE_KEY] = createDefaultState();
+	g[RUNTIME_FLAG_KEY] = true;
+	g.tailordb = {
+		Client: MockTailordbClient,
+		file: mockTailordbFile
+	};
+	g.tailor = {
+		secretmanager: {
+			getSecrets: mockGetSecrets,
+			getSecret: mockGetSecret
+		},
+		authconnection: { getConnectionToken: mockGetConnectionToken },
+		workflow: {
+			triggerJobFunction: mockTriggerJobFunction,
+			triggerWorkflow: mockTriggerWorkflow,
+			wait: mockWait,
+			resolve: mockResolve
+		},
+		context: { getInvoker: mockGetInvoker },
+		idp: { Client: MockIdpClient },
+		iconv: {
+			convert: mockConvert,
+			convertBuffer: mockConvertBuffer,
+			decode: mockDecode,
+			encode: mockEncode,
+			encodings: mockEncodings,
+			Iconv: MockIconv
+		}
+	};
+	g.TailorErrors = TailorErrorsMock;
+	g.TailorErrorMessage = TailorErrorMessageMock;
+	g.TailorDBFileError = TailorDBFileErrorMock;
+}
+/**
+* Remove all injected mocks from globalThis.
+* Called by the tailor-runtime Vitest environment during teardown.
+* @param global - The global object to clean up mocks from
+*/
+function cleanupMocks(global) {
+	const g = global;
+	delete g.tailordb;
+	delete g.tailor;
+	delete g.TailorErrors;
+	delete g.TailorErrorMessage;
+	delete g.TailorDBFileError;
+	delete g[STATE_KEY];
+	delete g[RUNTIME_FLAG_KEY];
+}
+
+//#endregion
+export { fileMock as a, injectMocks as c, workflowMock as d, cleanupMocks as i, secretmanagerMock as l, STATE_KEY as n, iconvMock as o, authconnectionMock as r, idpMock as s, RUNTIME_FLAG_KEY as t, tailordbMock as u };
+//# sourceMappingURL=mock-BP-9O5On.mjs.map