nitro-graphql 2.0.0-beta.37 → 2.0.0-beta.39

package/dist/cli/config.d.mts

@@ -0,0 +1,75 @@
+import { GraphQLFramework } from "../core/constants.mjs";
+import { CoreClientUtilsConfig, CoreCodegenConfig, CoreExternalService, CoreFederationConfig, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig } from "../core/types/config.mjs";
+import "../core/types/index.mjs";
+
+//#region src/cli/config.d.ts
+
+/**
+ * CLI configuration options
+ * Used when running nitro-graphql as a standalone CLI tool
+ */
+interface CLIConfig {
+  /** Root directory (defaults to current working directory) */
+  rootDir?: string;
+  /** Build output directory */
+  buildDir?: string;
+  /** Server GraphQL directory (defaults to 'server/graphql') */
+  serverDir?: string;
+  /** Client GraphQL directory (defaults to 'graphql') */
+  clientDir?: string;
+  /** Types output directory */
+  typesDir?: string;
+  /** GraphQL framework (defaults to 'graphql-yoga') */
+  framework?: GraphQLFramework;
+  /** Codegen configuration */
+  codegen?: CoreCodegenConfig;
+  /** Security configuration */
+  security?: CoreSecurityConfig;
+  /** External GraphQL services */
+  externalServices?: CoreExternalService[];
+  /** Apollo Federation configuration */
+  federation?: CoreFederationConfig;
+  /** Path configuration */
+  paths?: CorePathsConfig;
+  /** Scaffold file configuration */
+  scaffold?: false | CoreScaffoldConfig;
+  /** Type generation configuration */
+  types?: false | CoreTypesConfig;
+  /** SDK generation configuration */
+  sdk?: false | CoreSdkConfig;
+  /** Client utilities configuration */
+  clientUtils?: false | CoreClientUtilsConfig;
+  /** Patterns to ignore during scanning */
+  ignore?: string[];
+  /** Watch mode configuration */
+  watch?: {
+    /** Enable watch mode */
+    enabled?: boolean;
+    /** Debounce time in ms */
+    debounce?: number;
+  };
+  /**
+   * Runtime file generation
+   * Generates resolvers.ts, schema.ts for standalone server usage
+   */
+  runtime?: boolean | {
+    /** Output directory for runtime files (defaults to '{buildDir}/runtime') */
+    outDir?: string;
+    /** What to include in generation */
+    include?: {
+      resolvers?: boolean;
+      schema?: boolean;
+      index?: boolean;
+    };
+  };
+}
+/**
+ * Define CLI configuration with type safety
+ */
+declare function defineConfig(config: CLIConfig): CLIConfig;
+/**
+ * Default CLI configuration values
+ */
+declare const DEFAULT_CLI_CONFIG: CLIConfig;
+//#endregion
+export { CLIConfig, DEFAULT_CLI_CONFIG, defineConfig };

package/dist/cli/config.mjs

@@ -0,0 +1,20 @@
+//#region src/cli/config.ts
+/**
+* Define CLI configuration with type safety
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Default CLI configuration values
+*/
+const DEFAULT_CLI_CONFIG = {
+	framework: "graphql-yoga",
+	serverDir: "server/graphql",
+	clientDir: "graphql",
+	buildDir: ".graphql",
+	ignore: ["**/node_modules/**", "**/dist/**"]
+};
+
+//#endregion
+export { DEFAULT_CLI_CONFIG, defineConfig };

package/dist/cli/index.d.mts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { CLIConfig, defineConfig } from "./config.mjs";
+
+//#region src/cli/index.d.ts
+
+/**
+ * CLI context with resolved configuration
+ */
+interface CLIContext {
+  config: Required<Pick<CLIConfig, 'rootDir' | 'buildDir' | 'serverDir' | 'clientDir' | 'typesDir' | 'framework' | 'ignore'>> & CLIConfig;
+  cwd: string;
+}
+/**
+ * Load CLI configuration from file or defaults
+ */
+declare function loadConfig(cwd?: string): Promise<CLIConfig>;
+/**
+ * Create CLI context from configuration
+ */
+declare function createCLIContext(options?: {
+  cwd?: string;
+}): Promise<CLIContext>;
+//#endregion
+export { type CLIConfig, CLIContext, createCLIContext, defineConfig, loadConfig };

package/dist/cli/index.mjs

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+import { LOG_TAG } from "../core/constants.mjs";
+import { DEFAULT_CLI_CONFIG, defineConfig } from "./config.mjs";
+import consola from "consola";
+import { resolve } from "pathe";
+import { existsSync } from "node:fs";
+import { defineCommand, runMain } from "citty";
+
+//#region src/cli/index.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Load CLI configuration from file or defaults
+*/
+async function loadConfig(cwd = process.cwd()) {
+	for (const file of [
+		"nitro-graphql.config.ts",
+		"nitro-graphql.config.js",
+		"nitro-graphql.config.mjs",
+		"graphql.config.ts"
+	]) {
+		const configPath = resolve(cwd, file);
+		if (existsSync(configPath)) try {
+			const module = await import(configPath);
+			const config = module.default || module;
+			logger.info(`Loaded config from ${file}`);
+			return {
+				...DEFAULT_CLI_CONFIG,
+				...config
+			};
+		} catch (error) {
+			logger.warn(`Failed to load config from ${file}:`, error);
+		}
+	}
+	logger.debug("Using default configuration");
+	return { ...DEFAULT_CLI_CONFIG };
+}
+/**
+* Create CLI context from configuration
+*/
+async function createCLIContext(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const config = await loadConfig(cwd);
+	const rootDir = config.rootDir ? resolve(cwd, config.rootDir) : cwd;
+	const buildDir = config.buildDir ? resolve(rootDir, config.buildDir) : resolve(rootDir, ".nitro-graphql");
+	const serverDir = config.serverDir ? resolve(rootDir, config.serverDir) : resolve(rootDir, "server/graphql");
+	const clientDir = config.clientDir ? resolve(rootDir, config.clientDir) : resolve(rootDir, "graphql");
+	const typesDir = config.typesDir ? resolve(rootDir, config.typesDir) : resolve(buildDir, "types");
+	return {
+		cwd,
+		config: {
+			...config,
+			rootDir,
+			buildDir,
+			serverDir,
+			clientDir,
+			typesDir,
+			framework: config.framework || "graphql-yoga",
+			ignore: config.ignore || ["**/node_modules/**", "**/dist/**"]
+		}
+	};
+}
+const generateCommand = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Generate all GraphQL types"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		silent: {
+			type: "boolean",
+			alias: "s",
+			description: "Suppress output"
+		},
+		watch: {
+			type: "boolean",
+			alias: "w",
+			description: "Watch mode"
+		},
+		runtime: {
+			type: "boolean",
+			alias: "r",
+			description: "Generate runtime files (resolvers.ts, schema.ts)"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const silent = Boolean(args.silent);
+		const watch = Boolean(args.watch);
+		const runtime = Boolean(args.runtime) || Boolean(ctx.config.runtime);
+		if (!silent) logger.info("Generating GraphQL types...");
+		const { generateAll } = await import("./commands/generate.mjs");
+		await generateAll(ctx, {
+			silent,
+			watch,
+			runtime
+		});
+		if (!silent) logger.success("Type generation complete!");
+	}
+});
+const generateServerCommand = defineCommand({
+	meta: {
+		name: "generate:server",
+		description: "Generate server types only"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		silent: {
+			type: "boolean",
+			alias: "s",
+			description: "Suppress output"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const silent = Boolean(args.silent);
+		if (!silent) logger.info("Generating server types...");
+		const { generateServer } = await import("./commands/generate.mjs");
+		await generateServer(ctx, { silent });
+		if (!silent) logger.success("Server type generation complete!");
+	}
+});
+const generateClientCommand = defineCommand({
+	meta: {
+		name: "generate:client",
+		description: "Generate client types only"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		silent: {
+			type: "boolean",
+			alias: "s",
+			description: "Suppress output"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const silent = Boolean(args.silent);
+		if (!silent) logger.info("Generating client types...");
+		const { generateClient } = await import("./commands/generate.mjs");
+		await generateClient(ctx, { silent });
+		if (!silent) logger.success("Client type generation complete!");
+	}
+});
+const validateCommand = defineCommand({
+	meta: {
+		name: "validate",
+		description: "Validate GraphQL schemas"
+	},
+	args: { cwd: {
+		type: "string",
+		description: "Set working directory"
+	} },
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		logger.info("Validating GraphQL schemas...");
+		const { validate } = await import("./commands/validate.mjs");
+		if (await validate(ctx)) logger.success("Schema validation passed!");
+		else {
+			logger.error("Schema validation failed!");
+			process.exit(1);
+		}
+	}
+});
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize project structure or download a template"
+	},
+	args: {
+		projectName: {
+			type: "positional",
+			description: "Project name (directory to create)",
+			required: false
+		},
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Force overwrite existing files"
+		},
+		template: {
+			type: "string",
+			alias: "t",
+			description: "Template to use (e.g., drizzle-orm, vite-react)"
+		},
+		list: {
+			type: "boolean",
+			alias: "l",
+			description: "List available templates"
+		}
+	},
+	async run({ args }) {
+		const { listTemplates, initFromTemplate, init } = await import("./commands/init.mjs");
+		if (args.list) {
+			listTemplates();
+			return;
+		}
+		if (args.template) {
+			const projectName = args.projectName || args.template;
+			logger.info(`Creating project "${projectName}" from template "${args.template}"...`);
+			await initFromTemplate(projectName, args.template, {
+				force: Boolean(args.force),
+				cwd: args.cwd || process.cwd()
+			});
+			logger.success("Project created successfully!");
+			return;
+		}
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		logger.info("Initializing nitro-graphql project...");
+		await init(ctx, { force: Boolean(args.force) });
+		logger.success("Project initialized!");
+	}
+});
+const main = defineCommand({
+	meta: {
+		name: "nitro-graphql",
+		version: "2.0.0",
+		description: "GraphQL type generation CLI for Nitro"
+	},
+	subCommands: {
+		"generate": generateCommand,
+		"gen": generateCommand,
+		"g": generateCommand,
+		"generate:server": generateServerCommand,
+		"gen:server": generateServerCommand,
+		"generate:client": generateClientCommand,
+		"gen:client": generateClientCommand,
+		"validate": validateCommand,
+		"v": validateCommand,
+		"init": initCommand
+	}
+});
+async function run() {
+	const { initCompletions } = await import("./completions.mjs");
+	await initCompletions(main);
+	return runMain(main);
+}
+run();
+
+//#endregion
+export { createCLIContext, defineConfig, loadConfig };

package/dist/core/codegen/client.d.mts

@@ -0,0 +1,23 @@
+import { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig } from "../types/codegen.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/codegen/client.d.ts
+
+/**
+ * Default client codegen configuration
+ */
+declare const DEFAULT_CLIENT_CODEGEN_CONFIG: ClientCodegenConfig;
+/**
+ * Generate client-side GraphQL types
+ * Pure function that generates TypeScript types from a GraphQL schema and documents
+ */
+declare function generateClientTypesCore(input: ClientCodegenInput): Promise<ClientCodegenResult | false>;
+/**
+ * Generate client types for external GraphQL service
+ */
+declare function generateExternalClientTypesCore(service: ExternalServiceCodegenConfig, schema: GraphQLSchema, documents: Source[], virtualTypesPath?: string): Promise<ClientCodegenResult | false>;
+//#endregion
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/client.mjs

@@ -0,0 +1,150 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
+import { pluginContent } from "./plugin.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { defu as defu$1 } from "defu";
+import { codegen } from "@graphql-codegen/core";
+import { preset } from "@graphql-codegen/import-types-preset";
+import { plugin } from "@graphql-codegen/typed-document-node";
+import { plugin as plugin$1 } from "@graphql-codegen/typescript";
+import { plugin as plugin$2 } from "@graphql-codegen/typescript-generic-sdk";
+import { plugin as plugin$3 } from "@graphql-codegen/typescript-operations";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { parse } from "graphql";
+
+//#region src/core/codegen/client.ts
+/**
+* Default client codegen configuration
+*/
+const DEFAULT_CLIENT_CODEGEN_CONFIG = {
+	emitLegacyCommonJSImports: false,
+	useTypeImports: true,
+	enumsAsTypes: true,
+	strictScalars: true,
+	maybeValue: "T | null | undefined",
+	inputMaybeValue: "T | undefined",
+	documentMode: "string",
+	pureMagicComment: true,
+	dedupeOperationSuffix: true,
+	rawRequest: true,
+	scalars: DEFAULT_GRAPHQL_SCALARS
+};
+/**
+* Generate generic SDK content for schema-only generation
+*/
+function generateGenericSdkContent() {
+	return `// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+import type { GraphQLResolveInfo } from 'graphql'
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
+
+export interface Requester<C = {}, E = unknown> {
+  <R, V>(doc: string, vars?: V, options?: C): Promise<R> | AsyncIterable<R>
+}
+
+export type Sdk = {
+  request: <R, V = Record<string, any>>(document: string, variables?: V) => Promise<R>
+}
+
+export function getSdk(requester: Requester): Sdk {
+  return {
+    request: <R, V = Record<string, any>>(document: string, variables?: V): Promise<R> => {
+      return requester<R, V>(document, variables)
+    }
+  }
+}
+`;
+}
+/**
+* Generate client-side GraphQL types
+* Pure function that generates TypeScript types from a GraphQL schema and documents
+*/
+async function generateClientTypesCore(input) {
+	const { schema, documents, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath } = input;
+	if (documents.length === 0 && !serviceName) return false;
+	const mergedConfig = defu$1(DEFAULT_CLIENT_CODEGEN_CONFIG, config);
+	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
+	try {
+		if (documents.length === 0) return {
+			types: await codegen({
+				filename: outputPath || "client-types.generated.ts",
+				schema: parse(printSchemaWithDirectives(schema)),
+				documents: [],
+				config: mergedConfig,
+				plugins: [{ pluginContent: {} }, { typescript: {} }],
+				pluginMap: {
+					pluginContent: { plugin: pluginContent },
+					typescript: { plugin: plugin$1 }
+				}
+			}),
+			sdk: generateGenericSdkContent()
+		};
+		const enableTypedDocumentNode = config.typedDocumentNode === true;
+		const plugins = [
+			{ pluginContent: {} },
+			{ typescript: {} },
+			{ typescriptOperations: {} }
+		];
+		const pluginMap = {
+			pluginContent: { plugin: pluginContent },
+			typescript: { plugin: plugin$1 },
+			typescriptOperations: { plugin: plugin$3 }
+		};
+		if (enableTypedDocumentNode) {
+			plugins.push({ typedDocumentNode: {} });
+			pluginMap.typedDocumentNode = { plugin };
+		}
+		const output = await codegen({
+			filename: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...documents],
+			config: mergedConfig,
+			plugins,
+			pluginMap
+		});
+		const typesPath = virtualTypesPath || (serviceName ? `#graphql/client/${serviceName}` : "#graphql/client");
+		const sdkOutput = await preset.buildGeneratesSection({
+			baseOutputDir: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...documents],
+			config: mergedSdkConfig,
+			presetConfig: { typesPath },
+			plugins: [{ pluginContent: {} }, { typescriptGenericSdk: {} }],
+			pluginMap: {
+				pluginContent: { plugin: pluginContent },
+				typescriptGenericSdk: { plugin: plugin$2 }
+			}
+		});
+		return {
+			types: output,
+			sdk: (await Promise.all(sdkOutput.map(async (config$1) => {
+				return {
+					file: config$1.filename,
+					content: await codegen(config$1)
+				};
+			})))[0]?.content || ""
+		};
+	} catch {
+		return false;
+	}
+}
+/**
+* Generate client types for external GraphQL service
+*/
+async function generateExternalClientTypesCore(service, schema, documents, virtualTypesPath) {
+	return generateClientTypesCore({
+		schema,
+		documents,
+		config: service.codegen?.client || {},
+		sdkConfig: service.codegen?.clientSDK || {},
+		serviceName: service.name,
+		virtualTypesPath
+	});
+}
+
+//#endregion
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/document-loader.d.mts

@@ -0,0 +1,10 @@
+import { Source } from "@graphql-tools/utils";
+
+//#region src/core/codegen/document-loader.d.ts
+
+/**
+ * Load GraphQL documents from files
+ */
+declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
+//#endregion
+export { loadGraphQLDocuments };

package/dist/core/codegen/document-loader.mjs

@@ -0,0 +1,18 @@
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { loadDocuments } from "@graphql-tools/load";
+
+//#region src/core/codegen/document-loader.ts
+/**
+* Load GraphQL documents from files
+*/
+async function loadGraphQLDocuments(patterns) {
+	try {
+		return await loadDocuments(patterns, { loaders: [new GraphQLFileLoader()] });
+	} catch (e) {
+		if ((e.message || "").includes("Unable to find any GraphQL type definitions for the following pointers:")) return [];
+		throw e;
+	}
+}
+
+//#endregion
+export { loadGraphQLDocuments };

package/dist/core/codegen/index.d.mts

@@ -0,0 +1,8 @@
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.mjs";
+import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes };

package/dist/core/codegen/index.mjs

@@ -0,0 +1,9 @@
+import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes };

package/dist/{utils/codegen-plugin.d.mts → core/codegen/plugin.d.mts}

@@ -1,7 +1,7 @@
-import { GraphQLSchema } from "graphql";
 import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
 
-//#region src/utils/codegen-plugin.d.ts
+//#region src/core/codegen/plugin.d.ts
 
 /**
  * Plugin to add prepend comments to generated files

package/dist/{utils/codegen-plugin.mjs → core/codegen/plugin.mjs}

@@ -1,4 +1,4 @@
-//#region src/utils/codegen-plugin.ts
+//#region src/core/codegen/plugin.ts
 /**
 * Plugin to add prepend comments to generated files
 * Used by both server and client codegen

package/dist/core/codegen/runtime.d.mts

@@ -0,0 +1,20 @@
+import { ScannedResolver } from "../types/scanning.mjs";
+import "../types/index.mjs";
+
+//#region src/core/codegen/runtime.d.ts
+
+/**
+ * Generate resolver module code
+ * Outputs Nitro-compatible format with { resolver: ... } wrapper
+ */
+declare function generateResolverModule(resolvers: ScannedResolver[], baseDir: string): string;
+/**
+ * Generate schema module code
+ */
+declare function generateSchemaModule(schemaString: string): string;
+/**
+ * Generate runtime index module
+ */
+declare function generateRuntimeIndex(): string;
+//#endregion
+export { generateResolverModule, generateRuntimeIndex, generateSchemaModule };