Application Configuration and Startup

/**
 * Create a new Koin application with optional configuration
 * @param createEagerInstances - Whether to create eager instances immediately
 * @param appDeclaration - Application configuration function
 * @returns KoinApplication instance
 */
function koinApplication(
  createEagerInstances: boolean = true,
  appDeclaration?: (app: KoinApplication) => void
): KoinApplication;

/**
 * Create a Koin application with configuration function
 * @param appDeclaration - Application configuration function
 * @returns KoinApplication instance
 */
function koinApplication(appDeclaration: (app: KoinApplication) => void): KoinApplication;

/**
 * Create a Koin application with configuration object
 * @param configuration - KoinConfiguration instance
 * @returns KoinApplication instance
 */
function koinApplication(configuration: KoinConfiguration): KoinApplication;

import { koinApplication, module } from "koin-core";

// Basic application creation
const app = koinApplication((app) => {
  app.modules([myModule]);
  app.printLogger();
});

// With eager instance creation disabled
const app = koinApplication(false, (app) => {
  app.modules([myModule]);
  app.allowOverride(true);
});

// Using configuration object
const config = new KoinConfiguration();
config.modules([myModule]);
const app = koinApplication(config);

/**
 * Start Koin globally with application configuration
 * @param appDeclaration - Application configuration function
 * @returns KoinApplication instance
 */
function startKoin(appDeclaration: (app: KoinApplication) => void): KoinApplication;

/**
 * Start Koin globally with pre-configured application
 * @param koinApplication - Configured KoinApplication instance  
 * @returns KoinApplication instance
 */
function startKoin(koinApplication: KoinApplication): KoinApplication;

/**
 * Stop the global Koin instance and cleanup all resources
 */
function stopKoin(): void;

import { startKoin, stopKoin, module } from "koin-core";

// Start with inline configuration
startKoin((app) => {
  app.modules([appModule, networkModule]);
  app.printLogger();
  app.properties(new Map([["api.url", "https://api.example.com"]]));
});

// Later, stop the application
stopKoin();

class KoinApplication {
  /**
   * Load dependency modules into the application
   * @param modules - Array of Module instances
   * @returns KoinApplication for chaining
   */
  modules(modules: Module[]): KoinApplication;

  /**
   * Set application properties for dependency injection
   * @param properties - Map of property key-value pairs
   * @returns KoinApplication for chaining
   */
  properties(properties: Map<string, any>): KoinApplication;

  /**
   * Configure logging with custom logger
   * @param logger - Logger instance
   * @returns KoinApplication for chaining
   */
  logger(logger: Logger): KoinApplication;

  /**
   * Use default console logger with specified level
   * @param level - Log level (default: INFO)
   * @returns KoinApplication for chaining
   */
  printLogger(level?: Level): KoinApplication;

  /**
   * Allow definition override for testing and configuration
   * @param override - Whether to allow overriding definitions
   * @returns KoinApplication for chaining
   */
  allowOverride(override: boolean): KoinApplication;

  /**
   * Create eager instances immediately after application start
   * @returns KoinApplication for chaining
   */
  createEagerInstances(): KoinApplication;

  /**
   * Close the application and cleanup all resources
   */
  close(): void;

  /**
   * Get the underlying Koin container for direct access
   */
  koin: Koin;
}

import { koinApplication, Level } from "koin-core";

const app = koinApplication((app) => {
  app
    .modules([coreModule, apiModule, dbModule])
    .properties(new Map([
      ["database.url", "mongodb://localhost:27017"],
      ["api.timeout", 5000],
      ["debug.enabled", true]
    ]))
    .printLogger(Level.DEBUG)
    .allowOverride(false)
    .createEagerInstances();
});

// Access the underlying Koin container
const koin = app.koin;
const service = koin.get("MyService");

/**
 * Create a reusable configuration object
 * @param declaration - Configuration function
 * @returns KoinConfiguration instance
 */
function koinConfiguration(declaration: (config: KoinConfiguration) => void): KoinConfiguration;

class KoinConfiguration {
  /**
   * Convert configuration to application declaration
   * @returns Application declaration function
   */
  invoke(): (app: KoinApplication) => void;

  /**
   * Export configuration as application declaration
   */
  appDeclaration: (app: KoinApplication) => void;
}

import { koinConfiguration, koinApplication } from "koin-core";

// Create reusable configuration
const appConfig = koinConfiguration((config) => {
  config.modules([sharedModule, utilsModule]);
  config.printLogger();
  config.allowOverride(true);
});

// Use configuration with application
const app = koinApplication(appConfig);

// Or use the app declaration directly
const app2 = koinApplication(appConfig.appDeclaration);

/**
 * Load additional modules into running application
 * @param modules - Modules to load
 */
function loadKoinModules(modules: Module[]): void;

/**
 * Load single module into running application
 * @param module - Module to load
 */
function loadKoinModules(module: Module): void;

/**
 * Unload modules from running application
 * @param modules - Modules to unload
 */
function unloadKoinModules(modules: Module[]): void;

/**
 * Unload single module from running application
 * @param module - Module to unload
 */
function unloadKoinModules(module: Module): void;

import { startKoin, loadKoinModules, unloadKoinModules, module } from "koin-core";

// Start with basic modules
startKoin((app) => {
  app.modules([coreModule]);
});

// Load additional modules at runtime
const featureModule = module((builder) => {
  builder.single(() => new FeatureService());
});

loadKoinModules([featureModule]);

// Later, unload the module
unloadKoinModules([featureModule]);

/** Function type for application configuration */
type KoinAppDeclaration = (app: KoinApplication) => void;

/** Log levels for application logging */
enum Level {
  DEBUG = "DEBUG",
  INFO = "INFO",
  WARNING = "WARNING", 
  ERROR = "ERROR",
  NONE = "NONE"
}

/** Exception thrown when Koin application is already started */
class KoinApplicationAlreadyStartedException extends Error {
  constructor(message: string);
}