Core API

/**
 * Initialize Eruda with configuration options
 * @param options - Configuration options for initialization
 */
function init(options?: InitOptions): void;

interface InitOptions {
  /** Container element. If not set, appends element under html root */
  container?: HTMLElement;
  /** Tools to initialize. Default: all tools */
  tool?: string[];
  /** Auto scale for different viewport settings */
  autoScale?: boolean;
  /** Use shadow DOM for CSS encapsulation */
  useShadowDom?: boolean;
  /** Enable inline mode without entry button */
  inline?: boolean;
  /** Default settings configuration */
  defaults?: InitDefaults;
}

interface InitDefaults {
  /** UI transparency, 0 to 1 */
  transparency?: number;
  /** Display size, 0 to 100 */
  displaySize?: number;
  /** Theme name, defaults to Light or Dark */
  theme?: string;
}

// Basic initialization
eruda.init();

// Initialize with custom container
eruda.init({
  container: document.getElementById('debug-container')
});

// Initialize with specific tools only
eruda.init({
  tool: ['console', 'elements', 'network']
});

// Initialize with custom defaults
eruda.init({
  autoScale: false,
  useShadowDom: false,
  defaults: {
    displaySize: 50,
    theme: 'Dark',
    transparency: 0.9
  }
});

// Inline mode (always visible, no entry button)
eruda.init({
  inline: true,
  container: document.getElementById('debug-panel')
});

/**
 * Get tool instance or DevTools instance
 * @param name - Tool name or 'entryBtn'. If omitted, returns DevTools instance
 * @returns Tool instance, entry button, or DevTools instance
 */
function get(name?: string): Tool | EntryBtn | DevTools;

/**
 * Add custom tool to DevTools
 * @param tool - Tool instance or function that returns a tool
 * @returns Eruda instance for chaining
 */
function add(tool: Tool | ((eruda: Eruda) => Tool)): Eruda;

/**
 * Remove tool from DevTools
 * @param name - Tool name to remove
 * @returns Eruda instance for chaining
 */
function remove(name: string): Eruda;

// Get tool instances
const console = eruda.get('console');
const elements = eruda.get('elements');
const devTools = eruda.get(); // Gets DevTools instance
const entryBtn = eruda.get('entryBtn');

// Add custom tool
eruda.add(function(eruda) {
  return new MyCustomTool();
});

// Add tool instance directly
const customTool = new MyDebugTool();
eruda.add(customTool);

// Remove tool
eruda.remove('myCustomTool');

/**
 * Show DevTools or specific tool
 * @param name - Specific tool name to show (optional)
 * @returns Eruda instance for chaining
 */
function show(name?: string): Eruda;

/**
 * Hide DevTools
 * @returns Eruda instance for chaining
 */
function hide(): Eruda;

// Show DevTools with default tool
eruda.show();

// Show specific tool
eruda.show('console');
eruda.show('elements');
eruda.show('network');

// Hide DevTools
eruda.hide();

// Chain operations
eruda.show('console').scale(0.8);

/**
 * Get or set UI scale factor
 * @param s - Scale factor (optional)
 * @returns Current scale or Eruda instance
 */
function scale(s?: number): number | Eruda;

/**
 * Get or set entry button position
 * @param p - Position coordinates (optional)
 * @returns Current position or Eruda instance
 */
function position(p?: Position): Position | Eruda;

interface Position {
  x: number;
  y: number;
}

// Get current scale
const currentScale = eruda.scale();

// Set scale
eruda.scale(0.8); // 80% of normal size
eruda.scale(1.2); // 120% of normal size

// Get current position
const currentPos = eruda.position();

// Set position
eruda.position({ x: 100, y: 200 });

// Chain operations
eruda.scale(0.9).position({ x: 50, y: 50 });

/**
 * Destroy Eruda instance and clean up all resources
 */
function destroy(): void;

// Clean up Eruda
eruda.destroy();

// Can reinitialize after destruction
eruda.init();

// Version information
const version: string;

// Utility functions
const util: Util;

// Debugging protocol instance
const chobitsu: Chobitsu;

// Tool constructors
const Console: ErudaConsoleConstructor;
const Elements: ElementsConstructor;
const Network: NetworkConstructor;
const Sources: SourcesConstructor;
const Resources: ResourcesConstructor;
const Info: InfoConstructor;
const Snippets: SnippetsConstructor;
const Settings: SettingsConstructor;
const Tool: ToolConstructor;

interface Util {
  /** Check if element is part of Eruda */
  isErudaEl(val: any): boolean;
  /** Check if theme is dark */
  isDarkTheme(theme?: string): boolean;
  /** Get current theme name */
  getTheme(): string;
  /** Inject CSS with theme processing */
  evalCss(css: string): HTMLStyleElement;
}

interface Chobitsu {
  /** Register debugging protocol domains */
  register(domain: string, implementation: object): void;
  /** Chrome DevTools protocol instance for advanced debugging */
}

// Check Eruda version
console.log(eruda.version); // "3.4.3"

// Use utilities
const isDark = eruda.util.isDarkTheme();
const currentTheme = eruda.util.getTheme();
const isErudaElement = eruda.util.isErudaEl(someElement);

// Inject custom CSS
eruda.util.evalCss('.my-custom-style { color: red; }');

// Access debugging protocol
const protocol = eruda.chobitsu;
// Note: chobitsu provides Chrome DevTools protocol integration
// for advanced debugging scenarios

// Create tool instances
const customConsole = new eruda.Console();
const customSettings = new eruda.Settings();