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

package/dist/core/types/scanning.d.mts

@@ -0,0 +1,69 @@
+import { CoreLogger } from "./config.mjs";
+
+//#region src/core/types/scanning.d.ts
+
+/**
+ * Scan context for file scanning operations
+ * Provides all necessary information for scanning without framework dependencies
+ */
+interface ScanContext {
+  /** Root directory of the project */
+  rootDir: string;
+  /** Server GraphQL directory */
+  serverDir: string;
+  /** Client GraphQL directory */
+  clientDir: string;
+  /** Patterns to ignore during scanning */
+  ignorePatterns: string[];
+  /** Whether running in development mode */
+  isDev: boolean;
+  /** Logger instance */
+  logger: CoreLogger;
+  /** Layer server directories (Nuxt layers) */
+  layerServerDirs?: string[];
+  /** Layer app directories (Nuxt layers) */
+  layerAppDirs?: string[];
+}
+/**
+ * Generic scan result wrapper
+ * Provides consistent result structure with warnings and errors
+ */
+interface ScanResult<T> {
+  /** Scanned items */
+  items: T[];
+  /** Non-fatal warnings encountered during scanning */
+  warnings: string[];
+  /** Errors encountered during scanning */
+  errors: string[];
+}
+/**
+ * File information from scanning
+ */
+interface ScannedFile {
+  /** Relative path from scan directory */
+  path: string;
+  /** Absolute file path */
+  fullPath: string;
+}
+/**
+ * Resolver import information
+ */
+interface ResolverImport {
+  /** Export name */
+  name: string;
+  /** Resolver type (query, mutation, resolver, type, subscription, directive) */
+  type: 'query' | 'mutation' | 'resolver' | 'type' | 'subscription' | 'directive';
+  /** Aliased import name */
+  as: string;
+}
+/**
+ * Scanned resolver information
+ */
+interface ScannedResolver {
+  /** File specifier (path) */
+  specifier: string;
+  /** Exports from this file */
+  imports: ResolverImport[];
+}
+//#endregion
+export { ResolverImport, ScanContext, ScanResult, ScannedFile, ScannedResolver };

package/dist/core/types/scanning.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/{utils → core/utils}/directive-parser.d.mts

@@ -1,4 +1,8 @@
-//#region src/utils/directive-parser.d.ts
+//#region src/core/utils/directive-parser.d.ts
+/**
+ * Directive parser utilities
+ * AST-based parsing for GraphQL directive definitions
+ */
 interface ParsedDirective {
   name: string;
   locations: string[];
@@ -69,13 +73,25 @@ declare class DirectiveParser {
  */
 declare function generateDirectiveSchema(directive: ParsedDirective): string;
 /**
- * Generate directive schemas file from scanned directives
- * @returns The path to the generated _directives.graphql file, or null if no directives
+ * Directive file reference
+ * Can be either { fullPath } or { specifier } (for GenImport compatibility)
  */
-declare function generateDirectiveSchemas(nitro: any, directives: any[]): Promise<string | null>;
+type DirectiveFileRef = {
+  fullPath: string;
+} | {
+  specifier: string;
+};
 /**
  * Singleton instance for reuse
  */
 declare const directiveParser: DirectiveParser;
+/**
+ * Generate GraphQL schemas from an array of parsed directives
+ */
+declare function generateDirectiveSchemas(nitro: {
+  graphql: {
+    buildDir: string;
+  };
+}, directives: DirectiveFileRef[]): Promise<string | null>;
 //#endregion
-export { DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };
+export { DirectiveFileRef, DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/{utils → core/utils}/directive-parser.mjs

@@ -1,4 +1,4 @@
-//#region src/utils/directive-parser.ts
+//#region src/core/utils/directive-parser.ts
 /**
 * Clean AST-based directive parser using oxc-parser
 */
@@ -180,47 +180,36 @@ function generateDirectiveSchema(directive) {
 	return `directive @${directive.name}${args} on ${locations}`;
 }
 /**
-* Generate directive schemas file from scanned directives
-* @returns The path to the generated _directives.graphql file, or null if no directives
+* Get the file path from a directive reference
 */
-async function generateDirectiveSchemas(nitro, directives) {
-	if (directives.length === 0) return null;
-	const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
-	const { readFile } = await import("node:fs/promises");
-	const { resolve, dirname } = await import("pathe");
-	const directiveSchemas = [];
-	const seenDirectives = /* @__PURE__ */ new Set();
-	const parser = new DirectiveParser();
-	for (const dir of directives) for (const _imp of dir.imports) {
-		const fileContent = await readFile(dir.specifier, "utf-8");
-		const directiveDefs = await parser.parseDirectives(fileContent, dir.specifier);
-		for (const def of directiveDefs) {
-			if (seenDirectives.has(def.name)) continue;
-			seenDirectives.add(def.name);
-			const schema = generateDirectiveSchema(def);
-			directiveSchemas.push(schema);
-		}
-	}
-	if (directiveSchemas.length > 0) {
-		const directivesPath = resolve(nitro.graphql.buildDir, "_directives.graphql");
-		const content = `# WARNING: This file is auto-generated by nitro-graphql
-# Do not modify this file directly. It will be overwritten.
-# To define custom directives, create .directive.ts files using defineDirective()
-
-${directiveSchemas.join("\n\n")}`;
-		const targetDir = dirname(directivesPath);
-		if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
-		let shouldWrite = true;
-		if (existsSync(directivesPath)) shouldWrite = readFileSync(directivesPath, "utf-8") !== content;
-		if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
-		return directivesPath;
-	}
-	return null;
+function getFilePath(ref) {
+	return "fullPath" in ref ? ref.fullPath : ref.specifier;
 }
 /**
 * Singleton instance for reuse
 */
 const directiveParser = new DirectiveParser();
+/**
+* Generate GraphQL schemas from an array of parsed directives
+*/
+async function generateDirectiveSchemas(nitro, directives) {
+	if (directives.length === 0) return null;
+	const fs = await import("node:fs");
+	const path = await import("pathe");
+	const allParsedDirectives = [];
+	for (const directive of directives) try {
+		const filePath = getFilePath(directive);
+		const content = fs.readFileSync(filePath, "utf-8");
+		const parsed = await directiveParser.parseDirectives(content, filePath);
+		allParsedDirectives.push(...parsed);
+	} catch {}
+	if (allParsedDirectives.length === 0) return null;
+	const schemaContent = allParsedDirectives.map((d) => generateDirectiveSchema(d)).join("\n\n");
+	const directivesPath = path.join(nitro.graphql.buildDir, "_directives.graphql");
+	fs.mkdirSync(path.dirname(directivesPath), { recursive: true });
+	fs.writeFileSync(directivesPath, schemaContent, "utf-8");
+	return directivesPath;
+}
 
 //#endregion
 export { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/{utils → core/utils}/errors.d.mts

@@ -1,4 +1,8 @@
-//#region src/utils/errors.d.ts
+//#region src/core/utils/errors.d.ts
+/**
+ * Error handling utilities for GraphQL
+ * Framework-agnostic error masking and handling
+ */
 interface MaskErrorOptions {
   /**
    * Default HTTP status code for validation errors (ZodError)
@@ -20,7 +24,7 @@ interface MaskErrorOptions {
  * @example Basic usage
  * ```ts
  * import { defineGraphQLConfig } from 'nitro-graphql/define'
- * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ * import { createDefaultMaskError } from 'nitro-graphql/core/utils'
  *
  * export default defineGraphQLConfig({
  *   maskedErrors: {
@@ -32,7 +36,7 @@ interface MaskErrorOptions {
  * @example Custom status codes
  * ```ts
  * import { defineGraphQLConfig } from 'nitro-graphql/define'
- * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ * import { createDefaultMaskError } from 'nitro-graphql/core/utils'
  *
  * export default defineGraphQLConfig({
  *   maskedErrors: {
@@ -47,7 +51,7 @@ interface MaskErrorOptions {
  * @example Custom error handling with fallback to default
  * ```ts
  * import { defineGraphQLConfig } from 'nitro-graphql/define'
- * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ * import { createDefaultMaskError } from 'nitro-graphql/core/utils'
  *
  * const defaultMaskError = createDefaultMaskError()
  *

package/dist/{utils → core/utils}/errors.mjs

@@ -1,6 +1,10 @@
 import { GraphQLError } from "graphql";
 
-//#region src/utils/errors.ts
+//#region src/core/utils/errors.ts
+/**
+* Error handling utilities for GraphQL
+* Framework-agnostic error masking and handling
+*/
 /**
 * Default error masking function for GraphQL Yoga
 * Handles common error types like ZodError and HTTPError
@@ -10,7 +14,7 @@ import { GraphQLError } from "graphql";
 * @example Basic usage
 * ```ts
 * import { defineGraphQLConfig } from 'nitro-graphql/define'
-* import { createDefaultMaskError } from 'nitro-graphql/utils'
+* import { createDefaultMaskError } from 'nitro-graphql/core/utils'
 *
 * export default defineGraphQLConfig({
 *   maskedErrors: {
@@ -22,7 +26,7 @@ import { GraphQLError } from "graphql";
 * @example Custom status codes
 * ```ts
 * import { defineGraphQLConfig } from 'nitro-graphql/define'
-* import { createDefaultMaskError } from 'nitro-graphql/utils'
+* import { createDefaultMaskError } from 'nitro-graphql/core/utils'
 *
 * export default defineGraphQLConfig({
 *   maskedErrors: {
@@ -37,7 +41,7 @@ import { GraphQLError } from "graphql";
 * @example Custom error handling with fallback to default
 * ```ts
 * import { defineGraphQLConfig } from 'nitro-graphql/define'
-* import { createDefaultMaskError } from 'nitro-graphql/utils'
+* import { createDefaultMaskError } from 'nitro-graphql/core/utils'
 *
 * const defaultMaskError = createDefaultMaskError()
 *

package/dist/core/utils/file-io.d.mts

@@ -0,0 +1,24 @@
+//#region src/core/utils/file-io.d.ts
+/**
+ * Unified file I/O utilities
+ * Centralizes file writing patterns used across the codebase
+ */
+/**
+ * Write file with automatic directory creation
+ */
+declare function writeFile(path: string, content: string): void;
+/**
+ * Write file only if content changed (for dev mode optimization)
+ * Returns true if file was written, false if unchanged
+ */
+declare function writeFileIfChanged(path: string, content: string): boolean;
+/**
+ * Ensure directory exists
+ */
+declare function ensureDir(path: string): void;
+/**
+ * Read file safely, returns undefined if file doesn't exist
+ */
+declare function readFileSafe(path: string): string | undefined;
+//#endregion
+export { ensureDir, readFileSafe, writeFile, writeFileIfChanged };

package/dist/core/utils/file-io.mjs

@@ -0,0 +1,47 @@
+import { dirname } from "pathe";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+
+//#region src/core/utils/file-io.ts
+/**
+* Unified file I/O utilities
+* Centralizes file writing patterns used across the codebase
+*/
+/**
+* Write file with automatic directory creation
+*/
+function writeFile(path, content) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, content, "utf-8");
+}
+/**
+* Write file only if content changed (for dev mode optimization)
+* Returns true if file was written, false if unchanged
+*/
+function writeFileIfChanged(path, content) {
+	try {
+		if (existsSync(path)) {
+			if (readFileSync(path, "utf-8") === content) return false;
+		}
+	} catch {}
+	writeFile(path, content);
+	return true;
+}
+/**
+* Ensure directory exists
+*/
+function ensureDir(path) {
+	mkdirSync(path, { recursive: true });
+}
+/**
+* Read file safely, returns undefined if file doesn't exist
+*/
+function readFileSafe(path) {
+	try {
+		return readFileSync(path, "utf-8");
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { ensureDir, readFileSafe, writeFile, writeFileIfChanged };

package/dist/{utils → core/utils}/imports.d.mts

@@ -1,4 +1,4 @@
-//#region src/utils/imports.d.ts
+//#region src/core/utils/imports.d.ts
 /**
  * Import utilities
  * Helpers for generating import IDs and relative paths

package/dist/{utils → core/utils}/imports.mjs

@@ -1,7 +1,7 @@
 import { relative } from "pathe";
 import { hash } from "ohash";
 
-//#region src/utils/imports.ts
+//#region src/core/utils/imports.ts
 /**
 * Import utilities
 * Helpers for generating import IDs and relative paths

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

@@ -0,0 +1,7 @@
+import { DirectiveFileRef, DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
+import { MaskErrorOptions, createDefaultMaskError } from "./errors.mjs";
+import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./file-io.mjs";
+import { getImportId, relativeWithDot } from "./imports.mjs";
+import { createLogger, createSilentLogger, defaultLogger } from "./logger.mjs";
+import { OfetchTemplateOptions, generateOfetchTemplate } from "./ofetch-templates.mjs";
+export { DirectiveFileRef, DirectiveParser, MaskErrorOptions, OfetchTemplateOptions, ParsedDirective, createDefaultMaskError, createLogger, createSilentLogger, defaultLogger, directiveParser, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, readFileSafe, relativeWithDot, writeFile, writeFileIfChanged };

package/dist/core/utils/index.mjs

@@ -0,0 +1,8 @@
+import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./file-io.mjs";
+import { createLogger, createSilentLogger, defaultLogger } from "./logger.mjs";
+import { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
+import { createDefaultMaskError } from "./errors.mjs";
+import { getImportId, relativeWithDot } from "./imports.mjs";
+import { generateOfetchTemplate } from "./ofetch-templates.mjs";
+
+export { DirectiveParser, createDefaultMaskError, createLogger, createSilentLogger, defaultLogger, directiveParser, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, readFileSafe, relativeWithDot, writeFile, writeFileIfChanged };

package/dist/core/utils/logger.d.mts

@@ -0,0 +1,19 @@
+import { CoreLogger } from "../types/config.mjs";
+
+//#region src/core/utils/logger.d.ts
+
+/**
+ * Create a logger instance with the nitro-graphql tag
+ */
+declare function createLogger(tag?: string): CoreLogger;
+/**
+ * Default logger instance
+ */
+declare const defaultLogger: CoreLogger;
+/**
+ * Create a silent logger (no output)
+ * Useful for testing or when logging should be suppressed
+ */
+declare function createSilentLogger(): CoreLogger;
+//#endregion
+export { createLogger, createSilentLogger, defaultLogger };

package/dist/core/utils/logger.mjs

@@ -0,0 +1,38 @@
+import { LOG_TAG } from "../constants.mjs";
+import { consola as consola$1 } from "consola";
+
+//#region src/core/utils/logger.ts
+/**
+* Create a logger instance with the nitro-graphql tag
+*/
+function createLogger(tag = LOG_TAG) {
+	const logger = consola$1.withTag(tag);
+	return {
+		info: (message, ...args) => logger.info(message, ...args),
+		warn: (message, ...args) => logger.warn(message, ...args),
+		error: (message, ...args) => logger.error(message, ...args),
+		success: (message, ...args) => logger.success(message, ...args),
+		debug: (message, ...args) => logger.debug(message, ...args)
+	};
+}
+/**
+* Default logger instance
+*/
+const defaultLogger = createLogger();
+/**
+* Create a silent logger (no output)
+* Useful for testing or when logging should be suppressed
+*/
+function createSilentLogger() {
+	const noop = () => {};
+	return {
+		info: noop,
+		warn: noop,
+		error: noop,
+		success: noop,
+		debug: noop
+	};
+}
+
+//#endregion
+export { createLogger, createSilentLogger, defaultLogger };

package/dist/{utils → core/utils}/ofetch-templates.d.mts

@@ -1,4 +1,4 @@
-//#region src/utils/ofetch-templates.d.ts
+//#region src/core/utils/ofetch-templates.d.ts
 /**
  * Shared ofetch template generation utilities
  * Used by both main client and external service code generation

package/dist/{utils → core/utils}/ofetch-templates.mjs

@@ -1,4 +1,4 @@
-//#region src/utils/ofetch-templates.ts
+//#region src/core/utils/ofetch-templates.ts
 /**
 * Capitalize first letter of a string
 */

package/dist/core/validation/external-services.d.mts

@@ -0,0 +1,11 @@
+//#region src/core/validation/external-services.d.ts
+/**
+ * External services validation utilities
+ * Framework-agnostic validation helpers
+ */
+/**
+ * Validate external GraphQL service configuration
+ */
+declare function validateExternalServices(services: unknown[]): string[];
+//#endregion
+export { validateExternalServices };

package/dist/{utils/validation.mjs → core/validation/external-services.mjs}

@@ -1,7 +1,7 @@
-//#region src/utils/validation.ts
+//#region src/core/validation/external-services.ts
 /**
-* Validation utilities
-* Configuration validation helpers
+* External services validation utilities
+* Framework-agnostic validation helpers
 */
 /**
 * Validate external GraphQL service configuration

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

@@ -0,0 +1,2 @@
+import { validateExternalServices } from "./external-services.mjs";
+export { validateExternalServices };

package/dist/core/validation/index.mjs

@@ -0,0 +1,3 @@
+import { validateExternalServices } from "./external-services.mjs";
+
+export { validateExternalServices };

package/dist/define.d.mts

@@ -1,6 +1,4 @@
-import { StandardSchemaV1 } from "./types/standard-schema.mjs";
-import "./types/index.mjs";
-import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten } from "./types/define.mjs";
+import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten, StandardSchemaV1 } from "./nitro/types.mjs";
 import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
 
 //#region src/define.d.ts

package/dist/index.d.mts

@@ -1,44 +1,6 @@
-import { NitroGraphQLOptions } from "./types/index.mjs";
-import { resolveSecurityConfig } from "./setup.mjs";
-import { NitroModule } from "nitro/types";
-import { Plugin } from "vite";
-
-//#region src/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 { graphqlModule as default, resolveSecurityConfig };
+import { ExternalGraphQLService, NitroGraphQLOptions, SecurityConfig } from "./nitro/types.mjs";
+import { NitroAdapter } from "./nitro/adapter.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { setupNitroGraphQL } from "./nitro/setup.mjs";
+import graphqlModule from "./nitro/index.mjs";
+export { type ExternalGraphQLService, NitroAdapter, type NitroGraphQLOptions, type SecurityConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/index.mjs

@@ -1,63 +1,6 @@
-import { resolveSecurityConfig, setupNitroGraphQL } from "./setup.mjs";
-import { readFile } from "node:fs/promises";
-import defu from "defu";
+import { NitroAdapter } from "./nitro/adapter.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { setupNitroGraphQL } from "./nitro/setup.mjs";
+import nitro_default from "./nitro/index.mjs";
 
-//#region src/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 src_default = graphqlModule;
-
-//#endregion
-export { src_default as default, resolveSecurityConfig };
+export { NitroAdapter, nitro_default as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/adapter.d.mts

@@ -0,0 +1,30 @@
+import { CoreConfig, CoreContext, CoreLogger } from "../core/types/config.mjs";
+import { ScanContext } from "../core/types/scanning.mjs";
+import "../core/types/index.mjs";
+import { FrameworkAdapter, ScanAdapter } from "../core/types/adapter.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/adapter.d.ts
+
+/**
+ * Create a CoreLogger from Nitro's logger
+ */
+declare function createLoggerFromNitro(nitro: Nitro): CoreLogger;
+/**
+ * Create a ScanContext from Nitro instance
+ */
+declare function createScanContextFromNitro(nitro: Nitro): ScanContext;
+/**
+ * Create a CoreConfig from Nitro instance
+ */
+declare function createCoreConfigFromNitro(nitro: Nitro): CoreConfig;
+/**
+ * Create a CoreContext from Nitro instance
+ */
+declare function createCoreContextFromNitro(nitro: Nitro): CoreContext;
+/**
+ * Nitro framework adapter implementation
+ */
+declare const NitroAdapter: FrameworkAdapter<Nitro> & ScanAdapter<Nitro>;
+//#endregion
+export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro };