declare let GeographicRole: import('../dist/shared/enums/geographic-role').GeographicRole
declare let ColumnRole: import('../dist/shared/enums/column-role').ColumnRole
declare let NumberFormat: import('../dist/shared/enums/number-format').NumberFormat
declare let UnitsFormat: import('../dist/shared/enums/units-format').UnitsFormat
declare let DataType: import('../dist/shared/enums/data-type').DataType
declare let AggType: import('../dist/shared/enums/agg-type').AggType

declare type DataRow = import('../dist/shared/types/data-row').DataRow
declare type ColumnReference = import('../dist/shared/types/column-reference').ColumnReference
declare type ColumnHeader = import('../dist/shared/types/column-header').ColumnHeader
declare type ExtractorOptions = import('../dist/shared/types/extractor-options').ExtractorOptions
declare type ColumnType = import('../dist/shared/types/column-type').ColumnType

// declare class Fetcher {
//   // run(request: HandlerInput, context: RunContext): Promise<void>
//   async fetch(request: HandlerInput, context: RunContext): Promise<Uint8Array>
// }

// export declare abstract class Fetcher implements Handler {
//   protected fetchSchema(request: HandlerInput, context: ExtractorContext): Promise<void>
//   protected fetchData(request: HandlerInput, context: ExtractorContext): Promise<void>
//   protected fetch(request: HandlerInput, context: ExtractorContext): Promise<any>
//   private run(request: HandlerInput, context: ExtractorContext): Promise<void>
// }

declare let ExtractorContext: import('../dist/eps/extractor/extractor-context').default

declare let Fetcher: import('../dist/eps/extractor/handlers/abstract/fetcher').Fetcher
// declare class ExtractorContext: import('../dist/eps/extractor/extractor-context').default
declare type HandlerInput = import('../dist/shared/types/handler-input').HandlerInput

declare class DataContainer {
  metaData: MetaData
  tables: DataTable[]

  getTableByName(name: string): DataTable
}

declare type MetaData = {
  name: string
  sourceType: string
}

declare class DataTable {
  private id: string
  private columns: ColumnHeader[]
  private rows: DataRow[]
  private name: string
  private properties: object

  constructor(str: string)
  addColumnHeaders(colHeaders: ColumnHeader[]): void
  setId(id: string): void
  setProperties(properties: object): void
  addRows(rows: DataRow[]): void
  getTableName(): string
  getColumns(): ColumnHeader[]
  getId(): string
  getSortedColumns(): ColumnHeader[]
  addRow(row: DataRow): void
  addColumnHeader(column: ColumnHeader): void
  createHeadersFromList(...columnNames: string[]): void
}
// declare class HandlerInput {
//   data: { [key: string]: any }
// }
// declare class RunContext {
//   data: any // { features: any; schema?: any; data?: any } | string | Uint8Array | Object[]
//   connector: ExtractorOptions
// }

declare function log(msg: any)

declare class AjaxRequest {
  static getJSON(url: string, options?: { headers?: {}; query?: {} }): Promise<JSON>
  static postJSON(url: string, options?: { headers?: {}; body?: {}; query?: {} }): Promise<JSON>
  static getArrayBuffer(url: string, options?: { headers?: {}; query?: {} }): Promise<Uint8Array>
}

declare class CsvParser {
  static parse(_data: ArrayBuffer | string, options: { name: string; hasHeader: boolean }): Promise<DataContainer>
}

declare class ExcelParser {
  static parse(data: Uint16Array): Promise<DataContainer>
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
declare function requireAsync(name: string): Promise<Promise<(args: any[]) => void>>

// declare function writeFile(name: string, data: string)

declare abstract class Parser {
  addMetaData(options: MetaData)

  createTable(name: string): DataTable

  get container()
  set container(container: DataContainer)

  parseSchema(context: typeof ExtractorContext): Promise<DataContainer>

  parseData(context: typeof ExtractorContext): Promise<DataContainer>

  parse(fetcherResult: any, input: HandlerInput): Promise<DataContainer>

  run(request: HandlerInput, context: typeof ExtractorContext): Promise<any>
}