import { ConwayGeometry, FileHandlerFunction as FileHandlerCallback } from '@bldrs-ai/conway';
import * as glmatrix from 'gl-matrix';
import { IfcApiModelPassthrough } from './ifc_api_model_passthrough';
import { Properties } from './properties';
export * from './ifc2x4';
export declare const UNKNOWN = 0;
export declare const STRING = 1;
export declare const LABEL = 2;
export declare const ENUM = 3;
export declare const REAL = 4;
export declare const REF = 5;
export declare const EMPTY = 6;
export declare const SET_BEGIN = 7;
export declare const SET_END = 8;
export declare const LINE_END = 9;
export interface Loadersettings {
    COORDINATE_TO_ORIGIN: boolean;
    USE_FAST_BOOLS: boolean;
    CIRCLE_SEGMENTS_LOW?: number;
    CIRCLE_SEGMENTS_MEDIUM?: number;
    CIRCLE_SEGMENTS_HIGH?: number;
    BOOL_ABORT_THRESHOLD?: number;
}
export interface Vector<T> {
    get(index: number): T;
    push(parameter: T): void;
    size(): number;
}
export interface Color {
    x: number;
    y: number;
    z: number;
    w: number;
}
export interface PlacedGeometry {
    color: Color;
    geometryExpressID: number;
    flatTransformation: Array<number>;
}
export interface FlatMesh {
    geometries: Vector<PlacedGeometry>;
    expressID: number;
}
export interface RawLineData {
    ID: number;
    type: number;
    arguments: any[];
}
export interface LoaderError {
    type: string;
    message: string;
    expressID: number;
    ifcType: number;
}
export interface IfcGeometry {
    GetVertexData(): number;
    GetVertexDataSize(): number;
    GetIndexData(): number;
    GetIndexDataSize(): number;
}
/**
 * @return {number} current time in ms
 */
export declare function ms(): number;
export type LocateFileHandlerFn = FileHandlerCallback;
/**
 * IfcAPI - Web-IFC API Shim Implementation for full read functionality
 */
export declare class IfcAPI {
    wasmModule: undefined | any;
    fs: undefined | any;
    wasmPath: string;
    isWasmPathAbsolute: boolean;
    settings: Loadersettings | undefined;
    globalModelIDCounter: number;
    models: Map<number, IfcApiModelPassthrough>;
    conwaywasm: ConwayGeometry;
    _isCoordinated: boolean;
    linearScalingFactor: number;
    identity: number[];
    NormalizeMat: glmatrix.mat4;
    properties: Properties;
    /**
     * Get the passthrough for a particular model id.
     *
     * @param modelID
     * @return {IfcApiModelPassthrough | undefined}
     */
    getPassthrough(modelID: number): IfcApiModelPassthrough | undefined;
    /**
     * Initializes the WASM module (WebIFCWasm), required before using any other functionality.
     *
     * @param customLocateFileHandler An optional locateFile function that let's
     * you override the path from which the wasm module is loaded.
     */
    Init(customLocateFileHandler?: LocateFileHandlerFn): Promise<void>;
    /**
     * Opens a model and returns a modelID number
     *
     * @param data containing IFC data (bytes)
     * @param settings settings for loading the model
     * @return {number} model ID
     */
    OpenModel(data: Uint8Array, settings?: Loadersettings): number;
    /**
     * Creates a new model and returns a modelID number (unimplemented)
     *
     * @param settings settings for generating data the model
     * @return {number} model ID
     */
    CreateModel(settings?: Loadersettings): number;
    /**
     *
     * @param modelID
     * @return {Uint8Array} unimplemented
     */
    ExportFileAsIFC(modelID: number): Uint8Array;
    /**
     * Opens a model and returns a modelID number
     *
     * @param modelID handle retrieved by OpenModel, model must not be closed
     * @param geometryExpressID containing IFC data (bytes)
     * @return {IfcGeometry}
     */
    GetGeometry(modelID: number, geometryExpressID: number): IfcGeometry;
    /**
     *
     * @param modelID
     * @param expressID
     * @param flatten
     * @return {any} line data
     */
    GetLine(modelID: number, expressID: number, flatten?: boolean): string | void;
    /**
     *
     * @param modelID
     * @return {Vector<LoaderError>}
     */
    GetAndClearErrors(modelID: number): Vector<LoaderError>;
    /**
     *
     * @param modelID
     * @param lineObject
     */
    WriteLine(modelID: number, lineObject: any): void;
    /**
     *
     * @param modelID
     * @param line
     * @return {string | undefined}
     */
    FlattenLine(modelID: number, line: any): void;
    /**
     *
     * @param modelID
     * @param expressID
     * @return {RawLineData}
     */
    GetRawLineData(modelID: number, expressID: number): RawLineData;
    /**
     * Get all line ids with the matching type
     *
     * @param modelID
     * @param type
     * @return {Vector<number>} The matching express IDs
     */
    GetLineIDsWithType(modelID: number, type: number): Vector<number>;
    /**
     *
     * @param modelID
     * @return {Vector<number>}
     */
    GetAllLines(modelID: number): Vector<number>;
    /**
     *
     * @param modelID
     * @param transformationMatrix
     */
    setGeometryTransformation(modelID: number, transformationMatrix: Array<number>): void;
    /**
     *
     * @param modelID
     * @return {Array<number>}
     */
    GetCoordinationMatrix(modelID: number): Array<number>;
    /**
     *
     * @param ptr
     * @param size
     * @return {Float32Array}
     */
    GetVertexArray(ptr: number, size: number): Float32Array;
    /**
     *
     * @param ptr
     * @param size
     * @return {Uint32Array}
     */
    GetIndexArray(ptr: number, size: number): Uint32Array;
    /**
     *
     * @param heap
     * @param startPtr
     * @param sizeBytes
     * @return {Float32Array | Uint32Array}
     */
    getSubArray(heap: Float32Array | Uint32Array, startPtr: number, sizeBytes: number): Float32Array | Uint32Array;
    /**
     * Closes a model and frees all related memory
     *
     * @param modelID Model handle retrieved by OpenModel, model must not be closed
     */
    CloseModel(modelID: number): void;
    /**
     *
     * @param modelID
     * @param meshCallback
     */
    StreamAllMeshes(modelID: number, meshCallback: (mesh: FlatMesh) => void): void;
    /**
     *
     * @param modelID
     * @param types
     * @param meshCallback
     */
    StreamAllMeshesWithTypes(modelID: number, types: Array<number>, meshCallback: (mesh: FlatMesh) => void): void;
    /**
     * Checks if a specific model ID is open or closed
     *
     * @param modelID handle retrieved by OpenModel
     * @return {boolean}
     */
    IsModelOpen(modelID: number): boolean;
    /**
     * Load all geometry in a model
     *
     * @param modelID handle retrieved by OpenModel
     * @return {Vector<FlatMesh>}
     */
    LoadAllGeometry(modelID: number): Vector<FlatMesh>;
    /**
     * Load geometry for a single element
     *
     * @param modelID handle retrieved by OpenModel
     * @param expressID express ID of flat mesh
     * @return {FlatMesh}
     */
    GetFlatMesh(modelID: number, expressID: number): FlatMesh;
    /**
     * Creates a map between element ExpressIDs and GlobalIDs.
     * Each element has two entries, (ExpressID -> GlobalID) and (GlobalID -> ExpressID).
     *
     * @param modelID handle retrieved by OpenModel
     */
    CreateIfcGuidToExpressIdMapping(modelID: number): void;
    /**
     *
     * @param path new wasm path
     * @param absolute is the path absolute?
     */
    SetWasmPath(path: string, absolute?: boolean): void;
    /** The conway version string like "0.23.940-WebMT" */
    getConwayVersion(): string;
    /** @see https://bldrs-ai.github.io/conway/classes/statistics_statistics.Statistics.html */
    getStatistics(modelID: number): any;
}
//# sourceMappingURL=ifc_api.d.ts.map