edhindex 1.1.0 → 2.0.0

package/src/language/adapters/terraform.ts

@@ -0,0 +1,25 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'hcl',
+  wasmPath: new URL('../../node_modules/@tree-sitter-grammars/tree-sitter-hcl/tree-sitter-hcl.wasm', import.meta.url).pathname,
+  queryPatterns: {
+    block: '(block (identifier) @name)',
+    attribute: '(attribute (identifier) @name)',
+  },
+  typeMap: {
+    block: SymbolType.Module,
+    attribute: SymbolType.Property,
+  },
+  nameNodeTypes: ['identifier'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class TerraformAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Terraform'; }
+  fileExtensions(): string[] { return ['.tf', '.tfvars']; }
+}

package/src/language/adapters/text.ts

@@ -0,0 +1,195 @@
+import { LanguageAdapter, ParseResult, CodeSymbol, SymbolType } from '../types.js';
+
+export class TextAdapter implements LanguageAdapter {
+  languageName(): string { return 'Text'; }
+  fileExtensions(): string[] { return ['.txt', '.log']; }
+  fileNames(): string[] { return []; }
+  canParse(filePath: string): boolean {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith('.txt') || lower.endsWith('.log');
+  }
+  supportsSymbols(): boolean { return true; }
+
+  async parse(content: string, filePath: string): Promise<ParseResult> {
+    const lines = content.split('\n');
+    const symbols: CodeSymbol[] = [];
+    const imports: string[] = [];
+    const exports: string[] = [];
+    const comments: string[] = [];
+
+    if (filePath.endsWith('.log')) {
+      this.extractLogEntries(lines, symbols, filePath);
+    } else {
+      this.extractTextSections(lines, symbols, filePath);
+    }
+
+    return { symbols, imports, exports, comments };
+  }
+
+  private extractLogEntries(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    const logPatterns = [
+      { regex: /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/i, type: SymbolType.Function },
+      { regex: /^\[?\d{4}-\d{2}-\d{2}\]?/i, type: SymbolType.Function },
+      { regex: /^(ERROR|WARN|INFO|DEBUG|FATAL)/i, type: SymbolType.Function },
+      { regex: /^Exception|Error|Warning/i, type: SymbolType.Function },
+    ];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (!line) continue;
+
+      for (const pattern of logPatterns) {
+        if (pattern.regex.test(line)) {
+          symbols.push({
+            id: `${filePath}:${i + 1}`,
+            name: line.substring(0, 50),
+            type: pattern.type,
+            language: 'log',
+            file: filePath,
+            startLine: i + 1,
+            endLine: i + 1,
+            parent: null,
+            children: [],
+            metadata: { fullLine: line },
+          });
+          break;
+        }
+      }
+
+      // Extract stack traces
+      if (line.includes('at ') && line.includes('(') && line.includes(')')) {
+        symbols.push({
+          id: `${filePath}:${i + 1}:stack`,
+          name: 'stackTrace',
+          type: SymbolType.Function,
+          language: 'log',
+          file: filePath,
+          startLine: i + 1,
+          endLine: i + 1,
+          parent: null,
+          children: [],
+          metadata: { trace: line },
+        });
+      }
+    }
+  }
+
+  private extractTextSections(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    let currentSection: string | null = null;
+    let currentSectionId: string | null = null;
+    let sectionStart = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Detect section headers (lines that are all uppercase, or followed by underline)
+      const isHeader = this.isSectionHeader(line, lines[i + 1]);
+      
+      if (isHeader && line.length > 0) {
+        // Save previous section
+        if (currentSection) {
+          symbols.push({
+            id: currentSectionId!,
+            name: currentSection,
+            type: SymbolType.Section,
+            language: 'text',
+            file: filePath,
+            startLine: sectionStart,
+            endLine: i,
+            parent: null,
+            children: [],
+            metadata: {},
+          });
+        }
+
+        // Start new section
+        currentSection = line;
+        currentSectionId = `${filePath}:${i + 1}`;
+        sectionStart = i + 1;
+      }
+    }
+
+    // Save last section
+    if (currentSection) {
+      symbols.push({
+        id: currentSectionId!,
+        name: currentSection,
+        type: SymbolType.Section,
+        language: 'text',
+        file: filePath,
+        startLine: sectionStart,
+        endLine: lines.length,
+        parent: null,
+        children: [],
+        metadata: {},
+      });
+    }
+
+    // If no sections found, create paragraph-based symbols
+    if (symbols.length === 0) {
+      this.extractParagraphs(lines, symbols, filePath);
+    }
+  }
+
+  private isSectionHeader(line: string, nextLine: string | undefined): boolean {
+    if (!line || line.length < 3) return false;
+    
+    // Check if line is all uppercase
+    if (line === line.toUpperCase() && /[A-Z]/.test(line)) return true;
+    
+    // Check if next line is underline (=== or ---)
+    if (nextLine) {
+      const underline = nextLine.trim();
+      if (/^[=-]{3,}$/.test(underline)) return true;
+    }
+    
+    return false;
+  }
+
+  private extractParagraphs(lines: string[], symbols: CodeSymbol[], filePath: string) {
+    let paragraphStart = 0;
+    let paragraphText = '';
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line === '') {
+        if (paragraphText.length > 0) {
+          symbols.push({
+            id: `${filePath}:${paragraphStart + 1}`,
+            name: paragraphText.substring(0, 50),
+            type: SymbolType.Section,
+            language: 'text',
+            file: filePath,
+            startLine: paragraphStart + 1,
+            endLine: i,
+            parent: null,
+            children: [],
+            metadata: { size: paragraphText.length },
+          });
+          paragraphText = '';
+        }
+        paragraphStart = i + 1;
+      } else {
+        paragraphText += (paragraphText ? ' ' : '') + line;
+      }
+    }
+
+    // Handle last paragraph
+    if (paragraphText.length > 0) {
+      symbols.push({
+        id: `${filePath}:${paragraphStart + 1}`,
+        name: paragraphText.substring(0, 50),
+        type: SymbolType.Section,
+        language: 'text',
+        file: filePath,
+        startLine: paragraphStart + 1,
+        endLine: lines.length,
+        parent: null,
+        children: [],
+        metadata: { size: paragraphText.length },
+      });
+    }
+  }
+}

package/src/language/adapters/toml.ts

@@ -0,0 +1,82 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'toml',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-toml.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['bare_key', 'string'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class TomlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'TOML'; }
+  fileExtensions(): string[] { return ['.toml']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkToml(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  private walkToml(node: any, symbols: CodeSymbol[], filePath: string, parentId: string) {
+    if (node.type === 'table' || node.type === 'table_array_element') {
+      const key = this.extractTomlKey(node);
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Section, language: 'toml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        parentId = id;
+      }
+    } else if (node.type === 'pair') {
+      const key = this.extractPairKey(node);
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Property, language: 'toml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+      }
+    }
+    
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkToml(child, symbols, filePath, parentId);
+    }
+  }
+
+  private extractTomlKey(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'bare_key' || child.type === 'string') {
+        return child.text?.replace(/"/g, '') || null;
+      }
+      if (child.type === 'dotted_key') {
+        return child.text || null;
+      }
+    }
+    return null;
+  }
+
+  private extractPairKey(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'bare_key' || child.type === 'string') {
+        return child.text?.replace(/"/g, '') || null;
+      }
+    }
+    return null;
+  }
+}

package/src/language/adapters/vue.ts

@@ -0,0 +1,70 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'vue',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-vue.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['tag_name', 'attribute_name', 'directive_attribute'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class VueAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'Vue'; }
+  fileExtensions(): string[] { return ['.vue']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkVue(tree.rootNode, symbols, filePath);
+    return symbols;
+  }
+
+  private walkVue(node: any, symbols: CodeSymbol[], filePath: string) {
+    // Extract top-level sections: <template>, <script>, <style>
+    if (node.type === 'element') {
+      const tagName = this.extractTagName(node);
+      if (tagName && ['template', 'script', 'style'].includes(tagName.toLowerCase())) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: tagName, type: SymbolType.Section, language: 'vue',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: null, children: [], metadata: {},
+        });
+      }
+      
+      // Extract custom components (PascalCase or kebab-case with -)
+      if (tagName && (tagName[0] === tagName[0].toUpperCase() || tagName.includes('-'))) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: tagName, type: SymbolType.Class, language: 'vue',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: null, children: [], metadata: {},
+        });
+      }
+    }
+    
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkVue(child, symbols, filePath);
+    }
+  }
+
+  private extractTagName(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'tag_name') return child.text;
+      if (child.type === 'start_tag' || child.type === 'self_closing_tag') {
+        for (let j = 0; j < child.childCount; j++) {
+          const grandchild = child.child(j);
+          if (grandchild && grandchild.type === 'tag_name') return grandchild.text;
+        }
+      }
+    }
+    return null;
+  }
+}

package/src/language/adapters/xml.ts

@@ -0,0 +1,74 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const GRAMMAR: GrammarConfig = {
+  language: 'xml',
+  wasmPath: new URL('../../node_modules/@tree-sitter-grammars/tree-sitter-xml/tree-sitter-xml.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['tag_name', 'attribute_name'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class XmlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'XML'; }
+  fileExtensions(): string[] { return ['.xml']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.collectElements(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  private collectElements(node: any, symbols: CodeSymbol[], filePath: string, parentId: string) {
+    if (node.type === 'element') {
+      const tagName = this.extractTagName(node);
+      if (tagName) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        const symbolType = this.getSymbolType(tagName);
+        
+        symbols.push({
+          id, name: tagName, type: symbolType, language: 'xml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        
+        // Recurse into child elements
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child) this.collectElements(child, symbols, filePath, id);
+        }
+        return;
+      }
+    }
+    
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.collectElements(child, symbols, filePath, parentId);
+    }
+  }
+
+  private extractTagName(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'tag_name') return child.text;
+      if (child.type === 'start_tag' || child.type === 'self_closing_tag') {
+        for (let j = 0; j < child.childCount; j++) {
+          const grandchild = child.child(j);
+          if (grandchild && grandchild.type === 'tag_name') return grandchild.text;
+        }
+      }
+    }
+    return null;
+  }
+
+  private getSymbolType(tagName: string): SymbolType {
+    const significant = ['configuration', 'settings', 'properties', 'beans', 'component', 'module', 'project'];
+    if (significant.includes(tagName.toLowerCase())) return SymbolType.Module;
+    return SymbolType.Property;
+  }
+}

package/src/language/adapters/yaml.ts

@@ -0,0 +1,63 @@
+import { createRequire } from 'node:module';
+import { BaseTreeSitterAdapter, GrammarConfig } from '../base.js';
+import { SymbolType, CodeSymbol } from '../types.js';
+
+const require = createRequire(import.meta.url);
+
+const GRAMMAR: GrammarConfig = {
+  language: 'yaml',
+  wasmPath: new URL('../../node_modules/tree-sitter-wasms/out/tree-sitter-yaml.wasm', import.meta.url).pathname,
+  queryPatterns: {},
+  typeMap: {},
+  nameNodeTypes: ['string_scalar', 'plain_scalar'],
+  importNodeTypes: [],
+  exportNodeTypes: [],
+};
+
+export class YamlAdapter extends BaseTreeSitterAdapter {
+  protected grammar = GRAMMAR;
+  languageName(): string { return 'YAML'; }
+  fileExtensions(): string[] { return ['.yaml', '.yml']; }
+
+  protected async extractSymbolsFromTree(tree: any, filePath: string, content: string): Promise<CodeSymbol[]> {
+    const symbols: CodeSymbol[] = [];
+    this.walkYaml(tree.rootNode, symbols, filePath, '');
+    return symbols;
+  }
+
+  private walkYaml(node: any, symbols: CodeSymbol[], filePath: string, parentId: string) {
+    if (node.type === 'block_mapping_pair' || node.type === 'flow_pair') {
+      const key = this.extractYamlKey(node);
+      if (key) {
+        const id = `${filePath}:${node.startPosition.row + 1}`;
+        symbols.push({
+          id, name: key, type: SymbolType.Property, language: 'yaml',
+          file: filePath, startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1, parent: parentId || null, children: [], metadata: {},
+        });
+        // Recurse into nested mappings
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && (child.type === 'block_mapping' || child.type === 'flow_mapping')) {
+            this.walkYaml(child, symbols, filePath, id);
+          }
+        }
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child) this.walkYaml(child, symbols, filePath, parentId);
+    }
+  }
+
+  private extractYamlKey(node: any): string | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'string_scalar' || child.type === 'plain_scalar') {
+        return child.text || null;
+      }
+    }
+    return null;
+  }
+}

package/src/language/registry.ts

@@ -13,6 +13,30 @@ import { PhpAdapter } from './adapters/php.js';
 import { HtmlAdapter } from './adapters/html.js';
 import { CssAdapter } from './adapters/css.js';
 import { JsonAdapter } from './adapters/json.js';
+import { SwiftAdapter } from './adapters/swift.js';
+import { KotlinAdapter } from './adapters/kotlin.js';
+import { DartAdapter } from './adapters/dart.js';
+import { ScalaAdapter } from './adapters/scala.js';
+import { HaskellAdapter } from './adapters/haskell.js';
+import { SolidityAdapter } from './adapters/solidity.js';
+import { LuaAdapter } from './adapters/lua.js';
+import { YamlAdapter } from './adapters/yaml.js';
+import { TomlAdapter } from './adapters/toml.js';
+import { SqlAdapter } from './adapters/sql.js';
+import { MarkdownAdapter } from './adapters/markdown.js';
+import { XmlAdapter } from './adapters/xml.js';
+import { VueAdapter } from './adapters/vue.js';
+import { SvelteAdapter } from './adapters/svelte.js';
+import { TerraformAdapter } from './adapters/terraform.js';
+import { DockerfileAdapter } from './adapters/dockerfile.js';
+import { SalesforceAdapter } from './adapters/salesforce.js';
+import { CsvAdapter } from './adapters/csv.js';
+import { JsonVariantsAdapter } from './adapters/json-variants.js';
+import { ConfigAdapter } from './adapters/config.js';
+import { DocumentationAdapter } from './adapters/documentation.js';
+import { SvgAdapter } from './adapters/svg.js';
+import { TextAdapter } from './adapters/text.js';
+import { AstroAdapter } from './adapters/astro.js';
 import { GenericAdapter } from './generic.js';
 
 export type AdapterEntry = {
@@ -33,6 +57,7 @@ export class LanguageRegistry {
   }
 
   private registerDefaults() {
+    // Tier 1: Full symbol extraction (programming languages)
     this.register('ts', new TypeScriptAdapter(), 1);
     this.register('js', new JavaScriptAdapter(), 1);
     this.register('py', new PythonAdapter(), 1);
@@ -44,9 +69,37 @@ export class LanguageRegistry {
     this.register('cpp', new CppAdapter(), 1);
     this.register('csharp', new CSharpAdapter(), 1);
     this.register('php', new PhpAdapter(), 1);
+    this.register('swift', new SwiftAdapter(), 1);
+    this.register('kotlin', new KotlinAdapter(), 1);
+    this.register('dart', new DartAdapter(), 1);
+    this.register('scala', new ScalaAdapter(), 1);
+    this.register('haskell', new HaskellAdapter(), 1);
+    this.register('solidity', new SolidityAdapter(), 1);
+    this.register('lua', new LuaAdapter(), 1);
+    
+    // Tier 2: Structural extraction (markup, config, data)
     this.register('html', new HtmlAdapter(), 2);
     this.register('css', new CssAdapter(), 2);
     this.register('json', new JsonAdapter(), 2);
+    this.register('yaml', new YamlAdapter(), 2);
+    this.register('toml', new TomlAdapter(), 2);
+    this.register('sql', new SqlAdapter(), 2);
+    this.register('markdown', new MarkdownAdapter(), 2);
+    
+    // Tier 2: Additional markup and config languages
+    this.register('xml', new XmlAdapter(), 2);
+    this.register('vue', new VueAdapter(), 2);
+    this.register('svelte', new SvelteAdapter(), 2);
+    this.register('terraform', new TerraformAdapter(), 2);
+    this.register('dockerfile', new DockerfileAdapter(), 2);
+    this.register('salesforce', new SalesforceAdapter(), 2);
+    this.register('csv', new CsvAdapter(), 2);
+    this.register('json-variants', new JsonVariantsAdapter(), 2);
+    this.register('config', new ConfigAdapter(), 2);
+    this.register('documentation', new DocumentationAdapter(), 2);
+    this.register('svg', new SvgAdapter(), 2);
+    this.register('text', new TextAdapter(), 2);
+    this.register('astro', new AstroAdapter(), 2);
   }
 
   register(key: string, adapter: LanguageAdapter, tier: 1 | 2 | 3) {

package/src/language/types.ts

@@ -18,6 +18,19 @@ export enum SymbolType {
   Export = 'export',
   Comment = 'comment',
   Unknown = 'unknown',
+  Package = 'package',
+  Constructor = 'constructor',
+  Extension = 'extension',
+  Field = 'field',
+  TypeAlias = 'type_alias',
+  Document = 'document',
+  Section = 'section',
+  Table = 'table',
+  Selector = 'selector',
+  Rule = 'rule',
+  Actor = 'actor',
+  Object = 'object',
+  Protocol = 'protocol',
 }
 
 export interface CodeSymbol {

package/src/types/better-sqlite3.d.ts

@@ -0,0 +1,55 @@
+declare module 'better-sqlite3' {
+  namespace Database {
+    interface Database {
+      prepare(sql: string): Statement;
+      exec(sql: string): Database;
+      pragma(pragma: string, options?: { simple?: boolean }): any;
+      function(name: string, cb: (...args: any[]) => any): Database;
+      aggregate(name: string, options: any): Database;
+      loadExtension(path: string, entryPoint?: string): Database;
+      close(): Database;
+      defaultSafeIntegers(toggleState?: boolean): Database;
+      unsafeMode(unsafe?: boolean): Database;
+      transaction(fn: (...args: any[]) => any): (...args: any[]) => any;
+      savepoint(fn: (...args: any[]) => any): (...args: any[]) => any;
+      checkpoint(databaseName?: string): Database;
+      readonly(toggleState?: boolean): Database;
+      open: boolean;
+      inTransaction: boolean;
+      name: string;
+      memory: boolean;
+      readonly: boolean;
+    }
+
+    interface Statement {
+      database: Database;
+      source: string;
+      reader: boolean;
+      readonly: boolean;
+      busy: boolean;
+      run(...params: any[]): RunResult;
+      get(...params: any[]): any;
+      all(...params: any[]): any[];
+      iterate(...params: any[]): IterableIterator<any>;
+      pluck(toggleState?: boolean): Statement;
+      expand(toggleState?: boolean): Statement;
+      raw(toggleState?: boolean): Statement;
+      columns(toggleState?: boolean): Statement;
+      bind(...params: any[]): Statement;
+      safeIntegers(toggleState?: boolean): Statement;
+    }
+
+    interface RunResult {
+      changes: number;
+      lastInsertRowid: number | bigint;
+    }
+  }
+
+  interface DatabaseConstructor {
+    new(filename?: string | Buffer, options?: any): Database.Database;
+    (filename?: string | Buffer, options?: any): Database.Database;
+  }
+
+  const Database: DatabaseConstructor;
+  export = Database;
+}