declare module "@geo.de.tang/heavyai-connector" {
  import { EventEmitter } from "events"

  export interface ConnectionConfig {
    host?: string | string[]
    port?: number | number[]
    dbName?: string | string[]
    user?: string | string[]
    password?: string | string[]
    protocol?: string
    logging?: boolean
    platform?: string
    connectionTimeout?: number
  }

  export interface QueryResult {
    results: any[]
    timing?: {
      execution_time_ms: number
      total_time_ms: number
    }
  }

  export interface TableInfo {
    name: string
    label: string
    col_count: number
    row_count: number
  }

  export interface FieldInfo {
    name: string
    type: string
    is_array: boolean
    is_dict: boolean
    precision?: number
  }

  export interface DashboardInfo {
    dashboard_id: number
    dashboard_name: string
    owner: string
    dashboard_state: string
    image_hash: string
    update_time: string
    dashboard_metadata: string
  }

  export interface UserInfo {
    user_name: string
    is_super: boolean
    default_db: string
  }

  export interface ServerInfo {
    host_name: string
    version: string
    rendering_enabled: boolean
    start_time: number
    edition: string
    host_id: string
  }

  export interface MemoryInfo {
    host_name: string
    max_cpu_slab_size: number
    max_gpu_slab_size: number
    page_size: number
    max_cpu_slab_num_pages: number
    max_gpu_slab_num_pages: number
    num_cpu_slabs: number
    num_gpu_slabs: number
    cpu_slab_size: number
    gpu_slab_size: number
  }

  export interface ImportOptions {
    copy_params?: {
      delimiter?: string
      null_str?: string
      has_header?: boolean
      quoted?: boolean
      quote?: string
      escape?: string
      line_delim?: string
      array_delim?: string
      array_begin?: string
      array_end?: string
      threads?: number
      max_reject?: number
      buffer_size?: number
    }
    row_desc?: Array<{
      col_name: string
      col_type: {
        type: number
        encoding?: number
        nullable?: boolean
        is_array?: boolean
        precision?: number
        scale?: number
        comp_param?: number
      }
    }>
  }

  export class DbCon extends EventEmitter {
    constructor()

    // Connection configuration methods
    host(host?: string | string[]): string[] | DbCon
    port(port?: number | number[]): number[] | DbCon
    dbName(dbName?: string | string[]): string[] | DbCon
    user(user?: string | string[]): string[] | DbCon
    password(password?: string | string[]): string[] | DbCon
    protocol(protocol?: string): string | DbCon
    logging(logging?: boolean): boolean | DbCon
    platform(platform?: string): string | DbCon
    connectionTimeout(timeout?: number): number | DbCon

    // Connection management
    connect(): Promise<DbCon>
    disconnect(): Promise<void>

    // Query methods
    query(query: string, options?: any): Promise<QueryResult>
    queryAsync(query: string, options?: any): Promise<QueryResult>
    queryDFAsync(query: string, options?: any): Promise<any>
    validateQuery(query: string): Promise<any>

    // Table management
    getTables(): Promise<TableInfo[]>
    getTablesAsync(): Promise<TableInfo[]>
    getFields(tableName: string): Promise<FieldInfo[]>
    getFieldsAsync(tableName: string): Promise<FieldInfo[]>
    createTable(
      tableName: string,
      rowDesc: any[],
      tableType?: number
    ): Promise<void>
    createTableAsync(
      tableName: string,
      rowDesc: any[],
      tableType?: number
    ): Promise<void>
    importTable(
      tableName: string,
      fileName: string,
      options?: ImportOptions
    ): Promise<void>
    importTableAsync(
      tableName: string,
      fileName: string,
      options?: ImportOptions
    ): Promise<void>
    importTableGeo(
      tableName: string,
      fileName: string,
      options?: ImportOptions
    ): Promise<void>
    importTableGeoAsync(
      tableName: string,
      fileName: string,
      options?: ImportOptions
    ): Promise<void>
    detectColumnTypes(fileName: string, options?: ImportOptions): Promise<any>
    detectColumnTypesAsync(
      fileName: string,
      options?: ImportOptions
    ): Promise<any>

    // Dashboard management
    getDashboards(): Promise<DashboardInfo[]>
    getDashboardsAsync(): Promise<DashboardInfo[]>
    createDashboard(
      dashboardName: string,
      dashboardState: string,
      imageHash: string,
      dashboardMetadata?: string
    ): Promise<number>
    createDashboardAsync(
      dashboardName: string,
      dashboardState: string,
      imageHash: string,
      dashboardMetadata?: string
    ): Promise<number>
    replaceDashboard(
      dashboardId: number,
      dashboardName: string,
      dashboardState: string,
      imageHash: string,
      dashboardMetadata?: string
    ): Promise<void>
    replaceDashboardAsync(
      dashboardId: number,
      dashboardName: string,
      dashboardState: string,
      imageHash: string,
      dashboardMetadata?: string
    ): Promise<void>
    deleteDashboard(dashboardId: number): Promise<void>
    deleteDashboardAsync(dashboardId: number): Promise<void>

    // User management
    getUsers(): Promise<UserInfo[]>
    getUsersAsync(): Promise<UserInfo[]>
    createUser(
      userName: string,
      userPassword: string,
      isSuper?: boolean
    ): Promise<void>
    createUserAsync(
      userName: string,
      userPassword: string,
      isSuper?: boolean
    ): Promise<void>
    deleteUser(userName: string): Promise<void>
    deleteUserAsync(userName: string): Promise<void>

    // Database information
    getDatabases(): Promise<string[]>
    getDatabasesAsync(): Promise<string[]>
    getStatus(): Promise<ServerInfo[]>
    getStatusAsync(): Promise<ServerInfo[]>
    getHardwareInfo(): Promise<any>
    getHardwareInfoAsync(): Promise<any>
    getMemory(): Promise<MemoryInfo[]>
    getMemoryAsync(): Promise<MemoryInfo[]>
    getRoles(): Promise<string[]>
    getRolesAsync(): Promise<string[]>

    // Rendering methods
    renderVega(widget: any, options?: any, vega?: any): Promise<any>
    renderVegaAsync(widget: any, options?: any, vega?: any): Promise<any>
    getRenderStatus(): Promise<any>
    getRenderStatusAsync(): Promise<any>

    // Utility methods
    wrapTimeout(promise: Promise<any>, timeout: number | null): Promise<any>
    convertFromThriftTypes(fields: any): FieldInfo[]

    // Internal methods
    executeSingleClient(method: string, ...args: any[]): Promise<any>
    executeAllClients(method: string, ...args: any[]): Promise<any>
    addPendingRequest(requestId: string): void
  }

  // Default export
  export default DbCon

  // Re-export Thrift types
  export * from "./thrift/common_types"
  export * from "./thrift/completion_hints_types"
  export * from "./thrift/extension_functions_types"
  export * from "./thrift/Heavy"
  export * from "./thrift/heavy_types"
  export * from "./thrift/serialized_result_set_types"
}