c8y-nitro 0.4.2 → 0.6.0

package/dist/{config-Dqi-ttQi.mjs → config-BRnvtthI.mjs}

@@ -2,6 +2,9 @@ import { dirname } from "pathe";
 import { loadConfig, loadDotenv } from "c12";
 import process from "process";
 //#region src/cli/utils/config.ts
+function normalizeBaseUrl(baseUrl) {
+	return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
 /**
 * Loads c8y configuration from nitro.config and .env files.
 * Searches in cwd.
@@ -45,7 +48,7 @@ function validateBootstrapEnv(env) {
 	const missing = REQUIRED_BOOTSTRAP_ENV_VARS.filter((key) => !env[key]);
 	if (missing.length > 0) throw new Error(`Missing required environment variables:\n${missing.map((k) => `  - ${k}`).join("\n")}\n\nPlease set these in your .env or .env.local file.`);
 	return {
-		C8Y_BASEURL: env.C8Y_BASEURL.endsWith("/") ? env.C8Y_BASEURL.slice(0, -1) : env.C8Y_BASEURL,
+		C8Y_BASEURL: normalizeBaseUrl(env.C8Y_BASEURL),
 		C8Y_DEVELOPMENT_TENANT: env.C8Y_DEVELOPMENT_TENANT,
 		C8Y_DEVELOPMENT_USER: env.C8Y_DEVELOPMENT_USER,
 		C8Y_DEVELOPMENT_PASSWORD: env.C8Y_DEVELOPMENT_PASSWORD

package/dist/credentials-9FO7rTIR.d.mts

@@ -0,0 +1,6 @@
+import { ICredentials } from "@c8y/client";
+
+//#region src/types/credentials.d.ts
+type TenantCredentials = Record<string, ICredentials>;
+//#endregion
+export { TenantCredentials as t };

package/dist/{index-CzUqbp5C.d.mts → index-uOwpI6rD.d.mts}

@@ -193,10 +193,10 @@ interface Option {
    */
   key: string;
   /**
-   * Initial value if not overridden.
+   * Initial non-empty value if not overridden.
    * @example "1234"
    */
-  defaultValue?: string;
+  defaultValue: string;
   /**
    * Allow tenants to modify at runtime.
    * @default false
@@ -389,11 +389,34 @@ type C8YTenantOptionKeysCacheConfig$1 = Partial<Record<C8YTenantOptionKey$1, num
 type C8YTenantOptionKey$1 = string;
 //#endregion
 //#region src/types/index.d.ts
+interface C8yDevOptions {
+  /**
+   * Automatically inject the configured development user into incoming requests
+   * during local Nitro dev mode.
+   *
+   * Disable this when a local proxy already forwards the desired user context.
+   * @default true
+   */
+  injectUser?: boolean;
+}
 interface C8yNitroModuleOptions {
+  dev?: C8yDevOptions;
   manifest?: C8YManifestOptions;
   apiClient?: C8YAPIClientOptions;
   zip?: C8YZipOptions;
   cache?: C8yCacheOptions;
+  /**
+   * Adds a debug route for invalidating already-created tenant option caches.
+   * Exposes `GET /_c8y_nitro/invalidate-tenant-options`.
+   *
+   * Query params:
+   * - `all`: invalidate all created tenant option fetchers
+   * - `key`: invalidate a single manifest-defined tenant option key if it exists
+   *
+   * `all` takes priority over `key`.
+   * @default false
+   */
+  enableTenantOptionsInvalidationRoute?: boolean;
   /**
    * Disable auto-bootstrap during development.
    * When true, the module will not automatically register the microservice
@@ -405,4 +428,4 @@ interface C8yNitroModuleOptions {
   skipBootstrap?: boolean;
 }
 //#endregion
-export { C8yCacheOptions as a, C8YManifestOptions as c, C8YRoles$1 as i, C8YAPIClientOptions as l, C8YTenantOptionKey$1 as n, C8YZipOptions as o, C8YTenantOptionKeysCacheConfig$1 as r, C8YManifest as s, C8yNitroModuleOptions as t };
+export { C8YRoles$1 as a, C8YManifest as c, C8YTenantOptionKeysCacheConfig$1 as i, C8YManifestOptions as l, C8yNitroModuleOptions as n, C8yCacheOptions as o, C8YTenantOptionKey$1 as r, C8YZipOptions as s, C8yDevOptions as t, C8YAPIClientOptions as u };

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-import { t as C8yNitroModuleOptions } from "./index-CzUqbp5C.mjs";
+import { n as C8yNitroModuleOptions } from "./index-uOwpI6rD.mjs";
+import { t as TenantCredentials } from "./credentials-9FO7rTIR.mjs";
 import { NitroModule } from "nitro/types";
 
 //#region src/index.d.ts
@@ -7,6 +8,11 @@ declare module 'nitro/types' {
     c8y?: C8yNitroModuleOptions;
   }
 }
+declare module 'nitro/types' {
+  interface NitroRuntimeHooks {
+    'c8y:tenantCredentialsUpdated': (prev: TenantCredentials | null, next: TenantCredentials) => void;
+  }
+}
 declare function c8y(): NitroModule;
 //#endregion
 export { c8y, c8y as default };

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { a as findMicroserviceByName, g as GENERATED_READINESS_ROUTE, h as GENERATED_LIVENESS_ROUTE, l as subscribeToApplication, m as createC8yManifestFromNitro, n as createBasicAuthHeader, o as getBootstrapCredentials, p as createC8yManifest, r as createMicroservice } from "./c8y-api-BBSKRwKs.mjs";
+import { _ as GENERATED_READINESS_ROUTE, a as findMicroserviceByName, g as GENERATED_LIVENESS_ROUTE, h as GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE, l as subscribeToApplication, m as createC8yManifestFromNitro, n as createBasicAuthHeader, o as getBootstrapCredentials, p as createC8yManifest, r as createMicroservice } from "./c8y-api-BbRS1-Ls.mjs";
 import { t as writeBootstrapCredentials } from "./env-file-B0BK-uZW.mjs";
-import { n as name } from "./package-C4HtuVu_.mjs";
+import { n as name } from "./package-DsLC9Mo3.mjs";
 import { basename, dirname, join, relative } from "node:path";
 import { mkdir, writeFile } from "node:fs/promises";
 import { x } from "tinyexec";
@@ -427,11 +427,21 @@ async function setupRuntimeConfig(nitro, options) {
 */
 function registerRuntime(nitro, options = {}) {
 	const thisFilePath = fileURLToPath(new URL(".", import.meta.url));
+	const isNitroDev = nitro.options.preset === "nitro-dev";
+	const shouldIncludeRuntimeFile = (relativePath) => {
+		if (relativePath.endsWith(".dev.ts") && !isNitroDev) return false;
+		if (relativePath.endsWith("/dev-user.dev.ts") && options.dev?.injectUser === false) return false;
+		return true;
+	};
+	const toRuntimePath = (relativePath) => join$1(thisFilePath, relativePath.replace(/\.ts$/, ""));
 	const allPlugins = Object.keys({
-		"./runtime/plugins/c8y-variables.ts": 0,
+		"./runtime/plugins/c8y-variables.dev.ts": 0,
 		"./runtime/plugins/enrich-logs.ts": 0
-	}).map((p) => join$1(thisFilePath, p.replace(".ts", "")));
-	const allMiddlewares = Object.keys({ "./runtime/middlewares/dev-user.ts": 0 }).map((p) => join$1(thisFilePath, p.replace(".ts", "")));
+	}).filter(shouldIncludeRuntimeFile).map(toRuntimePath);
+	const allMiddlewares = Object.keys({
+		"./runtime/middlewares/c8y-client.ts": 0,
+		"./runtime/middlewares/dev-user.dev.ts": 0
+	}).filter(shouldIncludeRuntimeFile).map(toRuntimePath);
 	/**
 	* Plugins (auto scanned)
 	*/
@@ -465,6 +475,15 @@ function registerRuntime(nitro, options = {}) {
 		});
 		nitro.logger.debug(`Generated readiness probe at ${GENERATED_READINESS_ROUTE}`);
 	} else nitro.logger.debug("Readiness probe httpGet defined by user; skipping generation");
+	if (options.enableTenantOptionsInvalidationRoute) {
+		const invalidateTenantOptionsHandlerPath = join$1(thisFilePath, "./runtime/handlers/invalidateTenantOptions");
+		handlers.push({
+			route: GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE,
+			handler: invalidateTenantOptionsHandlerPath,
+			method: "GET"
+		});
+		nitro.logger.debug(`Generated tenant option invalidation route at ${GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE}`);
+	}
 	nitro.options.handlers.push(...handlers);
 }
 //#endregion
@@ -558,12 +577,25 @@ function c8y() {
 				name,
 				"@c8y/client"
 			];
+			nitro.options.rolldownConfig = {
+				...nitro.options.rolldownConfig,
+				resolve: {
+					...nitro.options.rolldownConfig?.resolve,
+					alias: {
+						...nitro.options.rolldownConfig?.resolve?.alias,
+						tslib: "tslib/tslib.es6.mjs"
+					}
+				}
+			};
 			if (!nitro.options.preset.startsWith("nitro") && !nitro.options.preset.startsWith("node")) {
 				nitro.logger.error(`Unsupported preset "${nitro.options.preset}" for c8y-nitro module, only node presets are supported.`);
 				throw new Error("Unsupported preset for c8y-nitro module");
 			}
 			let manifest = await createC8yManifestFromNitro(nitro);
-			const { setup: setupEvlog } = evlog({ env: { service: manifest.name } });
+			const { setup: setupEvlog } = evlog({
+				env: { service: manifest.name },
+				exclude: [manifest.livenessProbe?.httpGet?.path, manifest.readinessProbe?.httpGet?.path].filter(Boolean)
+			});
 			await setupEvlog(nitro);
 			if (!options.skipBootstrap) await autoBootstrap(nitro);
 			await setupRuntimeConfig(nitro, options);

package/dist/logging-CVlaRS4O.mjs

@@ -0,0 +1,3 @@
+import "evlog/nitro/v3";
+import { createError } from "evlog";
+export { createError as t };

package/dist/{options-BDDJWdph.mjs → options-Web5UyIU.mjs}

@@ -1,5 +1,5 @@
-import { c as getTenantOptionsByCategory, f as updateTenantOption, i as deleteTenantOption, n as createBasicAuthHeader, p as createC8yManifest, s as getTenantOption } from "./c8y-api-BBSKRwKs.mjs";
-import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-Dqi-ttQi.mjs";
+import { c as getTenantOptionsByCategory, f as upsertTenantOption, i as deleteTenantOption, n as createBasicAuthHeader, p as createC8yManifest, s as getTenantOption } from "./c8y-api-BbRS1-Ls.mjs";
+import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BRnvtthI.mjs";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 //#region src/cli/commands/options.ts
@@ -62,6 +62,7 @@ async function handleRead(baseUrl, category, authHeader, availableKeys, currentO
 		consola.warn("No options are currently set");
 		return;
 	}
+	if (credentialsKeys.length > 0) consola.warn("Encrypted credentials.* options cannot be read in decrypted form with the development user in this CLI.");
 	const key = await consola.prompt("Select option to read:", {
 		type: "select",
 		options: allKeys.map((k) => ({
@@ -71,7 +72,7 @@ async function handleRead(baseUrl, category, authHeader, availableKeys, currentO
 		cancel: "reject"
 	});
 	consola.info(`Reading option: ${key}`);
-	const value = await getTenantOption(baseUrl, category, key.startsWith("credentials.") ? key.replace(/^credentials\./, "") : key, authHeader);
+	const value = await getTenantOption(baseUrl, category, key, authHeader);
 	if (value === void 0) consola.warn(`Option '${key}' is not set`);
 	else consola.success(`Value: ${value}`);
 }
@@ -101,7 +102,7 @@ async function handleUpdate(baseUrl, category, authHeader, availableKeys, curren
 			cancel: "reject"
 		});
 		consola.info(`Updating option: ${key}`);
-		await updateTenantOption(baseUrl, category, key.replace(/^credentials\./, ""), newValue, authHeader);
+		await upsertTenantOption(baseUrl, category, key, newValue, authHeader);
 		currentOptions[key] = newValue;
 		consola.success(`Option '${key}' updated successfully`);
 		if (!await consola.prompt("Update another option?", {
@@ -136,7 +137,8 @@ async function handleDelete(baseUrl, category, authHeader, availableKeys, curren
 	consola.info(`Deleting ${keysToDelete.length} option(s)...`);
 	for (const key of keysToDelete) {
 		consola.info(`Deleting option: ${key}`);
-		await deleteTenantOption(baseUrl, category, key.startsWith("credentials.") ? key.replace(/^credentials\./, "") : key, authHeader);
+		await deleteTenantOption(baseUrl, category, key, authHeader);
+		delete currentOptions[key];
 		consola.success(`✓ Deleted: ${key}`);
 	}
 	consola.success("Delete operation completed");

package/dist/{package-C4HtuVu_.mjs → package-DsLC9Mo3.mjs}

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "c8y-nitro";
-var version = "0.4.2";
+var version = "0.6.0";
 var description = "Lightning fast Cumulocity IoT microservice development powered by Nitro";
 //#endregion
 export { name as n, version as r, description as t };

package/dist/{roles-DJxp2d8p.mjs → roles-D7rpbxPp.mjs}

@@ -1,5 +1,5 @@
-import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-BBSKRwKs.mjs";
-import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-Dqi-ttQi.mjs";
+import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-BbRS1-Ls.mjs";
+import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BRnvtthI.mjs";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 //#region src/cli/commands/roles.ts

package/dist/runtime/handlers/invalidateTenantOptions.mjs

@@ -0,0 +1,35 @@
+import { t as createError } from "../../logging-CVlaRS4O.mjs";
+import { c8yTenantOptionKeys } from "c8y-nitro/runtime";
+import { defineEventHandler, getQuery } from "nitro/h3";
+//#region src/utils/internal/tenantOptionFetchers.ts
+/**
+* Internal storage for cached functions per key
+*/
+const tenantOptionFetchers = {};
+//#endregion
+//#region src/module/runtime/handlers/invalidateTenantOptions.ts
+var invalidateTenantOptions_default = defineEventHandler(async (event) => {
+	const query = getQuery(event);
+	if ("all" in query) {
+		await Promise.all(Object.values(tenantOptionFetchers).map((fetcher) => fetcher?.invalidate()));
+		return { message: "success" };
+	}
+	const key = Array.isArray(query.key) ? query.key[0] : query.key;
+	if (!key) throw createError({
+		status: 400,
+		message: "Provide either the all or key query parameter",
+		why: "The tenant option invalidation route requires an explicit target",
+		fix: "Use ?all to invalidate all created tenant option caches or ?key=<manifest setting key> to invalidate one created cache entry"
+	});
+	if (!c8yTenantOptionKeys.includes(key)) throw createError({
+		status: 400,
+		message: "Invalid tenant option invalidation request",
+		why: "Only tenant option keys declared in manifest.settings can be invalidated via this route",
+		fix: "Use ?all to invalidate all created tenant option caches or provide a valid manifest-defined key in ?key"
+	});
+	const fetcher = tenantOptionFetchers[key];
+	if (fetcher) await fetcher.invalidate();
+	return { message: "success" };
+});
+//#endregion
+export { invalidateTenantOptions_default as default };

package/dist/runtime/middlewares/c8y-client.mjs

@@ -0,0 +1,43 @@
+import { t as createError } from "../../logging-CVlaRS4O.mjs";
+import { defineMiddleware } from "nitro";
+import process from "node:process";
+//#region src/module/runtime/middlewares/c8y-client.ts
+function isC8yClientThrownResponse(error) {
+	if (!error || typeof error !== "object") return false;
+	if (!("res" in error) || !error.res || typeof error.res !== "object") return false;
+	const response = error.res;
+	if (typeof response.status !== "number") return false;
+	const responseUrl = typeof response.url === "string" ? response.url : void 0;
+	const baseUrl = process.env.C8Y_BASEURL?.replace(/\/+$/, "");
+	const matchesConfiguredTenant = Boolean(baseUrl && responseUrl?.startsWith(baseUrl));
+	if ("data" in error && error.data && typeof error.data === "object") {
+		const data = error.data;
+		if (typeof data.info === "string" && data.info.startsWith("https://cumulocity.com/")) return true;
+	}
+	return matchesConfiguredTenant;
+}
+var c8y_client_default = defineMiddleware(async (_event, next) => {
+	try {
+		return await next();
+	} catch (error) {
+		if (!isC8yClientThrownResponse(error)) throw error;
+		const upstreamMessage = error.data?.message || error.res.statusText || "Cumulocity request failed";
+		const upstreamCode = error.data?.error;
+		throw createError({
+			message: "Internal Server Error",
+			status: 500,
+			internal: {
+				help: "An error occurred while processing a request to Cumulocity from the @c8y/client library.",
+				upstream: "@c8y/client",
+				message: upstreamMessage,
+				code: upstreamCode,
+				status: error.res.status,
+				statusText: error.res.statusText,
+				url: error.res.url,
+				data: error.data
+			}
+		});
+	}
+});
+//#endregion
+export { c8y_client_default as default };

package/dist/runtime/middlewares/{dev-user.mjs → dev-user.dev.mjs}

@@ -2,8 +2,8 @@ import { defineHandler } from "nitro/h3";
 import process from "node:process";
 import { Buffer } from "node:buffer";
 import consola from "consola";
-//#region src/module/runtime/middlewares/dev-user.ts
-var dev_user_default = defineHandler((event) => {
+//#region src/module/runtime/middlewares/dev-user.dev.ts
+var dev_user_dev_default = defineHandler((event) => {
 	if (import.meta.dev) {
 		const missingDevVars = [
 			"C8Y_DEVELOPMENT_TENANT",
@@ -20,4 +20,4 @@ var dev_user_default = defineHandler((event) => {
 	}
 });
 //#endregion
-export { dev_user_default as default };
+export { dev_user_dev_default as default };

package/dist/runtime/plugins/{c8y-variables.mjs → c8y-variables.dev.mjs}

@@ -1,7 +1,7 @@
-import process from "node:process";
 import { definePlugin } from "nitro";
-//#region src/module/runtime/plugins/c8y-variables.ts
-var c8y_variables_default = definePlugin(() => {
+import process from "node:process";
+//#region src/module/runtime/plugins/c8y-variables.dev.ts
+var c8y_variables_dev_default = definePlugin(() => {
 	if (import.meta.dev) {
 		const env = process.env;
 		const missingVars = [
@@ -14,4 +14,4 @@ var c8y_variables_default = definePlugin(() => {
 	}
 });
 //#endregion
-export { c8y_variables_default as default };
+export { c8y_variables_dev_default as default };

package/dist/runtime/plugins/enrich-logs.mjs

@@ -1,5 +1,5 @@
-import { definePlugin } from "nitro";
 import { c8yManifest } from "c8y-nitro/runtime";
+import { definePlugin } from "nitro";
 //#region src/module/runtime/plugins/enrich-logs.ts
 var enrich_logs_default = definePlugin(async (nitroApp) => {
 	nitroApp.hooks.hook("evlog:enrich", (enrichContext) => {

package/dist/types.d.mts

@@ -1,2 +1,3 @@
-import { a as C8yCacheOptions, c as C8YManifestOptions, i as C8YRoles, l as C8YAPIClientOptions, n as C8YTenantOptionKey, o as C8YZipOptions, r as C8YTenantOptionKeysCacheConfig, s as C8YManifest, t as C8yNitroModuleOptions } from "./index-CzUqbp5C.mjs";
-export { C8YAPIClientOptions, C8YManifest, C8YManifestOptions, C8YRoles, C8YTenantOptionKey, C8YTenantOptionKeysCacheConfig, C8YZipOptions, C8yCacheOptions, C8yNitroModuleOptions };
+import { a as C8YRoles, c as C8YManifest, i as C8YTenantOptionKeysCacheConfig, l as C8YManifestOptions, n as C8yNitroModuleOptions, o as C8yCacheOptions, r as C8YTenantOptionKey, s as C8YZipOptions, t as C8yDevOptions, u as C8YAPIClientOptions } from "./index-uOwpI6rD.mjs";
+import { t as TenantCredentials } from "./credentials-9FO7rTIR.mjs";
+export { C8YAPIClientOptions, C8YManifest, C8YManifestOptions, C8YRoles, C8YTenantOptionKey, C8YTenantOptionKeysCacheConfig, C8YZipOptions, C8yCacheOptions, C8yDevOptions, C8yNitroModuleOptions, TenantCredentials };

package/dist/utils.d.mts

@@ -1,8 +1,9 @@
+import { t as TenantCredentials } from "./credentials-9FO7rTIR.mjs";
 import { useLogger } from "evlog/nitro/v3";
 import { Client, ICredentials, ICurrentUser } from "@c8y/client";
 import { EventHandler, H3Event } from "nitro/h3";
 import { createError, createLogger } from "evlog";
-import { ServerRequest } from "nitro/types";
+import { ServerRequest, TaskContext, TaskPayload } from "nitro/types";
 import { C8YRoles, C8YTenantOptionKey } from "c8y-nitro/types";
 
 //#region src/utils/client.d.ts
@@ -163,31 +164,9 @@ declare function useUser(requestOrEvent: ServerRequest | H3Event): Promise<ICurr
 declare function useUserRoles(requestOrEvent: ServerRequest | H3Event): Promise<string[]>;
 //#endregion
 //#region src/utils/credentials.d.ts
-/**
- * Fetches credentials for all tenants subscribed to this microservice.\
- * Uses bootstrap credentials from runtime config to query the microservice subscriptions API.\
- * Results are cached based on the configured TTL (default: 10 minutes).\
- * @returns Object mapping tenant IDs to their respective credentials
- * @config Cache TTL can be configured via:
- * - `c8y.cache.credentialsTTL` in the Nitro config (value in seconds)
- * - `NITRO_C8Y_CACHE_CREDENTIALS_TTL` environment variable
- * @example
- * // Get all subscribed tenant credentials:
- * const credentials = await useSubscribedTenantCredentials()
- * console.log(Object.keys(credentials)) // ['t12345', 't67890']
- *
- * // Access specific tenant:
- * const tenant1Creds = credentials['t12345']
- *
- * // Invalidate cache:
- * await useSubscribedTenantCredentials.invalidate()
- *
- * // Force refresh:
- * const freshCreds = await useSubscribedTenantCredentials.refresh()
- */
-declare const useSubscribedTenantCredentials: (() => Promise<Record<string, ICredentials>>) & {
+declare const useSubscribedTenantCredentials: (() => Promise<TenantCredentials>) & {
   invalidate: () => Promise<void>;
-  refresh: () => Promise<Record<string, ICredentials>>;
+  refresh: () => Promise<TenantCredentials>;
 };
 /**
  * Fetches credentials for the tenant where this microservice is deployed.\
@@ -242,11 +221,6 @@ declare function useUserTenantCredentials(requestOrEvent: ServerRequest | H3Even
  * - `c8y.cache.tenantOptions` — Per-key TTL overrides
  * - `NITRO_C8Y_DEFAULT_TENANT_OPTIONS_TTL` — Environment variable for default TTL
  *
- * @note For encrypted options (keys starting with `credentials.`), the value is automatically
- * decrypted by Cumulocity if this microservice is the owner of the option (category matches
- * the microservice's settingsCategory/contextPath/name). The `credentials.` prefix is
- * automatically stripped when calling the API.
- *
  * @example
  * // Fetch a tenant option:
  * const value = await useTenantOption('myOption')
@@ -290,4 +264,110 @@ declare const useTenantOption: ((key: C8YTenantOptionKey) => Promise<string | un
   refreshAll: () => Promise<Record<string, string | undefined>>;
 };
 //#endregion
-export { createError, createLogger, hasUserRequiredRole, isUserFromAllowedTenant, isUserFromDeployedTenant, useDeployedTenantClient, useDeployedTenantCredentials, useLogger, useSubscribedTenantClients, useSubscribedTenantCredentials, useTenantOption, useUser, useUserClient, useUserRoles, useUserTenantClient, useUserTenantCredentials };
+//#region src/utils/schedule.d.ts
+type ScheduledTaskPayload = TaskPayload;
+type ScheduledTaskContext = TaskContext;
+/**
+ * A one-shot schedule definition for `scheduleTask()`.\
+ * Numbers are treated as seconds from now, strings are parsed as human-readable durations
+ * such as `"10 minutes"`, and dates are used as exact run times.
+ */
+type ScheduledTaskInput = Date | number | string;
+/**
+ * Options for scheduling a Nitro task to run once in the future.\
+ * `payload` and `context` are forwarded to the task handler's `run()` method.
+ */
+interface ScheduleTaskOptions {
+  /**
+   * Payload forwarded to the task handler's `TaskEvent.payload`.
+   */
+  payload?: ScheduledTaskPayload;
+  /**
+   * Context forwarded to the task handler's `TaskEvent.context`.
+   */
+  context?: ScheduledTaskContext;
+  /**
+   * When the task should run. Numbers are seconds from now.
+   */
+  schedule: ScheduledTaskInput;
+}
+/**
+ * Public information about a pending scheduled task.\
+ * Returned by `scheduleTask()` and by `listScheduledTasks()`.
+ */
+interface ScheduledTaskInfo {
+  /**
+   * Stable UUID used to list or cancel the scheduled task.
+   */
+  id: string;
+  /**
+   * Nitro task name that will be passed to `runTask()`.
+   */
+  task: string;
+  /**
+   * Exact execution time as an ISO date string.
+   */
+  runAt: string;
+}
+/**
+ * Schedules a Nitro task to run once in the future.\
+ * Resolves and calls the task handler directly from Nitro's virtual task registry\
+ * Numbers are treated as seconds, strings are parsed as human-readable durations, and dates are used as exact run times.
+ *
+ * @param taskName - The Nitro task name to run (from `tasks/*.ts`)
+ * @param options - Task payload, context, and the schedule time
+ * @returns Information about the scheduled task
+ *
+ * @example
+ * // Run a task in 30 seconds:
+ * const scheduled = await scheduleTask('emails:send', {
+ *   payload: { messageId: 'abc123' },
+ *   schedule: 30,
+ * })
+ *
+ * @example
+ * // Run a task using a human-readable duration:
+ * await scheduleTask('reports:generate', {
+ *   payload: { reportId: 'report-1' },
+ *   schedule: '1 hour',
+ * })
+ *
+ * @example
+ * // Run a task at an exact time:
+ * await scheduleTask('cleanup:tenant', {
+ *   payload: { tenant: 't12345' },
+ *   schedule: new Date('2026-05-01T12:00:00Z'),
+ * })
+ */
+declare function scheduleTask(taskName: string, options: ScheduleTaskOptions): Promise<ScheduledTaskInfo>;
+/**
+ * Lists all tasks that are currently scheduled and have not started yet.\
+ * The returned object is keyed by the scheduled task UUID for easy lookup and cancellation.
+ *
+ * @returns Object mapping scheduled task IDs to their public task information
+ *
+ * @example
+ * const tasks = await listScheduledTasks()
+ * for (const [id, task] of Object.entries(tasks)) {
+ *   console.log(id, task.task, task.runAt)
+ * }
+ */
+declare function listScheduledTasks(): Promise<Record<string, ScheduledTaskInfo>>;
+/**
+ * Cancels a scheduled task before it starts running.\
+ * Once the underlying Nitro task has started, it cannot be cancelled with this utility.
+ *
+ * @param id - The scheduled task UUID returned by `scheduleTask()` or `listScheduledTasks()`
+ * @returns `true` when a pending task was cancelled, otherwise `false`
+ *
+ * @example
+ * const scheduled = await scheduleTask('emails:send', {
+ *   payload: { messageId: 'abc123' },
+ *   schedule: '10 minutes',
+ * })
+ *
+ * const cancelled = await cancelScheduledTask(scheduled.id)
+ */
+declare function cancelScheduledTask(id: string): Promise<boolean>;
+//#endregion
+export { ScheduleTaskOptions, ScheduledTaskContext, ScheduledTaskInfo, ScheduledTaskInput, ScheduledTaskPayload, cancelScheduledTask, createError, createLogger, hasUserRequiredRole, isUserFromAllowedTenant, isUserFromDeployedTenant, listScheduledTasks, scheduleTask, useDeployedTenantClient, useDeployedTenantCredentials, useLogger, useSubscribedTenantClients, useSubscribedTenantCredentials, useTenantOption, useUser, useUserClient, useUserRoles, useUserTenantClient, useUserTenantCredentials };