c8y-nitro 0.10.3 → 0.11.0

package/dist/testing.mjs

@@ -0,0 +1,494 @@
+import { S as store, c as splitPath, d as RESOURCES, f as createDocument, g as renderManagedObject, h as createManagedObject, i as platform, l as createBinary, m as updateDocument, n as assertActiveTest, o as compileRoute, p as renderDocument, s as matchRoute, t as arrange, u as addExternalId, v as realtime, x as addChild } from "./scope-CxEPZ74p.mjs";
+import { t as DEFAULTS } from "./defaults-CrrCinRJ.mjs";
+import { Buffer } from "node:buffer";
+import { serverFetch as serverFetch$1 } from "nitro";
+// src/testing/data.ts
+var Ref = class {
+	label;
+	constructor(label) {
+		this.label = label;
+	}
+	get id() {
+		const id = store.refs.get(this);
+		if (id === void 0) throw new Error(`${this.label} does not exist yet: managed objects created with c8y.device()/c8y.managedObject() exist while a test runs, in the scope they were created in.`);
+		return id;
+	}
+	toJSON() {
+		return { id: this.id };
+	}
+};
+function resolveId(input) {
+	return typeof input === "string" ? input : input.id;
+}
+const RESERVED = [
+	"children",
+	"assets",
+	"additions",
+	"externalIds",
+	"tenant"
+];
+function newRef(label) {
+	return new Ref(label);
+}
+/**
+* Creates a managed object from factory input and binds it to its ref.
+* @param ref - The ref returned to the test
+* @param input - Factory input
+*/
+function createFromInput(ref, input) {
+	const data = store.tenant(input.tenant ?? platform.tenant);
+	const fragments = Object.fromEntries(Object.entries(input).filter(([key]) => !RESERVED.includes(key)));
+	const document = createManagedObject(data, fragments, input.owner ?? platform.user?.userName ?? "test-user");
+	store.refs.set(ref, document.id);
+	for (const [kind, children] of [
+		["childDevices", input.children],
+		["childAssets", input.assets],
+		["childAdditions", input.additions]
+	]) for (const child of children ?? []) addChild(data, document.id, kind, child.id);
+	for (const [type, externalId] of Object.entries(input.externalIds ?? {})) if (addExternalId(data, document.id, type, externalId) instanceof Response) throw new TypeError(`c8y: external id ${type}/${externalId} already exists`);
+}
+/**
+* Creates an inventory binary from seed input and binds it to its ref.
+* @param ref - The ref returned to the test
+* @param input - Binary input
+*/
+function createBinaryFromInput(ref, input) {
+	const { name, content, contentType, tenant, ...fragments } = input;
+	const data = store.tenant(tenant ?? platform.tenant);
+	const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
+	const document = createBinary(data, {
+		bytes,
+		contentType: contentType ?? (typeof content === "string" ? "text/plain" : "application/octet-stream"),
+		name
+	}, {
+		name,
+		...fragments
+	}, platform.user?.userName ?? "test-user");
+	store.refs.set(ref, document.id);
+}
+function toContent(content) {
+	return content && {
+		...content,
+		text: () => new TextDecoder().decode(content.bytes)
+	};
+}
+function seedInto(data, collection, input) {
+	const resource = Object.values(RESOURCES).find((item) => item.collection === collection);
+	const body = {
+		time: store.now(),
+		...input
+	};
+	if ("source" in input) body.source = { id: resolveId(input.source) };
+	if (collection === "events" || collection === "alarms") body.text ??= body.type;
+	if (collection === "alarms") body.severity ??= "MAJOR";
+	if (collection === "operations") {
+		delete body.time;
+		delete body.status;
+		delete body.failureReason;
+		body.deviceId = resolveId(input.deviceId);
+	}
+	const result = createDocument(data, resource, body);
+	if (result instanceof Response) throw new TypeError(`c8y.seed(): invalid ${collection.slice(0, -1)}: ${result.message ?? result.status}`);
+	if (collection === "operations" && (input.status !== void 0 || input.failureReason !== void 0)) updateDocument(data, resource, result, {
+		status: input.status ?? "PENDING",
+		failureReason: input.failureReason
+	});
+}
+/**
+* Seeds measurements, events, alarms, and operations (validated like API writes).
+* @param seed - Data to seed
+*/
+function applySeed(seed) {
+	const data = store.tenant(seed.tenant ?? platform.tenant);
+	for (const measurement of seed.measurements ?? []) seedInto(data, "measurements", measurement);
+	for (const event of seed.events ?? []) seedInto(data, "events", event);
+	for (const alarm of seed.alarms ?? []) seedInto(data, "alarms", alarm);
+	for (const operation of seed.operations ?? []) seedInto(data, "operations", operation);
+}
+function matches(value, expected) {
+	if (expected instanceof Ref) return value?.id === expected.id || value === expected.id;
+	if (expected && typeof expected === "object" && !Array.isArray(expected)) return Object.entries(expected).every(([key, item]) => matches(value?.[key], item));
+	return value === expected;
+}
+function filterDocuments(documents, filter) {
+	if (!filter) return documents;
+	if (typeof filter === "function") return documents.filter(filter);
+	return documents.filter((document) => Object.entries(filter).every(([key, expected]) => {
+		if ((key === "source" || key === "deviceId") && (typeof expected === "string" || expected instanceof Ref)) {
+			const id = typeof expected === "string" ? expected : expected.id;
+			return (key === "source" ? document.source?.id : document.deviceId) === id;
+		}
+		return matches(document[key], expected);
+	}));
+}
+function collectionView(tenant, collection) {
+	const rendered = () => {
+		const data = store.tenant(tenant());
+		return [...data[collection].values()].map((document) => collection === "managedObjects" ? renderManagedObject(data, document, { withParents: true }) : renderDocument(data, Object.values(RESOURCES).find((item) => item.collection === collection), document));
+	};
+	return {
+		get: (id) => rendered().find((document) => document.id === resolveId(id)),
+		find: (filter) => filterDocuments(rendered(), filter)
+	};
+}
+function createDb(tenant) {
+	return {
+		managedObjects: collectionView(tenant, "managedObjects"),
+		measurements: collectionView(tenant, "measurements"),
+		events: {
+			...collectionView(tenant, "events"),
+			attachment: (id) => toContent(store.tenant(tenant()).eventBinaries.get(resolveId(id)))
+		},
+		binaries: {
+			get: (id) => {
+				const document = collectionView(tenant, "managedObjects").get(id);
+				return document?.c8y_IsBinary !== void 0 ? document : void 0;
+			},
+			find: (filter) => collectionView(tenant, "managedObjects").find(filter).filter((document) => document.c8y_IsBinary !== void 0),
+			content: (id) => toContent(store.tenant(tenant()).binaries.get(resolveId(id)))
+		},
+		alarms: collectionView(tenant, "alarms"),
+		operations: {
+			...collectionView(tenant, "operations"),
+			update(id, update) {
+				const operation = store.tenant(tenant()).operations.get(resolveId(id));
+				if (!operation) throw new TypeError(`c8y.db.operations.update(): no operation ${resolveId(id)}`);
+				updateDocument(store.tenant(tenant()), RESOURCES.devicecontrol, operation, update);
+			}
+		},
+		externalIds: { find: (managedObject) => store.tenant(tenant()).externalIds.filter((entry) => managedObject === void 0 || entry.managedObjectId === resolveId(managedObject)).map((entry) => ({ ...entry })) }
+	};
+}
+// src/testing/index.ts
+/**
+* The fake Cumulocity tenant your microservice talks to in tests. Requires the
+* `c8yTest()` plugin from `c8y-nitro/testing/vite`.
+*
+* Arrange calls are **scope-aware**: at the top of a file they apply to every
+* test in the file, inside `describe` to the tests of that `describe` (inner
+* scopes override outer ones), and inside a test only to that test. Before
+* every test the tenant is rebuilt from the plugin baseline, the call log is
+* cleared, and c8y-nitro's caches are invalidated, so tests are independent.
+*
+* Arrange the platform as data: users, subscriptions, tenant options,
+* managed objects (`device()`), and measurements, events, alarms, and
+* operations (`seed()`). Your service reads and writes them through the real
+* `@c8y/client`; assert on its responses and on `c8y.db`.
+*
+* @example
+* ```ts
+* import { c8y, definePersona, serverFetch } from 'c8y-nitro/testing'
+*
+* const pump = c8y.device({ name: 'Pump', externalIds: { c8y_Serial: 'SN-1' } })  // seed the platform
+* const visitor = definePersona({ userName: 'visitor', roles: [] })
+*
+* it('returns the pump', async () => {
+*   expect((await serverFetch('/pumps/SN-1')).status).toBe(200)                  // as the default user
+*   expect((await serverFetch('/pumps/SN-1', { as: visitor })).status).toBe(403) // as another user
+* })
+* ```
+*/
+const c8y = {
+	/**
+	* Tenant the microservice is deployed in (the bootstrap tenant).
+	*/
+	get tenant() {
+		return platform.tenant;
+	},
+	/**
+	* Every request the microservice sent to the platform in this test, in order.
+	*/
+	get calls() {
+		return platform.calls;
+	},
+	/**
+	* Requests in this test the fake tenant could not answer (not emulated, and
+	* no `override()`). With the default `onUnhandledRequest: 'error'`, the test
+	* fails after it ran if this is not empty.
+	*/
+	get unhandled() {
+		return platform.unhandled;
+	},
+	/**
+	* The fake tenant's data, to assert on what your service wrote (and to
+	* drive operation status like a device would).
+	*
+	* @example
+	* ```ts
+	* expect(c8y.db.alarms.find({ source: pump, type: 'overdue' })).toMatchObject([{ severity: 'MAJOR' }])
+	* c8y.db.operations.update(operationId, { status: 'SUCCESSFUL' })
+	* ```
+	*/
+	db: {
+		...createDb(() => platform.tenant),
+		tenant: (tenant) => createDb(() => tenant)
+	},
+	/**
+	* Creates a managed object in the fake tenant (in the current scope).
+	* Returns a ref whose `id` is available while a test runs.
+	*
+	* @example
+	* ```ts
+	* const gateway = c8y.managedObject({ name: 'Gateway', type: 'c8y_Gateway', children: [c8y.device({ name: 'Pump' })] })
+	* ```
+	* @param input - Fragments, plus `children`/`assets`/`additions`, `externalIds`, and `tenant`
+	*/
+	managedObject(input = {}) {
+		const ref = newRef(`c8y.managedObject(${JSON.stringify(input.name ?? input.type ?? "")})`);
+		arrange("c8y.managedObject()", () => createFromInput(ref, input));
+		return ref;
+	},
+	/**
+	* Creates a device (a managed object with `c8y_IsDevice`) in the fake tenant.
+	*
+	* @example
+	* ```ts
+	* const pump = c8y.device({ name: 'Pump', externalIds: { c8y_Serial: 'SN-1' } })
+	* it('…', async () => {
+	*   await serverFetch(`/devices/${pump.id}`)
+	* })
+	* ```
+	* @param input - Fragments, plus `children`/`assets`/`additions`, `externalIds`, and `tenant`
+	*/
+	device(input = {}) {
+		const ref = newRef(`c8y.device(${JSON.stringify(input.name ?? "")})`);
+		arrange("c8y.device()", () => createFromInput(ref, {
+			c8y_IsDevice: {},
+			...input
+		}));
+		return ref;
+	},
+	/**
+	* Creates an inventory binary (a file) in the fake tenant (in the current
+	* scope). Returns a ref whose `id` is available while a test runs.
+	*
+	* @example
+	* ```ts
+	* const manual = c8y.binary({ name: 'manual.txt', content: 'Turn it off and on again.' })
+	* ```
+	* @param input - Name, content, optional content type, tenant, and fragments
+	*/
+	binary(input) {
+		const ref = newRef(`c8y.binary(${JSON.stringify(input.name)})`);
+		arrange("c8y.binary()", () => createBinaryFromInput(ref, input));
+		return ref;
+	},
+	/**
+	* Seeds measurements, events, alarms, and operations (in the current scope).
+	* They are validated like API writes (required fields, enums, existing
+	* source), and alarms are deduplicated like on the platform.
+	*
+	* @example
+	* ```ts
+	* c8y.seed({
+	*   measurements: [{ source: pump, type: 'c8y_Temperature', c8y_Temperature: { T: { value: 21.5, unit: 'C' } } }],
+	*   alarms: [{ source: pump, type: 'c8y_Overheating', severity: 'CRITICAL' }],
+	* })
+	* ```
+	* @param seed - Data to seed
+	*/
+	seed(seed) {
+		arrange("c8y.seed()", () => applySeed(seed));
+	},
+	/**
+	* Tenants subscribed to the microservice and their service users.
+	*/
+	subscriptions: {
+		/**
+		* Current subscriptions.
+		*/
+		list() {
+			return platform.subscriptions;
+		},
+		/**
+		* Adds a subscription, or replaces the one of the same tenant.
+		* @param subscription - Tenant and service user credentials
+		*/
+		add(subscription) {
+			arrange("c8y.subscriptions.add()", () => {
+				platform.subscriptions = [...platform.subscriptions.filter((item) => item.tenant !== subscription.tenant), { ...subscription }];
+			});
+		},
+		/**
+		* Removes the subscription of a tenant.
+		* @param tenant - Tenant id
+		*/
+		remove(tenant) {
+			arrange("c8y.subscriptions.remove()", () => {
+				platform.subscriptions = platform.subscriptions.filter((item) => item.tenant !== tenant);
+			});
+		},
+		/**
+		* Replaces all subscriptions.
+		* @param subscriptions - The new subscriptions
+		*/
+		set(subscriptions) {
+			arrange("c8y.subscriptions.set()", () => {
+				platform.subscriptions = subscriptions.map((subscription) => ({ ...subscription }));
+			});
+		}
+	},
+	/**
+	* Tenant options stored in the fake platform. These are platform values, not
+	* caches: a cached read keeps its value until it expires or is invalidated.
+	*/
+	tenantOptions: {
+		/**
+		* Sets an option value (merged with the outer scope's options).
+		* @param key - Option key
+		* @param value - Option value
+		* @param scope - Category and tenant, default own category in the deployed tenant
+		*/
+		set(key, value, scope) {
+			arrange("c8y.tenantOptions.set()", () => platform.setOption(key, value, scope));
+		},
+		/**
+		* Deletes an option in this scope.
+		* @param key - Option key
+		* @param scope - Category and tenant
+		*/
+		delete(key, scope) {
+			arrange("c8y.tenantOptions.delete()", () => {
+				platform.deleteOption(key, scope);
+			});
+		},
+		/**
+		* Reads an option value from the platform.
+		* @param key - Option key
+		* @param scope - Category and tenant
+		*/
+		get(key, scope) {
+			return platform.getOption(key, scope);
+		}
+	},
+	/**
+	* Overrides the platform's answer for requests matching `pattern`. Use it
+	* for failures (errors, timeouts) and for APIs the fake tenant does not
+	* emulate; arrange normal data with `device()`/`seed()` instead, so tests do
+	* not depend on which endpoints your service calls. Overrides stack: inner
+	* scopes and newer overrides win over everything else.
+	*
+	* Patterns are `"[METHOD ]/path"` with `:param`, `*` (one segment), and `**`
+	* (rest of the path).
+	*
+	* @example
+	* ```ts
+	* c8y.override('GET /inventory/**', () => Response.json({ message: 'Unavailable' }, { status: 503 }))
+	* c8y.override('GET /tenant/statistics/summary', () => ({ deviceCount: 3 }))
+	* ```
+	* @param pattern - Route pattern
+	* @param handler - Returns a `Response`, a JSON value (`200`), or nothing (`204`)
+	* @param options - Handler options
+	* @param options.once - Answer only the first matching request
+	*/
+	override(pattern, handler, options = {}) {
+		arrange("c8y.override()", () => {
+			platform.override(pattern, handler, options.once ?? false);
+		});
+	},
+	/**
+	* Applies several arrange settings at once, in the current scope. Callers
+	* are not part of the state: use `serverFetch(path, { as })`.
+	* @param state - Partial tenant state
+	*/
+	apply(state) {
+		arrange("c8y.apply()", () => platform.apply(state));
+	},
+	/**
+	* Notification 2.0 (realtime) in the fake tenant. Writes from your service,
+	* `c8y.seed()`/`c8y.device()` inside a test, and `c8y.db.operations.update()`
+	* are published to the subscriptions your service created.
+	*/
+	notifications: {
+		/**
+		* Waits until every notification delivered to your service's realtime
+		* handlers has been processed (acknowledged), including notifications
+		* caused by the handlers' own writes.
+		*
+		* @example
+		* ```ts
+		* c8y.seed({ measurements: [{ source: pump, type: 'c8y_Temperature', c8y_Temperature: { T: { value: 95, unit: 'C' } } }] })
+		* await c8y.notifications.settled()
+		* expect(c8y.db.alarms.find({ source: pump })).toHaveLength(1)
+		* ```
+		* @param options - Options
+		* @param options.timeout - Milliseconds to wait before failing (default 5000)
+		*/
+		async settled(options = {}) {
+			const timeout = options.timeout ?? 5e3;
+			const start = Date.now();
+			const tick = () => new Promise((resolve) => {
+				setTimeout(resolve, 1);
+			});
+			while (Date.now() - start < 500 && realtime.subscriptions.some((item) => ![...realtime.tokens.values()].some((token) => token.tenant === item.tenant && token.subscription === item.subscription))) await tick();
+			let quietTicks = 0;
+			while (quietTicks < 3) {
+				await tick();
+				quietTicks = realtime.pending() === 0 ? quietTicks + 1 : 0;
+				if (Date.now() - start > timeout) throw new Error(`c8y.notifications.settled(): ${realtime.pending()} notification(s) still not processed after ${timeout} ms`);
+			}
+		},
+		/**
+		* Notification 2.0 subscriptions your service created (all tenants).
+		*/
+		subscriptions() {
+			return realtime.subscriptions;
+		}
+	},
+	/**
+	* Recorded requests matching a route pattern (same syntax as `override()`).
+	* @param pattern - Route pattern, e.g. `'GET /tenant/options/**'`
+	*/
+	callsTo(pattern) {
+		const route = compileRoute(pattern);
+		return platform.calls.filter((call) => matchRoute(route, call.method, splitPath(call.path)));
+	}
+};
+/**
+* Types a user that calls your service in tests, so it can be defined once
+* and reused (role names autocomplete). Pass it to `serverFetch(path, { as })`.
+*
+* @example
+* ```ts
+* const operator = definePersona({ userName: 'operator', roles: ['ROLE_ALARM_ADMIN'] })
+* const partner = definePersona({ userName: 'eve', roles: [], tenant: 't99999' })
+* ```
+* @param user - The user
+*/
+function definePersona(user) {
+	return user;
+}
+/**
+* Calls a route of your service, like `serverFetch()` from `nitro`. With
+* `as`, the request is sent as that user: the platform answers
+* `GET /user/currentUser` with it during the request.
+*
+* @example
+* ```ts
+* await serverFetch('/pumps/SN-1')                                           // default user
+* await serverFetch('/pumps/SN-1/check', { method: 'POST', as: operator })   // a persona
+* await serverFetch('/pumps/SN-1', { as: { userName: 'visitor', roles: [] } }) // inline
+* await serverFetch('/user', { as: null })                                   // not logged in
+* ```
+* @param path - Route path, including the query
+* @param init - Request options, plus `as`
+*/
+async function serverFetch(path, init = {}) {
+	if (!("as" in init)) return serverFetch$1(path, init);
+	const { as: user, ...requestInit } = init;
+	assertActiveTest("serverFetch({ as })");
+	const previous = platform.user;
+	platform.setUser(user ?? null);
+	try {
+		const headers = new Headers(requestInit.headers);
+		const login = user ? `${user.tenant ?? platform.tenant}/${user.userName}:${DEFAULTS.developmentPassword}` : `${platform.tenant}/anonymous:invalid`;
+		headers.set("authorization", `Basic ${Buffer.from(login).toString("base64")}`);
+		return await serverFetch$1(path, {
+			...requestInit,
+			headers
+		});
+	} finally {
+		platform.setUser(previous);
+	}
+}
+export { c8y, definePersona, serverFetch };

package/dist/{typegen-BO_AkyNc.mjs → typegen-Bw4VxFmA.mjs}

@@ -1,11 +1,11 @@
-import { i as C8Y_NITRO_TYPES_FILE, r as C8Y_NITRO_TYPES_DIR } from "./manifest-DV3UW9Dl.mjs";
-import { t as writeAPIClient } from "./apiClient-kxv5KHYJ.mjs";
-import { resolve } from "pathe";
+import { t as writeAPIClient } from "./apiClient-GMQqcgQe.mjs";
+import { i as C8Y_NITRO_TYPES_FILE, r as C8Y_NITRO_TYPES_DIR } from "./manifest-BhrHDm8Y.mjs";
 import process from "node:process";
+import { resolve } from "pathe";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 import { createNitro } from "nitro/builder";
-//#region src/cli/commands/typegen.ts
+// src/cli/commands/typegen.ts
 var typegen_default = defineCommand({
 	meta: {
 		name: "typegen",
@@ -26,5 +26,4 @@ var typegen_default = defineCommand({
 		consola.info(`Add "${C8Y_NITRO_TYPES_DIR}/*.d.ts" to your tsconfig \`include\` if you have not already.`);
 	}
 });
-//#endregion
 export { typegen_default as default };

package/dist/types-D663gk80.d.mts

@@ -0,0 +1,140 @@
+import { C8YRole, C8YRoles, C8YTenantOptionKey } from "c8y-nitro/types";
+/**
+ * A role: the manifest's custom roles, known platform roles, or any string.
+ */
+type C8yTestRole = keyof C8YRoles | C8YRole;
+/**
+ * The user calling the microservice (returned by `GET /user/currentUser`).
+ */
+interface C8yTestUser {
+  userName: string;
+  /**
+   * Effective roles of the user.
+   */
+  roles?: C8yTestRole[];
+  /**
+   * Tenant the user belongs to. Defaults to the tenant the microservice is
+   * deployed in. Drives the injected dev user's auth header.
+   */
+  tenant?: string;
+  /**
+   * Any other `ICurrentUser` fields (email, firstName, …).
+   */
+  [field: string]: unknown;
+}
+/**
+ * Service user credentials of a tenant subscribed to the microservice.
+ */
+interface C8yTestSubscription {
+  tenant: string;
+  user: string;
+  password: string;
+}
+/**
+ * What to do with platform requests no handler answers.
+ */
+type UnhandledRequestStrategy = 'error' | 'warn' | 'ignore';
+/**
+ * State of the fake Cumulocity tenant. Used as the baseline in the
+ * `c8yTest()` plugin config, and as partial overrides in
+ * `c8y.apply()`.
+ */
+interface C8yTestState {
+  /**
+   * Tenant the microservice is deployed in (the bootstrap tenant).
+   * @default 't12345'
+   */
+  tenant?: string;
+  /**
+   * User calling the microservice. `null` makes `GET /user/currentUser`
+   * answer 401.
+   * @default { userName: 'test-user', roles: [] }
+   */
+  user?: C8yTestUser | null;
+  /**
+   * Tenants subscribed to the microservice, with their service users.
+   * @default one subscription for the deployed tenant
+   */
+  subscriptions?: C8yTestSubscription[];
+  /**
+   * Tenant options of the microservice's own settings category, in the deployed tenant.
+   */
+  tenantOptions?: Partial<Record<C8YTenantOptionKey, string>> & Record<string, string>;
+  /**
+   * What to do with platform requests that no handler answers. `'error'`
+   * fails the test after it ran.
+   * @default 'error'
+   */
+  onUnhandledRequest?: UnhandledRequestStrategy;
+}
+/**
+ * A request the microservice sent to the (fake) platform.
+ */
+interface C8yRequest {
+  method: string;
+  /**
+   * Path without query, e.g. `/inventory/managedObjects/42`.
+   */
+  path: string;
+  query: Record<string, string>;
+  /**
+   * Parsed JSON body, raw text, or `undefined`.
+   */
+  body: unknown;
+  headers: Record<string, string>;
+  /**
+   * Tenant the request targets: `targetTenant` query, else the caller's tenant.
+   */
+  tenant: string;
+  /**
+   * User name from basic auth, if any.
+   */
+  user: string | undefined;
+  /**
+   * Route params captured by the matching `c8y.override()` pattern.
+   */
+  params: Record<string, string>;
+}
+/**
+ * A platform request the fake tenant could not answer.
+ */
+interface C8yUnhandledRequest extends C8yRequest {
+  /**
+   * Why the fake tenant could not answer it.
+   */
+  reason: string;
+}
+/**
+ * Context passed to a `c8y.override()` handler.
+ */
+interface C8yRequestContext extends C8yRequest {
+  /**
+   * The raw request, body already consumed.
+   */
+  request: Request;
+}
+/**
+ * Answers a platform request. Return a `Response` for full control (status,
+ * headers), any other value to answer `200` with it as JSON, or nothing for
+ * `204`.
+ */
+type C8yRequestHandler = (context: C8yRequestContext) => unknown;
+/**
+ * Options for the `c8yTest()` Vite plugin.
+ */
+interface C8yTestOptions extends C8yTestState {
+  /**
+   * Base URL the fake platform pretends to live at (`C8Y_BASEURL`).
+   * @default 'https://t12345.cumulocity.test'
+   */
+  baseUrl?: string;
+}
+declare module 'vitest' {
+  interface ProvidedContext {
+    /**
+     * Baseline options of the `c8yTest()` plugin.
+     */
+    c8yNitroTest: C8yTestOptions;
+  }
+}
+export { C8yTestRole as a, C8yTestUser as c, C8yTestOptions as i, C8yUnhandledRequest as l, C8yRequestContext as n, C8yTestState as o, C8yRequestHandler as r, C8yTestSubscription as s, C8yRequest as t, UnhandledRequestStrategy as u };

package/dist/types.d.mts

@@ -1,3 +1,3 @@
-import { a as C8YTenantOptionKey, c as C8yDockerOptions, d as C8YManifest, f as C8YManifestOptions, g as C8YAPIClientOptions, h as C8YKnownRole, i as C8YSettingsCategory, l as C8yCacheOptions, m as C8YRoles, n as C8yNitroModuleOptions, o as C8YTenantOptionKeysCacheConfig, p as C8YRole, r as C8yOpenAPIOptions, s as C8yRealtimeOptions, t as C8yDevOptions, u as C8YZipOptions } from "./index-BEFoDy-y.mjs";
-import { t as TenantCredentials } from "./credentials-eKnJ7m9Y.mjs";
-export { C8YAPIClientOptions, type C8YKnownRole, type C8YManifest, type C8YManifestOptions, C8YRole, C8YRoles, C8YSettingsCategory, C8YTenantOptionKey, C8YTenantOptionKeysCacheConfig, type C8YZipOptions, type C8yCacheOptions, C8yDevOptions, type C8yDockerOptions, C8yNitroModuleOptions, C8yOpenAPIOptions, type C8yRealtimeOptions, type TenantCredentials };
+import { _ as C8YAPIClientOptions, a as C8YTenantOptionKey, c as C8yDockerOptions, d as C8YManifest, f as C8YManifestOptions, g as C8YKnownRole, h as C8YRoles, i as C8YSettingsCategory, l as C8yCacheOptions, m as C8YRole, n as C8yNitroModuleOptions, o as C8YTenantOptionKeysCacheConfig, p as ExposedMcpServer, r as C8yOpenAPIOptions, s as C8yRealtimeOptions, t as C8yDevOptions, u as C8YZipOptions } from "./index-CmIQfBpj.mjs";
+import { t as TenantCredentials } from "./credentials-C_3m4LVX.mjs";
+export { C8YAPIClientOptions, type C8YKnownRole, type C8YManifest, type C8YManifestOptions, C8YRole, C8YRoles, C8YSettingsCategory, C8YTenantOptionKey, C8YTenantOptionKeysCacheConfig, type C8YZipOptions, type C8yCacheOptions, C8yDevOptions, type C8yDockerOptions, C8yNitroModuleOptions, C8yOpenAPIOptions, type C8yRealtimeOptions, type ExposedMcpServer, type TenantCredentials };