nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/nitro/adapter.mjs

@@ -0,0 +1,97 @@
+import { scanDirectivesCore } from "../core/scanning/directives.mjs";
+import { scanDocumentsCore } from "../core/scanning/documents.mjs";
+import { scanResolversCore } from "../core/scanning/resolvers.mjs";
+import { scanGraphqlCore, scanSchemasCore } from "../core/scanning/schemas.mjs";
+import { join, relative } from "pathe";
+
+//#region src/nitro/adapter.ts
+/**
+* Create a CoreLogger from Nitro's logger
+*/
+function createLoggerFromNitro(nitro) {
+	return {
+		info: (msg, ...args) => nitro.logger.info(msg, ...args),
+		warn: (msg, ...args) => nitro.logger.warn(msg, ...args),
+		error: (msg, ...args) => nitro.logger.error(msg, ...args),
+		success: (msg, ...args) => nitro.logger.success(msg, ...args),
+		debug: (msg, ...args) => nitro.logger.debug(msg, ...args)
+	};
+}
+/**
+* Create a ScanContext from Nitro instance
+*/
+function createScanContextFromNitro(nitro) {
+	return {
+		rootDir: nitro.options.rootDir,
+		serverDir: nitro.graphql.serverDir,
+		clientDir: nitro.graphql.clientDir,
+		ignorePatterns: nitro.options.ignore,
+		isDev: nitro.options.dev,
+		logger: createLoggerFromNitro(nitro),
+		layerServerDirs: nitro.options.graphql?.layerServerDirs || [],
+		layerAppDirs: nitro.options.graphql?.layerAppDirs || []
+	};
+}
+/**
+* Create a CoreConfig from Nitro instance
+*/
+function createCoreConfigFromNitro(nitro) {
+	const graphqlOptions = nitro.options.graphql || {};
+	const isNuxt = nitro.options.framework?.name === "nuxt";
+	const typesDir = join(nitro.graphql.buildDir, "types");
+	return {
+		rootDir: nitro.options.rootDir,
+		buildDir: nitro.graphql.buildDir,
+		serverDir: nitro.graphql.serverDir,
+		clientDir: nitro.graphql.clientDir,
+		typesDir,
+		framework: graphqlOptions.framework || "graphql-yoga",
+		isNuxt,
+		isDev: nitro.options.dev,
+		graphqlOptions: {
+			framework: graphqlOptions.framework,
+			endpoint: typeof graphqlOptions.endpoint === "object" ? graphqlOptions.endpoint?.graphql : graphqlOptions.endpoint,
+			federation: graphqlOptions.federation,
+			security: graphqlOptions.security
+		},
+		logger: createLoggerFromNitro(nitro),
+		ignorePatterns: nitro.options.ignore,
+		layerServerDirs: nitro.options.graphql?.layerServerDirs || [],
+		layerAppDirs: nitro.options.graphql?.layerAppDirs || []
+	};
+}
+/**
+* Create a CoreContext from Nitro instance
+*/
+function createCoreContextFromNitro(nitro) {
+	return {
+		config: createCoreConfigFromNitro(nitro),
+		graphqlBuildDir: nitro.graphql.buildDir,
+		watchDirs: nitro.graphql.watchDirs,
+		dir: nitro.graphql.dir
+	};
+}
+/**
+* Nitro framework adapter implementation
+*/
+const NitroAdapter = {
+	name: "nitro",
+	createCoreConfig: createCoreConfigFromNitro,
+	createCoreContext: createCoreContextFromNitro,
+	createScanContext: createScanContextFromNitro,
+	getLogger: createLoggerFromNitro,
+	scanSchemas: (nitro) => scanSchemasCore(createScanContextFromNitro(nitro)),
+	scanGraphql: (nitro) => scanGraphqlCore(createScanContextFromNitro(nitro)),
+	scanResolvers: (nitro) => scanResolversCore(createScanContextFromNitro(nitro)),
+	scanDirectives: (nitro) => scanDirectivesCore(createScanContextFromNitro(nitro)),
+	scanDocuments(nitro) {
+		return scanDocumentsCore(createScanContextFromNitro(nitro), {
+			externalServices: nitro.options.graphql?.externalServices,
+			clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+		});
+	}
+};
+var adapter_default = NitroAdapter;
+
+//#endregion
+export { NitroAdapter, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro, adapter_default as default };

package/dist/{utils/apollo.d.ts → nitro/apollo.d.mts}

@@ -1,9 +1,9 @@
 import { ApolloServer, BaseContext, ContextFunction } from "@apollo/server";
-import { EventHandler, H3Event } from "h3";
-import { WithRequired } from "@apollo/utils.withrequired";
+import { EventHandler, H3Event } from "nitro/h3";
 import { Hooks } from "crossws";
 
-//#region src/utils/apollo.d.ts
+//#region src/nitro/apollo.d.ts
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 interface H3ContextFunctionArgument {
   event: H3Event;
 }

package/dist/nitro/apollo.mjs

@@ -0,0 +1,59 @@
+import { HeaderMap } from "@apollo/server";
+import { eventHandler, getRequestURL, readBody } from "nitro/h3";
+
+//#region src/nitro/apollo.ts
+function startServerAndCreateH3Handler(server, options) {
+	const defaultContext = () => Promise.resolve({});
+	const contextFunction = options?.context ?? defaultContext;
+	return eventHandler(async (event) => {
+		const apolloServer = typeof server === "function" ? server() : server;
+		if (!options?.serverAlreadyStarted) apolloServer.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+		if (event.req.method === "OPTIONS") {
+			event.res.status = 204;
+			return null;
+		}
+		try {
+			const graphqlRequest = await toGraphqlRequest(event);
+			const { body, headers, status } = await apolloServer.executeHTTPGraphQLRequest({
+				httpGraphQLRequest: graphqlRequest,
+				context: () => contextFunction({ event })
+			});
+			if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
+			for (const [key, value] of headers) event.res.headers.set(key, value);
+			event.res.status = status || 200;
+			return body.string;
+		} catch (error) {
+			if (error instanceof SyntaxError) {
+				event.res.status = 400;
+				return error.message;
+			} else throw error;
+		}
+	});
+}
+async function toGraphqlRequest(event) {
+	const url = getRequestURL(event);
+	return {
+		method: event.req.method || "POST",
+		headers: normalizeHeaders(Object.fromEntries(event.req.headers.entries())),
+		search: url.search.slice(1),
+		body: await normalizeBody(event)
+	};
+}
+function normalizeHeaders(headers) {
+	const headerMap = new HeaderMap();
+	for (const [key, value] of Object.entries(headers)) if (value !== void 0) headerMap.set(key, value);
+	return headerMap;
+}
+async function normalizeBody(event) {
+	const PayloadMethods = [
+		"PATCH",
+		"POST",
+		"PUT",
+		"DELETE"
+	];
+	const method = event.req.method;
+	if (method && PayloadMethods.includes(method)) return await readBody(event);
+}
+
+//#endregion
+export { startServerAndCreateH3Handler };

package/dist/nitro/codegen.d.mts

@@ -0,0 +1,19 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/codegen.d.ts
+
+/**
+ * Generate server-side resolver types
+ */
+declare function generateServerTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+/**
+ * Generate client-side operation types
+ */
+declare function generateClientTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateClientTypes, generateServerTypes };

package/dist/nitro/codegen.mjs

@@ -0,0 +1,141 @@
+import { LOG_TAG } from "../core/constants.mjs";
+import { loadGraphQLDocuments } from "../core/codegen/document-loader.mjs";
+import { writeFile } from "../core/utils/file-io.mjs";
+import { downloadAndSaveSchema, loadExternalSchema } from "../core/codegen/schema-loader.mjs";
+import { generateClientTypesCore, generateExternalClientTypesCore } from "../core/codegen/client.mjs";
+import { generateServerTypesCore } from "../core/codegen/server.mjs";
+import { validateNoDuplicateTypes } from "../core/codegen/validation.mjs";
+import { loadFederationSupport } from "../core/schema/federation.mjs";
+import { getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateTypes } from "./paths.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { buildSchema, parse, print } from "graphql";
+import { existsSync, readFileSync } from "node:fs";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { loadFilesSync } from "@graphql-tools/load-files";
+
+//#region src/nitro/codegen.ts
+const logger = consola.withTag(LOG_TAG);
+async function buildSchemaFromString(source, federation) {
+	if (federation) {
+		const buildSubgraph = await loadFederationSupport();
+		if (!buildSubgraph) throw new Error("Federation enabled but @apollo/subgraph not installed");
+		return buildSubgraph([{ typeDefs: parse(source) }]);
+	}
+	return buildSchema(source);
+}
+/**
+* Generate server-side resolver types
+*/
+async function generateServerTypes(nitro, options = {}) {
+	if (!shouldGenerateTypes(nitro)) return;
+	const schemas = nitro.scanSchemas || [];
+	if (!schemas.length) {
+		if (!options.silent) consola.info("No GraphQL schemas found");
+		return;
+	}
+	try {
+		const strings = loadFilesSync(schemas).map((s) => typeof s === "string" ? s : s.loc?.source?.body || "").filter(Boolean);
+		if (!validateNoDuplicateTypes(schemas, strings)) return;
+		const merged = mergeTypeDefs([strings.join("\n\n")], { throwOnConflict: true });
+		const federation = nitro.options.graphql?.federation?.enabled === true;
+		const schema = await buildSchemaFromString(print(merged), federation);
+		const result = await generateServerTypesCore({
+			framework: nitro.options.graphql?.framework || "graphql-yoga",
+			schema,
+			config: nitro.options.graphql?.codegen?.server,
+			federationEnabled: federation
+		});
+		writeFile(resolve(nitro.graphql.buildDir, "schema.graphql"), printSchemaWithDirectives(schema));
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const typesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, result.types);
+			if (!options.silent) logger.success(`Server types: ${typesPath}`);
+		}
+	} catch (error) {
+		logger.error("Server type generation failed:", error);
+	}
+}
+/**
+* Generate client-side operation types
+*/
+async function generateClientTypes(nitro, options = {}) {
+	try {
+		if (nitro.scanSchemas?.length) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalTypes(nitro, options);
+	} catch (error) {
+		logger.error("Client type generation failed:", error);
+	}
+}
+async function generateMainClientTypes(nitro, options = {}) {
+	const schemaPath = join(nitro.graphql.buildDir, "schema.graphql");
+	if (!existsSync(schemaPath)) {
+		if (!options.silent) consola.info("Schema not ready for client types");
+		return;
+	}
+	const docs = await loadGraphQLDocuments(nitro.scanDocuments);
+	const federation = nitro.options.graphql?.federation?.enabled === true;
+	const types = await generateClientTypesCore({
+		schema: await buildSchemaFromString(readFileSync(schemaPath, "utf-8"), federation),
+		documents: docs,
+		config: nitro.options.graphql?.codegen?.client,
+		sdkConfig: nitro.options.graphql?.codegen?.clientSDK,
+		options
+	});
+	if (types === false) return;
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	const sdkConfig = getSdkConfig(nitro);
+	const clientPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientPath) {
+		writeFile(clientPath, types.types);
+		if (!options.silent) logger.success(`Client types: ${clientPath}`);
+	}
+	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientDir}/default/sdk.ts", placeholders);
+	if (sdkPath) {
+		writeFile(sdkPath, types.sdk);
+		if (!options.silent) logger.success(`SDK: ${sdkPath}`);
+	}
+}
+async function generateExternalTypes(nitro, options = {}) {
+	for (const service of nitro.options.graphql?.externalServices || []) try {
+		if (!options.silent) consola.info(`[${service.name}] Processing external service`);
+		await downloadAndSaveSchema(service, nitro.options.buildDir);
+		const schema = await loadExternalSchema(service, nitro.options.buildDir);
+		if (!schema) {
+			consola.warn(`[${service.name}] Failed to load schema`);
+			continue;
+		}
+		const docs = service.documents?.length ? await loadGraphQLDocuments(service.documents).catch(() => []) : [];
+		if (service.documents?.length && !docs.length) {
+			consola.warn(`[${service.name}] No documents found`);
+			continue;
+		}
+		const types = await generateExternalClientTypesCore(service, schema, docs);
+		if (types === false) continue;
+		const placeholders = {
+			...getDefaultPaths(nitro),
+			serviceName: service.name
+		};
+		const typesConfig = getTypesConfig(nitro);
+		const sdkConfig = getSdkConfig(nitro);
+		const typesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, types.types);
+			if (!options.silent) consola.success(`[${service.name}] Types: ${typesPath}`);
+		}
+		const sdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientDir}/{serviceName}/sdk.ts", placeholders);
+		if (sdkPath) {
+			writeFile(sdkPath, types.sdk);
+			if (!options.silent) consola.success(`[${service.name}] SDK: ${sdkPath}`);
+		}
+	} catch (error) {
+		consola.error(`[${service.name}] External service failed:`, error);
+	}
+}
+
+//#endregion
+export { generateClientTypes, generateServerTypes };

package/dist/nitro/config.d.mts

@@ -0,0 +1,51 @@
+import { NitroGraphQLOptions } from "./types.mjs";
+
+//#region src/nitro/config.d.ts
+
+/**
+ * Default type generation configuration
+ */
+declare const DEFAULT_TYPES_CONFIG: {
+  readonly server: ".graphql/nitro-graphql-server.d.ts";
+  readonly client: ".graphql/nitro-graphql-client.d.ts";
+  readonly enabled: true;
+};
+/**
+ * Default runtime GraphQL configuration
+ */
+declare const DEFAULT_RUNTIME_CONFIG: NitroGraphQLOptions;
+/**
+ * Default ignore patterns for file watching
+ */
+declare const DEFAULT_IGNORE_PATTERNS: string[];
+/**
+ * Default SDK configuration
+ */
+declare const DEFAULT_SDK_CONFIG: {
+  readonly enabled: true;
+  readonly main: true;
+  readonly external: true;
+};
+/**
+ * Default paths configuration
+ * These are used as placeholders and resolved based on framework
+ */
+declare const DEFAULT_PATHS_CONFIG: {
+  readonly serverDir: "server/graphql";
+  readonly clientDir: null;
+  readonly typesDir: null;
+};
+/**
+ * Default TypeScript strict mode setting
+ */
+declare const DEFAULT_TYPESCRIPT_STRICT: true;
+/**
+ * Default watcher persistence setting
+ */
+declare const DEFAULT_WATCHER_PERSISTENT: true;
+/**
+ * Default watcher ignore initial setting
+ */
+declare const DEFAULT_WATCHER_IGNORE_INITIAL: true;
+//#endregion
+export { DEFAULT_IGNORE_PATTERNS, DEFAULT_PATHS_CONFIG, DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };

package/dist/nitro/config.mjs

@@ -0,0 +1,57 @@
+import { DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH } from "../core/constants.mjs";
+
+//#region src/nitro/config.ts
+/**
+* Default type generation configuration
+*/
+const DEFAULT_TYPES_CONFIG = {
+	server: DEFAULT_SERVER_TYPES_PATH,
+	client: DEFAULT_CLIENT_TYPES_PATH,
+	enabled: true
+};
+/**
+* Default runtime GraphQL configuration
+*/
+const DEFAULT_RUNTIME_CONFIG = {
+	endpoint: {
+		graphql: ENDPOINT_GRAPHQL,
+		healthCheck: ENDPOINT_HEALTH
+	},
+	playground: true
+};
+/**
+* Default ignore patterns for file watching
+*/
+const DEFAULT_IGNORE_PATTERNS = [];
+/**
+* Default SDK configuration
+*/
+const DEFAULT_SDK_CONFIG = {
+	enabled: true,
+	main: true,
+	external: true
+};
+/**
+* Default paths configuration
+* These are used as placeholders and resolved based on framework
+*/
+const DEFAULT_PATHS_CONFIG = {
+	serverDir: "server/graphql",
+	clientDir: null,
+	typesDir: null
+};
+/**
+* Default TypeScript strict mode setting
+*/
+const DEFAULT_TYPESCRIPT_STRICT = true;
+/**
+* Default watcher persistence setting
+*/
+const DEFAULT_WATCHER_PERSISTENT = true;
+/**
+* Default watcher ignore initial setting
+*/
+const DEFAULT_WATCHER_IGNORE_INITIAL = true;
+
+//#endregion
+export { DEFAULT_IGNORE_PATTERNS, DEFAULT_PATHS_CONFIG, DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };

package/dist/nitro/index.d.mts

@@ -0,0 +1,46 @@
+import { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroGraphQLOptions, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig } from "./types.mjs";
+import { NitroAdapter } from "./adapter.mjs";
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupNitroGraphQL } from "./setup.mjs";
+import { NitroModule } from "nitro/types";
+import { Plugin } from "vite";
+
+//#region src/nitro/index.d.ts
+
+/**
+ * Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+ * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+ * and automatically sets up the nitro-graphql module via the nitro: hook
+ *
+ * @example - Vite usage
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import { nitro } from 'nitro/vite'
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+ *     nitro()
+ *   ]
+ * })
+ * ```
+ *
+ *
+ * @example - Nitro direct usage
+ * ```ts
+ *
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   modules: [
+ *    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+ *   ]
+ * })
+ * ```
+ */
+declare function graphqlModule(options?: NitroGraphQLOptions): Plugin & {
+  nitro?: NitroModule;
+};
+//#endregion
+export { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroAdapter, NitroGraphQLOptions, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/index.mjs

@@ -0,0 +1,65 @@
+import { NitroAdapter } from "./adapter.mjs";
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupNitroGraphQL } from "./setup.mjs";
+import { readFile } from "node:fs/promises";
+import defu from "defu";
+
+//#region src/nitro/index.ts
+/**
+* Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+* This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+* and automatically sets up the nitro-graphql module via the nitro: hook
+*
+* @example - Vite usage
+* ```ts
+* import { defineConfig } from 'vite'
+* import { nitro } from 'nitro/vite'
+* import graphql from 'nitro-graphql'
+*
+* export default defineConfig({
+*   plugins: [
+*     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+*     nitro()
+*   ]
+* })
+* ```
+*
+*
+* @example - Nitro direct usage
+* ```ts
+*
+* import graphql from 'nitro-graphql'
+*
+* export default defineConfig({
+*   modules: [
+*    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+*   ]
+* })
+* ```
+*/
+function graphqlModule(options) {
+	return {
+		name: "nitro-graphql",
+		enforce: "pre",
+		async load(id) {
+			if (!/\.(?:graphql|gql)$/i.test(id)) return null;
+			try {
+				const content = await readFile(id, "utf-8");
+				return `export default ${JSON.stringify(content)}`;
+			} catch (error) {
+				if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		nitro: { async setup(nitro) {
+			if (options) nitro.options.graphql = defu(nitro.options.graphql || {}, options);
+			nitro.options.graphql = nitro.options.graphql || {};
+			nitro.options.graphql._vitePlugin = true;
+			await setupNitroGraphQL(nitro);
+		} }
+	};
+}
+var nitro_default = graphqlModule;
+
+//#endregion
+export { NitroAdapter, nitro_default as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/paths.d.mts

@@ -0,0 +1,54 @@
+import { FileGenerationConfig, SdkConfig, TypesConfig } from "./types.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/paths.d.ts
+
+/**
+ * Placeholder values for path resolution
+ */
+interface PathPlaceholders {
+  serviceName?: string;
+  buildDir: string;
+  rootDir: string;
+  framework: 'nuxt' | 'nitro';
+  typesDir: string;
+  serverDir: string;
+  clientDir: string;
+}
+/**
+ * Replace placeholders in a path string
+ * Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverDir}, {clientDir}
+ */
+declare function replacePlaceholders(path: string, placeholders: PathPlaceholders): string;
+/**
+ * Get default paths based on framework and user configuration
+ */
+declare function getDefaultPaths(nitro: Nitro): Required<PathPlaceholders>;
+/**
+ * Check if a file should be generated based on config
+ * Returns: true if should generate, false if should skip
+ */
+declare function shouldGenerateFile(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean): boolean;
+/**
+ * Resolve the file path based on configuration
+ * Returns: resolved absolute path or null if file should not be generated
+ */
+declare function resolveFilePath(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean, defaultPath: string, placeholders: PathPlaceholders): string | null;
+/**
+ * Check if SDK files should be generated (category-level check)
+ */
+declare function shouldGenerateSdk(nitro: Nitro): boolean;
+/**
+ * Get SDK configuration (handles false case)
+ */
+declare function getSdkConfig(nitro: Nitro): SdkConfig;
+/**
+ * Check if type files should be generated (category-level check)
+ */
+declare function shouldGenerateTypes(nitro: Nitro): boolean;
+/**
+ * Get types configuration (handles false case)
+ */
+declare function getTypesConfig(nitro: Nitro): TypesConfig;
+//#endregion
+export { PathPlaceholders, getDefaultPaths, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateFile, shouldGenerateSdk, shouldGenerateTypes };