archiyou 0.7.0

package/dist/src/Brep.d.ts

@@ -0,0 +1,152 @@
+import { Vector, Point, Obj, Vertex, Edge, Wire, Face, Shell, Solid, ShapeCollection, Sketch, PointLike, SelectionString, PointLikeSequence, MakeWireInput, MakeFaceInput, MakeShellInput, MakeSolidInput, AnyShapeOrCollection, AnyShapeOrCollectionOrSelectionString, ModelUnits, SketchPlaneName, Annotator } from './internal';
+declare global {
+    interface Console {
+        geom: any;
+        user: any;
+        exec: any;
+    }
+}
+export declare class Brep {
+    _oc: any;
+    _annotator: Annotator;
+    _console: any;
+    _cache: {
+        (key: string): any;
+    };
+    _units: ModelUnits;
+    scene: Obj;
+    activeLayer: Obj;
+    layerStack: Array<Obj>;
+    activeSketch: Sketch;
+    _duration: number;
+    _captureShapesStart: ShapeCollection;
+    _activeLayerGroup: Obj;
+    constructor();
+    units(u?: ModelUnits): ModelUnits;
+    /** Creates a 2D/3D Point */
+    Point(p: PointLike, ...args: any[]): Point;
+    /** Creates a 2D/3D Vector */
+    Vector(p: PointLike, ...args: any[]): Vector;
+    /** Creates a 2D/3D Point */
+    Vertex(p: PointLike, ...args: any[]): Vertex;
+    /** Creates a Line Edge */
+    Edge(start: PointLike, end: PointLike): Edge;
+    /** Create a Line Edge */
+    Line(start: PointLike, end: PointLike): Edge;
+    /** Make an Arc with start, mid and end Point */
+    Arc(start: PointLike, mid: PointLike, end: PointLike): Edge;
+    /** Make a Spline going through given Points */
+    Spline(points: PointLikeSequence, ...args: any[]): Edge;
+    /** Creates a Wire out of sequence of Points, Edges */
+    Wire(entities: MakeWireInput, ...args: any[]): Wire;
+    /** Make Line Wire by supplying multiple points */
+    Polyline(entities: MakeWireInput, ...args: any[]): Wire;
+    /** Make 2D Spiral */
+    Spiral(firstRadius: number, secondRadius: number, angle: number, lefthand: boolean): Wire;
+    Helix(radius?: number, height?: number, angle?: number, pivot?: PointLike, direction?: PointLike, lefthand?: boolean, coneSemiAngle?: number): Wire;
+    /** Creates an Face */
+    Face(entities: MakeFaceInput, ...args: any[]): Face | Shell;
+    /** Create a planar Face with width and depth and optional position */
+    Plane(width?: number, depth?: number, normal?: PointLike, position?: PointLike): Face;
+    /** Create a planar Face between two Points */
+    PlaneBetween(from: PointLike, to: PointLike): Face;
+    /** Create a 2D planar Face */
+    Rect(width?: number, depth?: number, position?: PointLike): Face;
+    /** Creates a rectangular Face */
+    RectBetween(from: PointLike, to: PointLike): Face;
+    /** Create the basic planes along the main axis */
+    BasePlane(axis?: string, size?: number): Face;
+    /** Create circular Face */
+    Circle(radius?: number): Face | Shell;
+    /** Create a Shell */
+    Shell(entities: MakeShellInput, ...args: any[]): Shell;
+    /** Create a Solid */
+    Solid(shells: MakeSolidInput, ...args: any[]): Solid;
+    /** Create a Solid Box with width, depth and height and optional a position */
+    Box(width?: number, depth?: number, height?: number, position?: PointLike): Solid;
+    /** Alias for a Solid Box with width, depth and height and optional a position */
+    Cube(width?: number, depth?: number, height?: number, position?: PointLike): Solid;
+    BoxBetween(from: PointLike, to: PointLike): Solid;
+    /** Create a Solid Sphere */
+    Sphere(radius?: number, position?: PointLike): Solid;
+    /** Create a Solid Cone */
+    Cone(bottomRadius?: number, topRadius?: number, height?: number, position?: PointLike): Solid;
+    /** Create a Solid Cylinder */
+    Cylinder(radius?: number, height?: number, position?: PointLike, angle?: number): Solid;
+    /** Start sketching a 2D Shape on a given plane, face, or plane given by xAxis and yAxis */
+    sketch(plane?: SketchPlaneName | Face | PointLike, yAxis?: PointLike): Sketch;
+    isTemp(): void;
+    select(selectionString: SelectionString): void;
+    atVertices(): void;
+    moveTo(point: PointLike, ...args: any[]): void;
+    lineTo(point: PointLike, ...args: any[]): void;
+    splineTo(points: PointLikeSequence, ...args: any[]): void;
+    arcTo(mid: PointLike, end: PointLike): void;
+    rectTo(point: PointLike, ...args: any[]): void;
+    rect(width?: number, height?: number): void;
+    circleTo(point: PointLike, ...args: any[]): void;
+    circle(radius: number): void;
+    close(): void;
+    combine(): void;
+    mirror(origin?: PointLike, direction?: Vector, autoOp?: boolean): void;
+    offset(amount?: number, type?: string): void;
+    offsetted(amount?: number, type?: string): void;
+    fillet(size?: number, vertices?: AnyShapeOrCollectionOrSelectionString): void;
+    chamfer(distance?: number, angle?: number, vertices?: AnyShapeOrCollectionOrSelectionString): void;
+    thicken(distance?: number): void;
+    thickened(distance?: number): void;
+    importSketch(): AnyShapeOrCollection;
+    /** Group Shapes into a ShapeCollection */
+    group(shapes: AnyShapeOrCollection, ...args: any[]): ShapeCollection;
+    /** Group Shapes into a ShapeCollection */
+    collection(shapes: AnyShapeOrCollection, ...args: any[]): ShapeCollection;
+    /** Group Shapes into a ShapeCollection */
+    Collection(shapes: AnyShapeOrCollection, ...args: any[]): ShapeCollection;
+    /** Get active layer of group of layers */
+    getActiveLayer(): Obj;
+    addToActiveLayer(obj: Obj): this;
+    /** Add layer Obj to parent */
+    addToActiveLayerParent(layer: Obj): void;
+    /** Recursively get all objects within the scene Obj */
+    allObjs(): Obj[];
+    /** Remove Obj from Scene */
+    removeObj(o: Obj): void;
+    /** Return all Shapes in Scene as ShapeCollection */
+    all(): ShapeCollection;
+    /** Return all shapes on the active layer */
+    layerShapes(): ShapeCollection;
+    /** Create and/or activate a layer as sibling to active layer (or Scene)
+     *  IMPORTANT: a layer is always a direct child of the Scene root
+    */
+    layer(name?: string): Obj;
+    getLayerNames(): Array<string>;
+    getObjNames(): Array<string>;
+    /** Set Layer Obj as active */
+    setActiveLayer(layerObj: Obj): Obj;
+    getLayer(layerName?: string): Obj;
+    /** get Shapes of given/active layer */
+    getLayerShapes(layerName?: string): ShapeCollection;
+    deleteLayer(layerName?: string): boolean;
+    getLatestLayerOnStack(): Obj;
+    returnToPreviousLayer(): Obj;
+    /** return to Scene root Obj */
+    resetLayers(): Obj;
+    /** clean out the scene and reset stuff if needed */
+    reset(): void;
+    /** Get a name for a layer based on existing ones and a pattern */
+    getNextLayerName(name: string): string;
+    /** Get unique name based on current names in Scene */
+    getNextObjName(name: string): string;
+    /** Start combining new layers into another layer with given name
+     *  Call endLayerGroup() to stop grouping layers
+     *  TODO: For later advanced use we can even supply a name of a parent Obj
+    */
+    layerGroup(name: string, inObjName?: string): Obj;
+    /** end grouping of Layer. Layers are now again created on scene root */
+    endLayerGroup(): Obj;
+    /** Start capturing of all new Shapes  */
+    _captureShapes(): ShapeCollection;
+    /** Capture all created shapes between points in time by comparing current to _captureShapesStart */
+    _captureShapesEnd(): ShapeCollection;
+    sceneToOCCompound(): void;
+}

package/dist/src/Calc.d.ts

@@ -0,0 +1,48 @@
+import { ArchiyouApp, Brep, Db, Table, Metric, MetricName, MetricOptions, TableLocation, DataRows } from './internal';
+export declare class Calc {
+    _ay: ArchiyouApp;
+    _brep: Brep;
+    db: Db;
+    dbData: Object;
+    _metrics: {
+        [key: string]: Metric;
+    };
+    gsheets: Record<string, any>;
+    constructor();
+    setArchiyou(ay: ArchiyouApp): void;
+    /** We need to know when we can load the Shapes */
+    init(): void;
+    reset(): void;
+    /** Get names of tables */
+    tables(): Array<string>;
+    /** Get table instances */
+    getTables(only: Array<string>): Array<Table>;
+    getTableNames(): Array<string>;
+    /** Make or get table with data
+     *  @param name string
+     *  @param data [ val1, val2, val3 ] or [{ col1: val1, col2: val2 }{ ... }]
+    */
+    table(name: string, data?: DataRows, columns?: Array<string>): Calc | Table;
+    /** Output raw data */
+    toTableData(only?: Array<string>): Record<string, Object>;
+    toMetricsData(only?: Array<string>): Record<string, Metric>;
+    /** Get internal metric objects */
+    metrics(): Record<string, Metric>;
+    /** Get internal metric objects with filtering
+     * @param only - array of metric names to filter by, or '*' to get all metrics
+      */
+    getMetrics(only?: Array<string>): Array<Metric>;
+    /** Add Metric element to dashboard */
+    metric(name: MetricName, data: string | number, options: MetricOptions): Metric;
+    /** Convert metrics to own table */
+    metricsToTable(): Table;
+    getMetricNames(): Array<string>;
+    setupGSheetUtils(): void;
+    /** Get raw data by simple table lookup with location and return TableLocation object
+     *  We can expect values like:
+     *       tableName
+     *       otherTable.columnname => all values in column
+     *       otherTable[1] => all values in row
+    */
+    _resolveTableLocation(tableLocation: string): TableLocation;
+}

package/dist/src/CalcDb.d.ts

@@ -0,0 +1,33 @@
+import { Brep, Table } from './internal';
+export declare class Db {
+    DEBUG: boolean;
+    UNNAMED_TABLE: string;
+    _brep: Brep;
+    _tables: Object;
+    shapes: Table;
+    objects: Table;
+    constructor(brep: Brep);
+    init(): void;
+    isInitiated(): boolean;
+    /** reset  */
+    reset(): void;
+    /** Generate standard tables  */
+    setupTables(): void;
+    saveTable(table: Table, name?: string): void;
+    /** Rename table and update its references in Db */
+    renameTable(table: Table, newName: string): void;
+    /** Get names of tables */
+    tables(): Array<string>;
+    table(name: string): Table;
+    generateShapesData(): Array<Object>;
+    generateObjsData(): Array<Object>;
+    /** Output tables as raw data */
+    toTableData(only?: string | Array<string>): Record<string, Object>;
+    /** Output tables as Excel file buffers  */
+    toTableExcel(only?: string | Array<string>): Promise<Record<string, ArrayBuffer>>;
+    generateTestShapesData(amount?: number): Array<Object>;
+    generateTestShape(): Object;
+    generateTestObjsData(amount?: number): Array<Object>;
+    generateTestObj(): Object;
+    randomShapeType(): string;
+}

package/dist/src/CalcTable.d.ts

@@ -0,0 +1,60 @@
+import { JSONSchema7 } from 'json-schema';
+import { Db, DataRowsColumnValue, DataRowColumnValue, DataRows } from './internal';
+export declare class Table {
+    DEFAULT_COL_NAME: string;
+    _name: string;
+    _db: Db;
+    _dataRows: DataRowsColumnValue;
+    _schema: JSONSchema7;
+    _component: string;
+    /** Make Table from rows with Objects or values */
+    constructor(data: DataRows, columns?: Array<string>);
+    /** Print table to console */
+    print(): DataRowsColumnValue;
+    /** Get/set name */
+    name(newName?: string): string | Table;
+    /** Set JSON schema for defining the structure of this table */
+    schema(schema?: JSONSchema7): this;
+    /** Validate this Table against its schema */
+    validate(): void;
+    /** Save this Table in the database*/
+    save(name: string): Table;
+    firstRow(): DataRowColumnValue;
+    /** Get size of table in rows and columns */
+    shape(): Array<number>;
+    size(): Array<number>;
+    numRows(): number;
+    numColumns(): number;
+    /** Set name of columns */
+    setColumns(names: Array<string>): Table;
+    /** Get column names */
+    columns(): Array<string>;
+    /** Return index labels. By default serial integers */
+    index(): Array<string | number>;
+    /** Add a simple row consisting of valyues */
+    addRow(row: Array<string | number | Record<string, string | number>>): this;
+    /** Output raw data in rows
+     * in format { [col1: row1val, col2: row1val2], [col1: row2val, ..] ... }
+    * */
+    toData(): DataRows;
+    /** Export this Table to Excel format in ArrayBuffer
+     * We use write-excel-file (https://www.npmjs.com/package/write-excel-file)
+     *  And use automatic value type detection
+    */
+    toExcel(): Promise<ArrayBuffer>;
+    /** Output to Row objects */
+    toDataRows(): DataRowsColumnValue;
+    /** Output to raw Array of values of this column */
+    toDataColumn(columnName: string): Array<number | string>;
+    _protectNullUndefined(value: any): any;
+    _zip(keys: Array<string>, values: Array<any>): {};
+    _checkColumn(name: string): boolean;
+    _checkColumns(names: Array<string>): string[];
+    /** Remap keys of Object to new */
+    _remapObject(obj: Object, map: Object): {};
+    /** We need to convert some values into their real type */
+    _makeRealValue(value: string): string | number | boolean;
+    _isNumeric(value: string): boolean;
+    _checkObject(obj: Object, columns: Array<string>): boolean;
+    _range(startIndex: number, endIndex: number): Array<number>;
+}

package/dist/src/CalcTableIO.d.ts

@@ -0,0 +1,130 @@
+import { Table } from './internal';
+interface GoogleDriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    parents: string[];
+    createdTime: string;
+    modifiedTime: string;
+}
+type GoogleDriveItem = GoogleDriveFile & {
+    type: 'folder' | 'file';
+};
+interface GoogleSheetNamedRange {
+    name: string;
+    range: GoogleSheetRange;
+}
+interface GoogleSheetRange {
+    sheetId: string;
+    startRowIndex: number;
+    startColumnIndex: number;
+    endRowIndex: number;
+    endColumnIndex: number;
+}
+type GoogleSpreadsheet = any;
+type GoogleSpreadsheetCell = any;
+export declare class TableIO {
+    GOOGLE_KEYFILE_PATH: string;
+    GOOGLE_SHEETS_BASE_URL: string;
+    _table: Table;
+    _googleModule: any;
+    _googleSpreadsheetModule: any;
+    _googleAuth: any;
+    _googleDriveId: string;
+    constructor(table?: Table);
+    /** Export table to Excel format */
+    exportExcel(table: Table): Promise<ArrayBuffer>;
+    exportGoogleSheets(table: Table, email: string, key: string): Promise<void>;
+    /** Load Google module and authenticate  */
+    initGoogle(keyfilePath?: string, driveId?: string): Promise<this>;
+    checkGoogleInitialized(): void;
+    /** Create new Google Sheet document and return its id */
+    createGoogleSheet(title: string, folderPath: string): Promise<string>;
+    _googleListFolder(folderId: string): Promise<Array<GoogleDriveItem>>;
+    /** List a folder specific by path
+    * Get files and folders from Google Drive based on path
+    * @param path - Path relative to the main folder (e.g., './', 'subfolder1', 'subfolder1/subfolder2')
+    * @returns Array of file/folder objects with id, name, type, and mimeType
+    */
+    _googleListPath(path?: string): Promise<Array<GoogleDriveItem>>;
+    /** Get file or folder by path, return undefined if not exists
+     *  @param path - Path relative to the main folder (e.g., './', 'subfolder1/file.txt')
+     *  @returns File or Folder item
+     */
+    _googleGetPathItem(path: string): Promise<GoogleDriveItem | undefined>;
+    /** Copy a Google Drive item to a new location given as path
+     *  NOTE: Please make sure the folders exist!
+     */
+    copyGoogleItem(item: GoogleDriveItem, itemNewPath: string): Promise<GoogleDriveItem>;
+    /** Get content of item by path
+     *  If path is file get file contents
+     *  If path is folder get list of items in folder
+     */
+    private _googleGetContentPath;
+    /** Get content of a file or folder */
+    private _googleGetItemContent;
+    /** Get content of a file based on its mimeType */
+    private _googleGetItemFileContent;
+    private _isGoogleWorkspaceFile;
+    /** Export Google Workspace files to downloadable formats */
+    private _exportGoogleWorkspaceFile;
+    /** Download regular (non-Google Workspace) files */
+    private _downloadRegularFile;
+    openGoogleSheet(sheetId: string): Promise<GoogleSpreadsheet>;
+    /** Powertool that creates a copy of a template sheet
+     *  then fills in the inputs, resolve any IMPORTRANGE formulas, and returns the id of a new sheet
+     */
+    googleSheetFromTemplate(templateSheetPath: string, newSheetPath: string, inputs: Record<string, any>, makePublic?: boolean, returnUrl?: boolean): Promise<string>;
+    /** Load module google-spreadsheet dynamically */
+    _initGoogleSpreadsheet(): Promise<void>;
+    /** Get named ranges from a Google Sheet
+     *  Named ranges are predefined ranges of cells that can be referenced by name
+     *  NOTE: Named ranges are global to the spreadsheet, not per worksheet
+     *  @param sheet - Google Spreadsheet object
+     *  @returns Array of named ranges with their details
+     *  @example
+     *    [
+     *      {
+     *        namedRangeId: 'g34lb4bdpigh',
+     *        name: 'MyNamedRange',
+     *        range: {
+     *            sheetId: 0,
+     *            startRowIndex: 1,
+     *            endRowIndex: 5,
+     *            startColumnIndex: 1,
+     *            endColumnIndex: 3
+     *        }
+     *      },
+     *      ...
+     *  ]
+     *
+     *  NOTE: Because google-spreadsheet doesn't support named ranges yet, we implement it using Google API directly
+     *
+     */
+    _googleSheetGetNamedRanges(sheet: GoogleSpreadsheet): Promise<Array<GoogleSheetNamedRange>>;
+    /** Set and save inputs on a Google Sheet
+     *  We use named ranges to set inputs (inputs.<<name>>)
+     *  So make sure to define named ranges in the sheet like inputs.width, inputs.depth, etc.
+     *  @param inputs - Record of named range to values
+     *
+    */
+    googleSheetSetInputs(sheet: GoogleSpreadsheet, inputs: Record<string, any>): Promise<void>;
+    /** Replace any references to other sheets (using IMPORTRANGE)
+     *  with actual data from the referenced sheets
+     *  For now search all worksheets for IMPORTRANGE formulas
+     *
+     *  @param sheet - Google Spreadsheet object
+     *  @param worksheets - Optional array of worksheet names to process, if empty process all. Case insensitive.
+     */
+    googleSheetResolveImportRangeFormulas(sheet: GoogleSpreadsheet, worksheets?: Array<string>): Promise<void>;
+    _googleWorksheetIterateCells(worksheet: any, callback: (cell: GoogleSpreadsheetCell, row: number, col: number) => void): Promise<void>;
+    /** Iterate over cells in a sheet, or specific worksheet
+     *  If callback returns GoogleSpreadsheetCell instance, update the cells content
+     */
+    _googleSheetIterEditCells(sheet: GoogleSpreadsheet, worksheets: Array<string>, callback: (cell: GoogleSpreadsheetCell, row: any, col: number) => Promise<GoogleSpreadsheetCell | void>): Promise<void>;
+    /** Set permissions on a Google Drive file using Drive API directly */
+    googleDriveSetPermissions(sheet: GoogleSpreadsheet, role: 'reader' | 'writer' | 'commenter', type: 'user' | 'group' | 'domain' | 'anyone', emailAddress?: string): Promise<void>;
+    /** Remove public access from a Google Drive file */
+    googleDriveRemovePublicAccess(sheet: GoogleSpreadsheet): Promise<void>;
+}
+export {};

package/dist/src/CodeParser.d.ts

@@ -0,0 +1,58 @@
+import { Statement } from './internal';
+import { Options, Node } from 'acorn';
+import { ScriptVersion, ImportStatement } from './models';
+import { IO } from './IO';
+interface PreStats {
+    numStatements: number;
+}
+export declare class CodeParser {
+    ACORN_OPTIONS: Options;
+    IMPORT_RE: RegExp;
+    LOAD_RE: RegExp;
+    DOC_RE: RegExp;
+    config: any;
+    code: string;
+    io: IO;
+    tree: any;
+    statements: Array<Statement>;
+    importStatements: Array<ImportStatement>;
+    prestats: PreStats;
+    importedScriptCache: {
+        [key: string]: ScriptVersion;
+    };
+    importedScriptQueue: Array<ImportStatement>;
+    constructor(code: string, config: any, io: IO);
+    update(code: string, config?: any): void;
+    /** Split as best as possible into seperate statements to be executed */
+    parse(): void;
+    /** Create Statements from AST tree */
+    makeStatements(): Array<Statement>;
+    getGlobalVars(): Array<string>;
+    getCodeOfNode(node: Node): string;
+    /** Filter statement on a given filters */
+    filterStatements(): void;
+    removeDeclarations(): void;
+    addComponentCodeDeclarations(componentCode: string): string;
+    /** Preload special statements like $import and $load which need to fetch data */
+    preloadSpecialStatements(): Promise<Statement[]>;
+    transformImportStatement(importStatement: ImportStatement, importedScript: ScriptVersion): void;
+    parseImportStatement(statement: Statement): ImportStatement;
+    /** Fetch component from cache or from servers */
+    fetchImportScript(importStatement: ImportStatement): Promise<ScriptVersion>;
+    handleFetchedImportScript(response: any): Promise<ScriptVersion>;
+    handleFetchedImportScriptError(importStatement: ImportStatement): void;
+    manageImportScriptQueue(): void;
+    placeImportScriptInCache(script: ScriptVersion): void;
+    /** Get import script from cache */
+    getImportScriptFromCache(name: string): Promise<ScriptVersion>;
+    /** Test is a given statement is a import statement */
+    isImportStatement(statement: Statement): boolean;
+    isLoadStatement(statement: Statement): boolean;
+    isDocStatement(statement: Statement): boolean;
+    /** Output statements */
+    getStatements(): Promise<Array<Statement>>;
+    /** Synchronous call to get statement without importing components */
+    getStatementsWithoutImports(): Array<Statement>;
+    _generateImportedScriptRealCode(importedScript: ScriptVersion, importStatement: ImportStatement): string;
+}
+export {};

package/dist/src/ComponentManager.d.ts

@@ -0,0 +1,33 @@
+import { ArchiyouApp, ScriptVersion } from './internal';
+export declare class ComponentManager {
+    _ay: ArchiyouApp;
+    _components: Record<string, any>;
+    _scriptCache: Record<string, any>;
+    constructor(_ay: ArchiyouApp);
+    /** Register a component for importing
+     *
+     *  @param path - the path to the component script on Archiyou platform, can be with or without version
+     *                  'archiyou/wall:1.0' or 'archiyou/wall' - version pinning is probably better
+     *  @params params - any parameters values to pass to the component
+     *  @params options - any options to pass to the component - repe
+     *
+     *  $component[an instance of ComponentManager].load('path/to/my-component.js')
+     *
+    */
+    load(path: string, params: Record<string, any>, options: Record<string, any>): this;
+}
+/** ImportComponent */
+export declare class ImportComponent {
+    _manager: ComponentManager;
+    _path: string;
+    _params: Record<string, any>;
+    _options: Record<string, any>;
+    _script: ScriptVersion;
+    _error: boolean;
+    constructor(path: string, params: Record<string, any>, options: Record<string, any>);
+    setManager(manager: ComponentManager): this;
+    /** Fetch the script of the component */
+    fetchScript(useCache?: boolean): Promise<this>;
+    /** Give information on the component by loading it  */
+    info(): void;
+}

package/dist/src/Console.d.ts

@@ -0,0 +1,34 @@
+import { ConsoleMessage, ConsoleMessageType } from './types';
+export declare class Console {
+    USE_COLORS: boolean;
+    ENDING_COLOR: string;
+    TYPE_TO_COLOR_CODE: Record<ConsoleMessageType, string>;
+    output: any;
+    buffer: Array<ConsoleMessage>;
+    _originalConsole: any;
+    constructor(output: any);
+    /** Binds either to Vuex store, WebWorker, direct console or an internal array */
+    connect(output?: any): void;
+    /** Reset the Console, removing all previous messages */
+    reset(): void;
+    _getOutputType(): string;
+    /** pass the message allong */
+    sendMessage(message: ConsoleMessage): void;
+    _wrapMessageStringWithColor(message: ConsoleMessage): string;
+    newMessage(type: ConsoleMessageType, message: any): void;
+    stringifyMessage(message: any): string;
+    info(message: any): void;
+    log(message: any): void;
+    /** Make a user message */
+    user(message: any): void;
+    /** log an error */
+    error(message: any): void;
+    warn(message: any): void;
+    /** Creation of geometry */
+    geom(message: any): void;
+    /** Messages about statement execution */
+    exec(message: any): void;
+    _currentTime(): string;
+    getBufferedMessages(types?: Array<ConsoleMessageType>): Array<ConsoleMessage>;
+    getErrors(): Array<ConsoleMessage>;
+}