c8y-nitro 0.6.0 → 0.7.1

package/dist/{bootstrap-DUDpmXcU.mjs → bootstrap-ObaEF7rN.mjs}

@@ -1,6 +1,6 @@
-import { a as findMicroserviceByName, d as updateMicroservice, l as subscribeToApplication, 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 validateBootstrapEnv, t as loadC8yConfig } from "./config-BRnvtthI.mjs";
+import { a as findMicroserviceByName, d as updateMicroservice, l as subscribeToApplication, n as createBasicAuthHeader, o as getBootstrapCredentials, p as createC8yManifest, r as createMicroservice } from "./c8y-api-BFjK6AYb.mjs";
+import { t as writeBootstrapCredentials } from "./env-file-BrOTmVjA.mjs";
+import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BVQHqlgV.mjs";
 import { defineCommand, runCommand } from "citty";
 import { consola } from "consola";
 //#region src/cli/commands/bootstrap.ts
@@ -12,11 +12,11 @@ var bootstrap_default = defineCommand({
 	args: {},
 	async run() {
 		consola.info("Loading configuration...");
-		const { env, c8yOptions, configDir } = await loadC8yConfig();
+		const { env, nitroConfig, configDir } = await loadC8yConfig();
 		consola.info("Validating environment variables...");
 		const envVars = validateBootstrapEnv(env);
 		consola.info("Building manifest...");
-		const manifest = await createC8yManifest(configDir, c8yOptions?.manifest);
+		const manifest = await createC8yManifest(configDir, nitroConfig);
 		consola.success(`Manifest created for: ${manifest.name} v${manifest.version}`);
 		const authHeader = createBasicAuthHeader(envVars.C8Y_DEVELOPMENT_TENANT, envVars.C8Y_DEVELOPMENT_USER, envVars.C8Y_DEVELOPMENT_PASSWORD);
 		consola.info(`Checking if microservice "${manifest.name}" exists...`);
@@ -52,7 +52,7 @@ var bootstrap_default = defineCommand({
 		});
 		consola.success(`Bootstrap credentials written to ${envFileName}`);
 		if (manifest.roles && manifest.roles.length > 0) {
-			if (await consola.prompt("Do you want to manage microservice roles for your development user?", { type: "confirm" })) await runCommand(await import("./roles-D7rpbxPp.mjs").then((r) => r.default), { rawArgs: [] });
+			if (await consola.prompt("Do you want to manage microservice roles for your development user?", { type: "confirm" })) await runCommand(await import("./roles-B58Fguop.mjs").then((r) => r.default), { rawArgs: [] });
 		}
 		consola.success("Bootstrap complete!");
 	}

package/dist/{c8y-api-BbRS1-Ls.mjs → c8y-api-BFjK6AYb.mjs}

@@ -6,8 +6,29 @@ const GENERATED_READINESS_ROUTE = "/_c8y_nitro/readiness";
 const GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE = "/_c8y_nitro/invalidate-tenant-options";
 //#endregion
 //#region src/module/manifest.ts
+const DEFAULT_OPENAPI_ROUTE = "/_openapi.json";
 const ROLE_OPTION_MANAGEMENT_READ = "ROLE_OPTION_MANAGEMENT_READ";
-const ROLE_OPTION_MANAGEMENT_ADMIN = "ROLE_OPTION_MANAGEMENT_ADMIN";
+/**
+* Decide whether Nitro will expose an OpenAPI spec in the deployed build,
+* and if so return the configured route (with leading slash).
+* Returns null when OpenAPI is not enabled for production.
+* @param config - Nitro config (or options) to inspect
+*/
+function resolveNitroOpenApiRoute(config) {
+	if (!config.experimental?.openAPI) return null;
+	if (!config.openAPI?.production) return null;
+	return config.openAPI?.route || DEFAULT_OPENAPI_ROUTE;
+}
+/**
+* Pull the parts of a Nitro config that feed manifest generation.
+* @param config - Nitro config (or options) loaded from disk or from a Nitro instance
+*/
+function extractManifestInputs(config) {
+	return {
+		options: config.c8y?.manifest ?? {},
+		openApiSpec: resolveNitroOpenApiRoute(config) ?? void 0
+	};
+}
 function validateManifestSettings(options) {
 	const invalidSettings = options.settings?.filter((setting) => typeof setting.defaultValue !== "string" || setting.defaultValue.length === 0) ?? [];
 	if (invalidSettings.length === 0) return;
@@ -39,13 +60,18 @@ async function readPackageJsonFieldsForManifest(rootDir, logger) {
 	};
 }
 /**
-* Creates a Cumulocity manifest from rootDir and options.
-* Standalone function that can be used by CLI or module.
-* @param rootDir - Directory containing package.json
-* @param options - Manifest options
+* Create a Cumulocity manifest from a project root and its Nitro config.
+* Reads `package.json` for identity fields, takes user manifest options from
+* `nitroConfig.c8y.manifest`, and auto-injects `openApiSpec` when Nitro
+* OpenAPI is enabled for production.
+*
+* Used by both the Nitro module and the CLI commands.
+* @param rootDir - Directory containing the project's `package.json`
+* @param nitroConfig - Nitro config (or options) for this project
 * @param logger - Optional logger for debug output
 */
-async function createC8yManifest(rootDir, options = {}, logger) {
+async function createC8yManifest(rootDir, nitroConfig = {}, logger) {
+	const { options, openApiSpec } = extractManifestInputs(nitroConfig);
 	validateManifestSettings(options);
 	const { name, version, provider, ...restManifestFields } = await readPackageJsonFieldsForManifest(rootDir, logger);
 	const probeFields = {};
@@ -59,7 +85,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 	};
 	const key = `${name}-key`;
 	let requiredRoles = options.requiredRoles ? [...options.requiredRoles] : void 0;
-	if (options.settings && options.settings.length > 0 && !requiredRoles?.includes(ROLE_OPTION_MANAGEMENT_READ) && !requiredRoles?.includes(ROLE_OPTION_MANAGEMENT_ADMIN)) {
+	if (options.settings && options.settings.length > 0 && !requiredRoles?.includes(ROLE_OPTION_MANAGEMENT_READ)) {
 		requiredRoles = [...requiredRoles ?? [], ROLE_OPTION_MANAGEMENT_READ];
 		logger?.debug(`Auto-added ${ROLE_OPTION_MANAGEMENT_READ} to requiredRoles because manifest.settings are defined`);
 	}
@@ -68,6 +94,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 		...probeFields,
 		...options,
 		...requiredRoles !== void 0 ? { requiredRoles } : {},
+		...openApiSpec ? { openApiSpec } : {},
 		provider,
 		name,
 		version,
@@ -75,6 +102,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 		key,
 		type: "MICROSERVICE"
 	};
+	if (openApiSpec) logger?.debug(`Auto-added openApiSpec="${openApiSpec}" to manifest (Nitro OpenAPI is enabled)`);
 	logger?.debug(`Created Cumulocity manifest: ${JSON.stringify(manifest, null, 2)}`);
 	return manifest;
 }
@@ -84,7 +112,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 * @param nitro - The Nitro instance
 */
 async function createC8yManifestFromNitro(nitro) {
-	return createC8yManifest(nitro.options.rootDir, nitro.options.c8y?.manifest, nitro.logger);
+	return createC8yManifest(nitro.options.rootDir, nitro.options, nitro.logger);
 }
 //#endregion
 //#region src/cli/utils/c8y-api.ts

package/dist/cli/index.mjs

@@ -1,4 +1,4 @@
-import { n as name, r as version, t as description } from "../package-DsLC9Mo3.mjs";
+import { n as name, r as version, t as description } from "../package-D5xRshsx.mjs";
 import { defineCommand, runMain } from "citty";
 //#region src/cli/index.ts
 runMain(defineCommand({
@@ -8,9 +8,9 @@ runMain(defineCommand({
 		description
 	},
 	subCommands: {
-		bootstrap: () => import("../bootstrap-DUDpmXcU.mjs").then((r) => r.default),
-		roles: () => import("../roles-D7rpbxPp.mjs").then((r) => r.default),
-		options: () => import("../options-Web5UyIU.mjs").then((r) => r.default)
+		bootstrap: () => import("../bootstrap-ObaEF7rN.mjs").then((r) => r.default),
+		roles: () => import("../roles-B58Fguop.mjs").then((r) => r.default),
+		options: () => import("../options-B7_yb_wr.mjs").then((r) => r.default)
 	}
 }));
 //#endregion

package/dist/client-DxmbyZju.mjs

@@ -0,0 +1,236 @@
+import { t as createError } from "./logging-BUYT8Z2V.mjs";
+import { BasicAuth, Client, MicroserviceClientRequestAuth } from "@c8y/client";
+import { defineCachedFunction } from "nitro/cache";
+import { Buffer } from "node:buffer";
+import { createHash, randomBytes } from "node:crypto";
+import process from "node:process";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { useNitroHooks } from "nitro/app";
+//#region src/utils/internal/common.ts
+/**
+* Converts undici Request headers to the format expected by MicroserviceClientRequestAuth.\
+* Extracts the following headers from the request:
+* - `authorization`: Used for Basic Auth or Bearer token authentication
+* - `cookie`: Used to extract XSRF-TOKEN and authorization token from cookies
+*
+* The MicroserviceClientRequestAuth class will automatically:
+* - Extract XSRF-TOKEN from cookies for CSRF protection
+* - Extract authorization token from cookies (prioritized over header auth)
+* - Fall back to Authorization header if no cookie-based auth is present
+*
+* @param request - The HTTP request containing headers
+* @returns Headers object compatible with \@c8y/client's MicroserviceClientRequestAuth
+*/
+function convertRequestHeadersToC8yFormat(request) {
+	const headers = {};
+	const authorization = request.headers.get("authorization");
+	if (authorization) headers.authorization = authorization;
+	const cookie = request.headers.get("cookie");
+	if (cookie) headers.cookie = cookie;
+	return headers;
+}
+//#endregion
+//#region src/utils/internal/tenant.ts
+const USER_TENANT_CACHE_SALT = randomBytes(32).toString("hex");
+function getCookieValue(cookieHeader, name) {
+	try {
+		const value = cookieHeader?.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`);
+		return value ? value.pop() : void 0;
+	} catch {
+		return;
+	}
+}
+function getCurrentUserTenantCacheKeyMaterial(requestOrEvent) {
+	const request = "req" in requestOrEvent ? requestOrEvent.req : requestOrEvent;
+	const cookieAuth = getCookieValue(request.headers.get("cookie"), "authorization");
+	if (cookieAuth) return `cookie:${cookieAuth}`;
+	const authorization = request.headers.get("authorization");
+	if (authorization) return `header:${authorization}`;
+}
+function createCurrentUserTenantCacheKey(requestOrEvent) {
+	const material = getCurrentUserTenantCacheKeyMaterial(requestOrEvent);
+	if (!material) throw new Error("Cannot create current user tenant cache key without auth material");
+	return createHash("sha256").update(USER_TENANT_CACHE_SALT).update(":").update(material).digest("hex");
+}
+function tryGetTenantFromBasicAuth(requestOrEvent) {
+	const authorization = ("req" in requestOrEvent ? requestOrEvent.req : requestOrEvent).headers.get("authorization");
+	if (!authorization?.startsWith("Basic ")) return;
+	try {
+		const decoded = Buffer.from(authorization.slice(6), "base64").toString("utf8");
+		const separatorIndex = decoded.indexOf(":");
+		const userPart = separatorIndex === -1 ? decoded : decoded.slice(0, separatorIndex);
+		const slashIndex = userPart.indexOf("/");
+		if (slashIndex <= 0) return;
+		return userPart.slice(0, slashIndex);
+	} catch {
+		return;
+	}
+}
+const getCurrentUserTenantId = defineCachedFunction(async (requestOrEvent) => {
+	const basicTenant = tryGetTenantFromBasicAuth(requestOrEvent);
+	if (basicTenant) return basicTenant;
+	return (await useUserClient(requestOrEvent).tenant.current()).data.name;
+}, {
+	maxAge: 60,
+	name: "_c8y_nitro_get_current_user_tenant_id",
+	group: "c8y_nitro",
+	swr: false,
+	getKey: (requestOrEvent) => createCurrentUserTenantCacheKey(requestOrEvent),
+	shouldBypassCache: (requestOrEvent) => !getCurrentUserTenantCacheKeyMaterial(requestOrEvent)
+});
+const cachedTenantDomain = defineCachedFunction(async (requestOrEvent, _tenantId) => {
+	return (await useUserClient(requestOrEvent).tenant.current()).data.domainName;
+}, {
+	maxAge: 86400,
+	name: "_c8y_nitro_get_user_tenant_domain",
+	group: "c8y_nitro",
+	swr: false,
+	getKey: (_requestOrEvent, tenantId) => tenantId
+});
+/**
+* Resolves the public domain of the current user's tenant (e.g. `tenant.cumulocity.com`)
+* via `/tenant/currentTenant` with the user's credentials from the current request.
+* @param requestOrEvent - The H3Event or ServerRequest from the current request
+*/
+async function getUserTenantDomain(requestOrEvent) {
+	const tenantId = await getCurrentUserTenantId(requestOrEvent);
+	return cachedTenantDomain(requestOrEvent, tenantId);
+}
+//#endregion
+//#region src/utils/credentials.ts
+let prevCredentials = null;
+function shouldEmitTenantCredentialsUpdated(prev, next) {
+	if (!prev) return true;
+	const prevTenantIds = Object.keys(prev);
+	const nextTenantIds = Object.keys(next);
+	if (prevTenantIds.length !== nextTenantIds.length) return true;
+	return new Set(nextTenantIds).symmetricDifference(new Set(prevTenantIds)).size > 0;
+}
+/**
+* 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_CREDENTIALS_CACHE_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()
+*/
+const cachedSubscribedTenantCredentials = defineCachedFunction(async () => {
+	const newCredentials = (await Client.getMicroserviceSubscriptions({
+		tenant: process.env.C8Y_BOOTSTRAP_TENANT,
+		user: process.env.C8Y_BOOTSTRAP_USER,
+		password: process.env.C8Y_BOOTSTRAP_PASSWORD
+	}, process.env.C8Y_BASEURL)).reduce((acc, cred) => {
+		if (cred.tenant) acc[cred.tenant] = cred;
+		return acc;
+	}, {});
+	if (shouldEmitTenantCredentialsUpdated(prevCredentials, newCredentials)) useNitroHooks().callHook("c8y:tenantCredentialsUpdated", prevCredentials, newCredentials);
+	prevCredentials = newCredentials;
+	return newCredentials;
+}, {
+	maxAge: useRuntimeConfig().c8yCredentialsCacheTTL ?? 600,
+	name: "_c8y_nitro_get_subscribed_tenant_credentials",
+	group: "c8y_nitro",
+	swr: false
+});
+const useSubscribedTenantCredentials = Object.assign(async () => {
+	const credentials = await cachedSubscribedTenantCredentials();
+	prevCredentials = credentials;
+	return credentials;
+}, {
+	invalidate: cachedSubscribedTenantCredentials.invalidate,
+	refresh: async () => {
+		await cachedSubscribedTenantCredentials.invalidate();
+		const credentials = await cachedSubscribedTenantCredentials();
+		prevCredentials = credentials;
+		return credentials;
+	}
+});
+/**
+* Fetches credentials for the tenant where this microservice is deployed.\
+* Uses the C8Y_BOOTSTRAP_TENANT environment variable to identify the deployed tenant.\
+* Returns credentials from the subscribed tenant credentials cache (cached based on configured TTL, default: 10 minutes).
+* @returns Credentials for the deployed tenant
+* @throws {EvlogError} If no credentials found for the deployed tenant
+* @example
+* // Get deployed tenant credentials:
+* const creds = await useDeployedTenantCredentials()
+* console.log(creds.tenant, creds.user)
+*
+* // Invalidate cache:
+* await useDeployedTenantCredentials.invalidate()
+*
+* // Force refresh:
+* const freshCreds = await useDeployedTenantCredentials.refresh()
+* @note This function is not cached separately. It uses the cache of `useSubscribedTenantCredentials()`. Invalidating or refreshing one will refresh `useDeployedTenantCredentials()`s cache.
+*/
+const useDeployedTenantCredentials = Object.assign(async () => {
+	const tenant = process.env.C8Y_BOOTSTRAP_TENANT;
+	const allCredsPromise = await useSubscribedTenantCredentials();
+	if (!allCredsPromise[tenant]) throw createError({
+		message: `No credentials found for tenant deployed tenant '${tenant}'`,
+		status: 500
+	});
+	return allCredsPromise[tenant];
+}, {
+	invalidate: useSubscribedTenantCredentials.invalidate,
+	refresh: async () => {
+		await useSubscribedTenantCredentials.refresh();
+		return await useDeployedTenantCredentials();
+	}
+});
+//#endregion
+//#region src/utils/client.ts
+/**
+* Creates a Cumulocity client authenticated with the current user's credentials.\
+* Extracts credentials from the Authorization header of the current request.
+* @param requestOrEvent - The H3Event or ServerRequest from the current request
+* @returns A configured Cumulocity Client instance
+* @example
+* // In a request handler:
+* const client = useUserClient(event)
+* const { data } = await client.inventory.list()
+*/
+function useUserClient(requestOrEvent) {
+	const request = "req" in requestOrEvent ? requestOrEvent.req : requestOrEvent;
+	if (request.context?.["c8y_user_client"]) return request.context["c8y_user_client"];
+	const client = new Client(new MicroserviceClientRequestAuth(convertRequestHeadersToC8yFormat(request)), process.env.C8Y_BASEURL);
+	request.context ??= {};
+	request.context["c8y_user_client"] = client;
+	return client;
+}
+/**
+* Creates a Cumulocity client for the tenant where this microservice is deployed.\
+* Uses the bootstrap tenant ID from runtime config to identify the deployed tenant.\
+* @returns A configured Cumulocity Client instance for the deployed tenant
+* @example
+* // Get client for the tenant hosting this microservice:
+* const client = await useDeployedTenantClient()
+* const { data } = await client.application.list()
+*/
+async function useDeployedTenantClient() {
+	const creds = await useSubscribedTenantCredentials();
+	const tenant = process.env.C8Y_BOOTSTRAP_TENANT;
+	if (!creds[tenant]) throw createError({
+		message: `No subscribed tenant credentials found for tenant '${tenant}'`,
+		status: 500
+	});
+	const client = new Client(new BasicAuth(creds[tenant]), process.env.C8Y_BASEURL);
+	client.core.tenant = tenant;
+	return client;
+}
+//#endregion
+export { getUserTenantDomain as n, useDeployedTenantClient as t };

package/dist/{credentials-9FO7rTIR.d.mts → credentials-eKnJ7m9Y.d.mts}

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

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

@@ -1,5 +1,5 @@
+import "./credentials-eKnJ7m9Y.mjs";
 import { C8YTenantOptionKeysCacheConfig } from "c8y-nitro/types";
-
 //#region src/types/apiClient.d.ts
 interface C8YAPIClientOptions {
   /**
@@ -16,7 +16,7 @@ interface C8YAPIClientOptions {
 }
 //#endregion
 //#region src/types/manifest.d.ts
-type C8YManifestOptions = Omit<C8YManifest, 'name' | 'version' | 'apiVersion' | 'key' | 'type' | 'provider'>;
+type C8YManifestOptions = Omit<C8YManifest, 'name' | 'version' | 'apiVersion' | 'key' | 'type' | 'provider' | 'openApiSpec'>;
 interface C8YManifest {
   /**
    * API version (e.g., "v2", "2"). Version 2 required for enhanced container security.
@@ -126,6 +126,16 @@ interface C8YManifest {
    * Platform extensions (e.g., UI plugins).
    */
   extensions?: Extension[];
+  /**
+   * OpenAPI specification path exposed by this microservice. Auto-populated
+   * by c8y-nitro when Nitro's `experimental.openAPI` is enabled and
+   * `openAPI.production` is configured. Used by clients (e.g., mc8yp) to
+   * auto-discover the API.
+   *
+   * Path is relative to the microservice context path.
+   * @example "/_openapi.json"
+   */
+  openApiSpec?: string;
 }
 /**
  * Company/organization information.
@@ -373,6 +383,30 @@ interface C8yCacheOptions {
   tenantOptions?: C8YTenantOptionKeysCacheConfig;
 }
 //#endregion
+//#region src/types/docker.d.ts
+interface C8yDockerOptions {
+  /**
+   * Base image for the generated Dockerfile.
+   *
+   * Use this when the default slim image is missing something the service
+   * needs at runtime (e.g. CA certificates, native runtime libraries).
+   * @default 'node:24-slim'
+   */
+  baseImage?: string;
+  /**
+   * Raw Dockerfile instructions inserted after `WORKDIR` and before the build
+   * output is copied, one instruction per entry.
+   *
+   * Placing them before the `COPY` keeps their layers cached across rebuilds.
+   * `ENV`, `EXPOSE 80` and the `CMD` entrypoint stay under module control and
+   * cannot be overridden — they are the Cumulocity microservice contract.
+   *
+   * @example ['RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && rm -rf /var/lib/apt/lists/*']
+   * @default []
+   */
+  extraInstructions?: string[];
+}
+//#endregion
 //#region src/types/roles.d.ts
 interface C8YRoles$1 {}
 //#endregion
@@ -383,10 +417,16 @@ interface C8YRoles$1 {}
  */
 type C8YTenantOptionKeysCacheConfig$1 = Partial<Record<C8YTenantOptionKey$1, number>>;
 /**
- * Type for tenant option keys.
+ * Union of tenant option keys declared in `manifest.settings`.
  * Overwritten by generated types from manifest settings (manifest.settings[].key).
  */
 type C8YTenantOptionKey$1 = string;
+/**
+ * The microservice's own tenant option settings category, resolved from
+ * `manifest.settingsCategory` (falling back to `contextPath`, then `name`).
+ * Overwritten by generated types from the manifest.
+ */
+type C8YSettingsCategory$1 = string;
 //#endregion
 //#region src/types/index.d.ts
 interface C8yDevOptions {
@@ -399,12 +439,38 @@ interface C8yDevOptions {
    */
   injectUser?: boolean;
 }
+interface C8yOpenAPIOptions {
+  /**
+   * Strip internal routes from the served OpenAPI document.
+   * Removes every route starting with `/_` (generated probes, `/_c8y_nitro/**`
+   * and the OpenAPI/Scalar/Swagger routes themselves) as well as user-defined
+   * probe `httpGet` paths.
+   * @default true
+   */
+  excludeInternalRoutes?: boolean;
+  /**
+   * Additional route prefixes to strip from the served OpenAPI document.
+   * Entries are matched as path prefixes (e.g. `/internal` also removes `/internal/status`).
+   * @default []
+   */
+  excludeRoutes?: string[];
+}
 interface C8yNitroModuleOptions {
   dev?: C8yDevOptions;
   manifest?: C8YManifestOptions;
   apiClient?: C8YAPIClientOptions;
   zip?: C8YZipOptions;
+  /**
+   * Controls the Dockerfile generated for the microservice image
+   * (base image, extra instructions).
+   */
+  docker?: C8yDockerOptions;
   cache?: C8yCacheOptions;
+  /**
+   * Controls how the OpenAPI document served by Nitro (`experimental.openAPI`)
+   * is transformed for Cumulocity microservices.
+   */
+  openapi?: C8yOpenAPIOptions;
   /**
    * Adds a debug route for invalidating already-created tenant option caches.
    * Exposes `GET /_c8y_nitro/invalidate-tenant-options`.
@@ -428,4 +494,4 @@ interface C8yNitroModuleOptions {
   skipBootstrap?: boolean;
 }
 //#endregion
-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 };
+export { C8YTenantOptionKey$1 as a, C8yDockerOptions as c, C8YManifest as d, C8YManifestOptions as f, C8YSettingsCategory$1 as i, C8yCacheOptions as l, C8yNitroModuleOptions as n, C8YTenantOptionKeysCacheConfig$1 as o, C8YAPIClientOptions as p, C8yOpenAPIOptions as r, C8YRoles$1 as s, C8yDevOptions as t, C8YZipOptions as u };

package/dist/index.d.mts

@@ -1,7 +1,6 @@
-import { n as C8yNitroModuleOptions } from "./index-uOwpI6rD.mjs";
-import { t as TenantCredentials } from "./credentials-9FO7rTIR.mjs";
+import { n as C8yNitroModuleOptions } from "./index-vu4xaFkz.mjs";
+import { t as TenantCredentials } from "./credentials-eKnJ7m9Y.mjs";
 import { NitroModule } from "nitro/types";
-
 //#region src/index.d.ts
 declare module 'nitro/types' {
   interface NitroOptions {