Module System

/**
 * Define a Nuxt module with automatic option merging and setup
 * @param definition - Module definition with meta, defaults, and setup function
 * @returns NuxtModule instance or builder object with .with() method
 */
function defineNuxtModule<T>(definition: ModuleDefinition<T>): NuxtModule<T>;

interface ModuleDefinition<T> {
  meta?: ModuleMeta;
  defaults?: T | ((nuxt: Nuxt) => T);
  schema?: Schema;
  hooks?: Partial<NuxtHooks>;
  setup?: (options: T, nuxt: Nuxt) => void | Promise<void>;
}

interface ModuleMeta {
  name?: string;
  version?: string;
  configKey?: string;
  compatibility?: NuxtCompatibility;
}

interface NuxtModule<T = any> {
  (this: void, inlineOptions: T, nuxt: Nuxt): void | Promise<void>;
  getOptions?: (inlineOptions?: T, nuxt?: Nuxt) => Promise<T>;
  getMeta?: () => Promise<ModuleMeta>;
}

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

// Basic module definition
export default defineNuxtModule({
  meta: {
    name: "my-module",
    configKey: "myModule"
  },
  defaults: {
    enabled: true,
    apiUrl: "https://api.example.com"
  },
  setup(options, nuxt) {
    // Module setup logic
    console.log(`Module enabled: ${options.enabled}`);
  }
});

// Builder pattern with .with()
export default defineNuxtModule({
  meta: { name: "my-module" },
  setup() {
    // Base setup
  }
}).with({
  // Extended configuration
  apiKey: process.env.API_KEY
});

/**
 * Install a module on a Nuxt instance (deprecated - use module dependencies instead)
 * @param moduleToInstall - Module to install (string path, function, or object)
 * @param inlineOptions - Options to pass to the module
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to installed NuxtModule
 */
function installModule<T>(
  moduleToInstall: T,
  inlineOptions?: any,
  nuxt?: Nuxt
): Promise<NuxtModule>;

/**
 * Install a set of modules on a Nuxt instance (internal function)
 * @param modulesToInstall - Map of modules to install with their options
 * @param resolvedModulePaths - Set of already resolved module paths
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise that resolves when all modules are installed
 * @internal
 */
function installModules(
  modulesToInstall: Map<ModuleToInstall, Record<string, any>>,
  resolvedModulePaths: Set<string>,
  nuxt?: Nuxt
): Promise<void>;

/**
 * Resolve module with options from module definition
 * @param definition - Module definition (string, array, or NuxtModule)
 * @param nuxt - Nuxt instance to use for resolution
 * @returns Resolved module information or undefined if not resolvable
 */
function resolveModuleWithOptions(
  definition: NuxtModule<any> | string | false | undefined | null | [(NuxtModule | string)?, Record<string, any>?],
  nuxt: Nuxt
): { resolvedPath?: string, module: string | NuxtModule<any>, options: Record<string, any> } | undefined;

/**
 * Load and resolve a Nuxt module instance
 * @param nuxtModule - Module identifier (string path or NuxtModule)
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to loaded NuxtModule
 */
function loadNuxtModuleInstance(
  nuxtModule: string | NuxtModule,
  nuxt?: Nuxt
): Promise<NuxtModule>;

/**
 * Get directory path from module file path
 * @param p - Module file path
 * @returns Directory path string
 */
function getDirectory(p: string): string;

/**
 * Normalize module path for transpilation
 * @param p - Module path to normalize
 * @returns Normalized path string
 */
function normalizeModuleTranspilePath(p: string): string;

/**
 * Check if a Nuxt module is installed by name
 * @param moduleName - Name of the module to check
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns True if module is installed
 */
function hasNuxtModule(moduleName: string, nuxt?: Nuxt): boolean;

/**
 * Get version of an installed Nuxt module
 * @param module - Module name or NuxtModule instance
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to version string or false if not found
 */
function getNuxtModuleVersion(
  module: string | NuxtModule,
  nuxt?: Nuxt
): Promise<string | false>;

/**
 * Check if module is compatible with given semver version
 * @param module - Module name or NuxtModule instance
 * @param semverVersion - Semantic version constraint
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to compatibility boolean
 */
function hasNuxtModuleCompatibility(
  module: string | NuxtModule,
  semverVersion: string,
  nuxt?: Nuxt
): Promise<boolean>;

import { 
  hasNuxtModule, 
  getNuxtModuleVersion, 
  hasNuxtModuleCompatibility 
} from "@nuxt/kit";

// Check if module is installed
if (hasNuxtModule("@nuxtjs/tailwindcss")) {
  console.log("Tailwind CSS module is installed");
}

// Get module version
const version = await getNuxtModuleVersion("@nuxtjs/tailwindcss");
console.log(`Tailwind CSS version: ${version}`);

// Check compatibility
const isCompatible = await hasNuxtModuleCompatibility(
  "@nuxtjs/tailwindcss",
  "^6.0.0"
);

interface NuxtCompatibility {
  nuxt?: string;
  bridge?: boolean;
}

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

interface NuxtHooks {
  [key: string]: (...args: any[]) => any;
}

type ModuleToInstall = string | NuxtModule<any, Partial<any>, false>;