Configuration & Loading

/**
 * Load and resolve Nuxt configuration with layers
 * @param opts - Configuration loading options
 * @returns Promise resolving to complete NuxtOptions
 */
function loadNuxtConfig(opts: LoadNuxtConfigOptions): Promise<NuxtOptions>;

interface LoadNuxtConfigOptions {
  /** Configuration file path or directory */
  cwd?: string;
  /** Override configuration values */
  overrides?: Partial<NuxtOptions>;
  /** Environment name (development, production, etc.) */
  envName?: string;
}

interface NuxtOptions {
  [key: string]: any;
}

import { loadNuxtConfig } from "@nuxt/kit";

// Load configuration from current directory
const config = await loadNuxtConfig({
  cwd: process.cwd()
});

// Load with overrides
const config = await loadNuxtConfig({
  cwd: "./my-nuxt-app",
  overrides: {
    dev: false,
    ssr: true
  },
  envName: "production"
});

/**
 * Extend Nuxt configuration schema
 * @param def - Schema definition or function returning schema definition
 */
function extendNuxtSchema(def: SchemaDefinition | (() => SchemaDefinition)): void;

interface SchemaDefinition {
  [key: string]: SchemaProperty;
}

interface SchemaProperty {
  type?: string;
  default?: any;
  description?: string;
  [key: string]: any;
}

import { extendNuxtSchema } from "@nuxt/kit";

// Extend schema with new configuration options
extendNuxtSchema({
  myModule: {
    type: "object",
    default: {},
    properties: {
      enabled: {
        type: "boolean",
        default: true,
        description: "Enable my module functionality"
      },
      apiUrl: {
        type: "string",
        default: "https://api.example.com",
        description: "API endpoint URL"
      }
    }
  }
});

// Dynamic schema extension
extendNuxtSchema(() => ({
  dynamicOption: {
    type: "string",
    default: process.env.DYNAMIC_VALUE || "default"
  }
}));

/**
 * Load a Nuxt instance with configuration
 * @param opts - Loading options including configuration overrides
 * @returns Promise resolving to configured Nuxt instance
 */
function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;

/**
 * Build a Nuxt instance (prepare for production)
 * @param nuxt - Nuxt instance to build
 * @returns Promise resolving to build result
 */
function buildNuxt(nuxt: Nuxt): Promise<any>;

interface LoadNuxtOptions {
  /** Working directory for the Nuxt project */
  cwd?: string;
  /** Development mode flag */
  dev?: boolean;
  /** Configuration overrides */
  overrides?: Partial<NuxtOptions>;
  /** Ready callback after instance is loaded */
  ready?: boolean;
}

interface Nuxt {
  options: NuxtOptions;
  hooks: Hookable;
  hook: Hookable['hook'];
  callHook: Hookable['callHook'];
  ready: () => Promise<void>;
  close: () => Promise<void>;
  [key: string]: any;
}

import { loadNuxt, buildNuxt } from "@nuxt/kit";

// Load Nuxt instance for development
const nuxt = await loadNuxt({
  cwd: "./my-app",
  dev: true,
  ready: false
});

// Prepare instance
await nuxt.ready();

// Build for production
const nuxtProd = await loadNuxt({
  cwd: "./my-app",
  dev: false,
  overrides: {
    nitro: {
      preset: "node-server"
    }
  }
});

await buildNuxt(nuxtProd);

/**
 * Get resolved directory paths for all layers in priority order
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Array of LayerDirectories objects
 */
function getLayerDirectories(nuxt?: Nuxt): LayerDirectories[];

interface LayerDirectories {
  /** Nuxt rootDir (`/` by default) */
  readonly root: string;
  /** Nitro source directory (`/server` by default) */
  readonly server: string;
  /** Local modules directory (`/modules` by default) */
  readonly modules: string;
  /** Shared directory (`/shared` by default) */
  readonly shared: string;
  /** Public directory (`/public` by default) */
  readonly public: string;
  /** Nuxt srcDir (`/app/` by default) */
  readonly app: string;
  /** Layouts directory (`/app/layouts` by default) */
  readonly appLayouts: string;
  /** Middleware directory (`/app/middleware` by default) */
  readonly appMiddleware: string;
  /** Pages directory (`/app/pages` by default) */
  readonly appPages: string;
  /** Plugins directory (`/app/plugins` by default) */
  readonly appPlugins: string;
}

import { getLayerDirectories } from "@nuxt/kit";

// Get all layer directories
const layers = getLayerDirectories();

layers.forEach((layer, index) => {
  console.log(`Layer ${index}: ${layer.root}`);
  console.log(`  App: ${layer.app}`);
  console.log(`  Layouts: ${layer.appLayouts}`);
  console.log(`  Pages: ${layer.appPages}`);
  console.log(`  Plugins: ${layer.appPlugins}`);
});

interface Hookable {
  hook<T>(name: string, fn: T): () => void;
  callHook<T>(name: string, ...args: any[]): Promise<T>;
  [key: string]: any;
}