import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
import { CanonicalMaterial } from "../core/canonical_material.js";
import { CanonicalMesh } from "../core/canonical_mesh.js";
import { Model } from "../core/model.js";
import { NativeTransform4x4 } from "../../dependencies/conway-geom/index.js";
import { PackedMesh } from "../core/packed_mesh.js";
import { SceneListener, SceneListenerOptions, WalkableScene } from "../core/scene.js";
import { SceneNodeModelType, SceneNodeGeometry, SceneNodeTransform } from "../core/scene_node.js";
import StepEntityBase from "../step/step_entity_base.js";
import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
import { IfcMaterialCache } from "./ifc_material_cache.js";
import IfcStepModel from "./ifc_step_model.js";
/**
 *
 */
export declare class IfcSceneTransform implements SceneNodeTransform {
    readonly model: Model;
    readonly transform: ReadonlyArray<number>;
    readonly absoluteTransform: ReadonlyArray<number>;
    readonly localID: number;
    readonly index: number;
    readonly nativeTransform: NativeTransform4x4;
    readonly absoluteNativeTransform: NativeTransform4x4;
    readonly parentIndex?: number | undefined;
    readonly type = SceneNodeModelType.TRANSFORM;
    /**
     *
     * @param model
     * @param transform
     * @param absoluteTransform
     * @param localID
     * @param index
     * @param nativeTransform
     * @param absoluteNativeTransform
     * @param parentIndex
     */
    constructor(model: Model, transform: ReadonlyArray<number>, absoluteTransform: ReadonlyArray<number>, localID: number, index: number, nativeTransform: NativeTransform4x4, absoluteNativeTransform: NativeTransform4x4, parentIndex?: number | undefined);
    children: number[];
}
/**
 *
 */
export declare class IfcSceneGeometry implements SceneNodeGeometry {
    readonly model: Model;
    readonly localID: number;
    readonly index: number;
    readonly relatedElementLocalId?: number | undefined;
    readonly parentIndex?: number | undefined;
    readonly isSpace: boolean;
    readonly materialOverideLocalID?: number | undefined;
    readonly type = SceneNodeModelType.GEOMETRY;
    /**
     * Construct a scene geometry node
     *
     * @param model
     * @param localID
     * @param index
     * @param relatedElementLocalId
     * @param parentIndex
     * @param isSpace
     * @param materialOverideLocalID
     */
    constructor(model: Model, localID: number, index: number, relatedElementLocalId?: number | undefined, parentIndex?: number | undefined, isSpace?: boolean, materialOverideLocalID?: number | undefined);
}
export type IfcSceneNode = IfcSceneTransform | IfcSceneGeometry;
/**
 *
 */
export declare class IfcSceneBuilder implements WalkableScene<StepEntityBase<EntityTypesIfc>> {
    readonly model: IfcStepModel;
    readonly conwayGeometry: ConwayGeometry;
    readonly materials: IfcMaterialCache;
    roots: number[];
    private scene_;
    private sceneLocalIdMap_;
    private geometrySet_;
    private sceneStack_;
    private currentParent_?;
    private transformListeners_?;
    private geometryListeners_?;
    /**
     * Get the current transform for this.
     *
     * @return {IfcSceneTransform|undefined}
     */
    get currentTransform(): IfcSceneTransform | undefined;
    /**
     *
     * @param model
     * @param conwayGeometry
     * @param materials
     */
    constructor(model: IfcStepModel, conwayGeometry: ConwayGeometry, materials: IfcMaterialCache);
    /**
     *
     * @param listener
     * @param options
     */
    addSceneListener(listener: SceneListener, options?: SceneListenerOptions): void;
    /**
     *
     * @param listener
     */
    removeSceneListener(listener: SceneListener): void;
    /**
     *
     * @param nodeIndex
     * @return {IfcSceneNode | undefined}
     */
    getByNodeIndex(nodeIndex: number): IfcSceneNode | undefined;
    /**
     *
     * @param localID
     * @return {IfcSceneNode | undefined}
     */
    private get;
    /**
     *
     */
    clearParentStack(): void;
    /**
     *
     * @param localID
     * @return {IfcSceneTransform | undefined}
     */
    getTransform(localID: number): IfcSceneTransform | undefined;
    /**
     *
     * @param localID
     * @return {IfcSceneGeometry | undefined}
     */
    getGeometry(localID: number): IfcSceneGeometry | undefined;
    /**
     * Build a packed/optimised mesh model with triangle element maps.
     *
     * @return {PackedMesh< IfcStepModel >} Maps materials to a geometry object
     * and triangle element map.
     */
    buildPackedMeshModel(): PackedMesh<IfcStepModel>;
    /**
     * Are all the geometry nodes in the scene spaces
     *
     * @return {boolean} Are all the geometry nodes in the scene spaces
     */
    isAllSpaces(): boolean;
    /**
     * Walk the current scene.
     *
     * @yields Raw absolute matrix transform, the native absolute transform, the canonical mesh,
     * @param includeSpaces
     * the canonical material and the associated step element as it walks the hierarchy.
     * @param walkTemporary Include temporary items.
     */
    walk(includeSpaces?: boolean): IterableIterator<[
        readonly number[] | undefined,
        NativeTransform4x4 | undefined,
        CanonicalMesh,
        CanonicalMaterial | undefined,
        StepEntityBase<EntityTypesIfc> | undefined
    ]>;
    /**
     *
     */
    popTransform(): void;
    /**
     *
     * @param transform
     */
    pushTransform(transform: IfcSceneTransform): void;
    /**
     * Does this scene have a particular piece of geometry?
     *
     * @param localID The local ID of the geometry
     * @return {boolean} True if the scene has this geometry.
     */
    hasGeometry(localID: number): boolean;
    /**
     *
     * @param localID
     * @param owningElementLocalID
     * @param isSpace
     * @param materialOverrideLocalID
     * @return {IfcSceneGeometry}
     */
    addGeometry(localID: number, owningElementLocalID?: number, isSpace?: boolean, materialOverrideLocalID?: number): IfcSceneGeometry;
    /**
     * Add a transform node and make the current transform stack parent its parent.
     *
     * Items added will be made the top of the transform stack.
     *
     * To prevent a node being used as a parent, pop it subsequently.
     *
     * @param localID
     * @param transform
     * @param nativeTransform
     * @param isMappedItem
     * @return {IfcSceneTransform}
     */
    addTransform(localID: number, transform: ReadonlyArray<number>, nativeTransform: NativeTransform4x4, isMappedItem?: boolean): IfcSceneTransform;
}
//# sourceMappingURL=ifc_scene_builder.d.ts.map