/** @internal NOTE: Internal APIs. Subject to change. Use of these APIs in production applications is not supported. */
import { BimProductMeshDescriptor, BimVertexData, MutableShallow, SimpleBoundingBox } from './bim-format-types';
import { BimProduct } from './BimProduct';
import { BimProductMesh } from './BimProductMesh';
import { BimIfcClass } from './bim-ifc-class';
import { IBimIfcLoaderElement } from './bim-ifc-loader-element';
import { BimIfcMesh } from './bim-ifc-mesh';
import { BimIfcStyle } from './bim-ifc-style';
import { Discipline } from './discipline';
import { RgbaComponent } from './rgba';
import { Writeable } from '../Types';
import { Matrix, BoundingInfo, Vector3 } from './babylonjs-import';
import { BimChangeIfc } from './bim-api-client';
import { Geometry3d } from './vertex-data-merge';
import { IfcMaterialHighlightIndex } from './CustomBabylonMaterials/IfcMaterial';
import { BimTypeObject } from './BimTypeObject';
import { type ModelProduct, type T8PropertySet, type T8QuantitySet, type T8Unit } from '@twinfinity/t8-client-model';
export interface BimIfcObjectRecursionOptions {
    stopRecursion: boolean;
    abort: boolean;
}
export interface BimIfcObjectForEachAction {
    (o: BimIfcObject, recursionOptions: BimIfcObjectRecursionOptions): void;
}
export interface BimIfcObjectForEachActionAsync {
    (o: BimIfcObject, recursionOptions: BimIfcObjectRecursionOptions): Promise<void>;
}
export interface BimIfcObjectForEachPredicate {
    (o: BimIfcObject, recursionOptions: BimIfcObjectRecursionOptions): unknown;
}
export declare function DefaultBimIfcObjectForEachPredicate(o: BimIfcObject, recursionOptions: BimIfcObjectRecursionOptions): unknown;
/**
 * This class contains the structure of an IFC Object
 */
export declare class BimIfcObject implements ModelProduct {
    readonly entityLabelInIfc: string;
    readonly ifcLoaderElement: IBimIfcLoaderElement;
    readonly parents: BimIfcObject[];
    readonly enclosingFloor?: BimIfcBuildingStorey | undefined;
    private static readonly _noChildren;
    private _children;
    readonly rawProduct: BimProduct;
    /**
     * Returns true if object is visible
     */
    readonly visible: (visible?: boolean, meshes?: BimProductMesh[]) => boolean;
    readonly propertySets: Record<string, T8PropertySet<T8Unit>>;
    readonly computedPropertySets: Record<string, T8PropertySet<T8Unit>>;
    readonly quantitySets: Record<string, T8QuantitySet<T8Unit>>;
    /**
     * Returns the class object for IFC-product
     */
    readonly class: BimIfcClass;
    readonly hasGeometry: boolean;
    protected constructor(entityLabelInIfc: string, ifcLoaderElement: IBimIfcLoaderElement, rawProduct: MutableShallow<BimProduct>, parents: BimIfcObject[], enclosingFloor?: BimIfcBuildingStorey | undefined);
    /** Creates a geometry consisting of all specified IFC objects (or specific meshes.).
     * @param items All objects that will be combined. It is possible to specify multiple {@link BimProductMesh}
     * to be used on each IFC object. If none are specified, then all meshes in the IFC objects are used.
     * When {@link BimIfcObject.isOnGpu} === `false`, the geometry will automatically be loaded and included in the final
     * {@link Geometry3d}.
     * @returns A {@link Geometry3d} instance that represents all geometry. Note that the geometry is in IFC space and not BabylonJS worldspace.
     */
    static createGeometryFromAsync(items: (BimIfcObject | {
        ifcObject: BimIfcObject;
        meshes: BimProductMesh[];
    })[]): Promise<Geometry3d>;
    /** Creates a geometry consisting of all specified IFC objects (or specific meshes.).
     * @param items All objects that will be combined. It is possible to optionally specify exactly which {@link BimProductMesh} that are
     * to be used on each IFC object. If none is specified, then all meshes in the IFC objects are used.
     * Geom. Items where {@link BimIfcObject.isOnGpu} === `false` will not be included in the final
     * {@link Geometry3d}.
     * @returns A {@link Geometry3d} instance that represents all geometry. Note that the geometry is in IFC space and not BabylonJS worldspace.
     */
    static createGeometryFrom(items: (BimIfcObject | {
        ifcObject: BimIfcObject;
        meshes: BimProductMesh[];
    })[]): Geometry3d;
    static create(ifcLoaderElement: IBimIfcLoaderElement): BimIfcObject;
    /**
     * Calculates the min and max value in the coordinate system.
     * @param min Minimum bounding vector3
     * @param max Maximum bounding vector3
     * @param predicate ?
     * @param noCache If `true`, transform caches will not be used.
     */
    aabb(min: Vector3, max: Vector3, predicate?: typeof DefaultBimIfcObjectForEachPredicate, noCache?: boolean): void;
    isOnGpu(meshes?: BimProductMesh[]): boolean;
    get ifc(): BimChangeIfc;
    get gid(): string;
    get globalId(): string;
    /**
     * @deprecated Use {@link boundingInfo} or {@link aabb}.
     */
    get bbox(): SimpleBoundingBox;
    boundingInfo(bI?: BoundingInfo, predicate?: typeof DefaultBimIfcObjectForEachPredicate, noCache?: boolean): BoundingInfo;
    get childCount(): number;
    get productMeshes(): BimProductMesh[];
    meshDescriptor(pM: BimProductMesh): BimProductMeshDescriptor;
    /**
     * Returns the discipline class for this IFC-product
     */
    get discipline(): Discipline;
    style(m: BimProductMesh): BimIfcStyle;
    vertexData(m: BimProductMesh): BimVertexData;
    transform(m: BimProductMesh, noCache?: boolean): Matrix;
    mesh(m: BimProductMesh, noCache?: boolean): BimIfcMesh;
    /**
     * Returns name of IFC-product
     */
    get name(): string;
    get description(): string;
    get type(): BimTypeObject | undefined;
    get localId(): number;
    get className(): string;
    get data(): Record<string, boolean | number | string>;
    get meshes(): readonly BimProductMesh[];
    setComputedPropertySet(name: string, set: T8PropertySet<T8Unit>): void;
    deleteComputedPropertySet(name: string): boolean;
    defaultColor(meshes?: BimProductMesh[]): boolean;
    setColors(src: Iterable<[BimProductMesh, ArrayLike<number>]>): boolean;
    setColor(color: ArrayLike<number>, meshes?: BimProductMesh[]): boolean;
    /**
     * Highlights the object
     * @param meshes The meshes to highlight
     * @param highlightIndex The highlight color index to use, setting it to zero means the mesh will not be highlighted
     * @returns a boolean indicating if the object was changed from the highlighting
     */
    highlight(highlightIndex?: IfcMaterialHighlightIndex, meshes?: BimProductMesh[]): boolean;
    /**
     * Makes the object give an ghosty outline when either SSAO or line outlines are enabled. It does this by making the object invisible
     * but also flag it to still write to the depth buffer used by the lines and SSAO
     * @param enabled If true the object will be hidden but will also be set to still write to the depth buffer
     * @param meshes The specific meshes of the object to apply this method on
     * @returns A bool indicating if any of the objects meshes was changed as a result of this method call
     */
    ghostOutline(enabled: boolean, meshes?: BimProductMesh[]): boolean;
    /**
     * Aggregates a bbox from current objects meshes.
     * This does not include related children.
     * This is alpha. Expect changes. Will probably be replaced by
     * one of the other bounding info functions.
     * @deprecated Use {@link boundingInfo} or {@link aabb}.
     * @alpha
     */
    computeObjectBboxInWorldSpace(): SimpleBoundingBox;
    private simpleBoundingIntersection;
    /**
     * Checks intersections of an object (containing object) against an array of other objects.
     * Only for internal use. Subject to change. Use of these method in production applications is not supported. If used, it is at your own risk.
     * @alpha
     * @internal
     * @hidden
     * */
    _geometricallyIntersects(objects: BimIfcObject[]): BimIfcObject[];
    /**
     * Checks intersections of an object (containing object) against an array of other objects.
     * @param objects Array of objects to test intersection against.
     * @param includeEnclosedObjects Default is true, it includes geometries completely geometrically on the inside, in the returned result.
     * @param includeIntersectingObjects Default is true, it includes geometries that intersects on border surface, in the returned result.
     * If both enclosedObjects and intersectingObjects are false, the function will make a quick rough test based on bbox and return all objects intersecting and enclosing on bounding box level.
     */
    geometricallyIntersects(objects: BimIfcObject[], includeEnclosedObjects?: boolean, includeIntersectingObjects?: boolean): BimIfcObject[];
    /**
     * @deprecated No longer does anything.
     */
    applyColor(): void;
    copyColorsTo(dst: Pick<Map<BimProductMesh, Writeable<ArrayLike<number>>>, 'get' | 'set'>): void;
    copyColorTo(m: BimProductMesh, dst: Writeable<ArrayLike<number>>, dstOffset?: number): void;
    getColorComponent(m: BimProductMesh, colorComponent: RgbaComponent): number;
    /** Get the closest parent in the IFC hiearchy. Equivalent of
     * @example
     * ```typescript
     * const parent = bimIfcObject.parents[bimIfcObjects.parents.length -1];
     * ```
     */
    get parent(): BimIfcObject | undefined;
    /** Remove the IFC object and its children from the IFC hiearchy. */
    remove(): void;
    get hasStructuredRelationships(): boolean;
    get aggregates(): readonly BimIfcObject[];
    get contains(): readonly BimIfcObject[];
    /** All children IFC objects. */
    get children(): BimIfcObject[];
    foreach(action: BimIfcObjectForEachAction): void;
    /**
     * Gets a iterator for all Ifc products currently loaded.
     */
    entries(): IterableIterator<BimIfcObject>;
    get project(): BimIfcObject;
    get site(): BimIfcObject | undefined;
    get building(): BimIfcObject | undefined;
    get facility(): BimIfcObject | undefined;
    get facilityPart(): BimIfcBuildingStorey | undefined;
    private static neverVisible;
    private static initializeCreateGeometryFrom;
    private possiblyVisible;
    private createBimIfcObject;
}
export declare class BimIfcSpace extends BimIfcObject {
    constructor(entityLabelInIfc: string, ifcLoaderElement: IBimIfcLoaderElement, rawProduct: BimProduct, parents: BimIfcObject[], enclosingFloor?: BimIfcBuildingStorey);
    get calculatedArea(): number;
    get elevationWithFlooring(): number;
    get spaceType(): string | undefined;
    get longname(): string | undefined;
}
export declare class BimIfcBuildingStorey extends BimIfcObject {
    readonly objectsWithGeometryCount: number;
    constructor(entityLabelInIfc: string, ifcLoaderElement: IBimIfcLoaderElement, rawProduct: BimProduct, parents: BimIfcObject[], enclosingFloor?: BimIfcBuildingStorey);
    get elevation(): number;
    get totalHeight(): number;
    static is(o: BimIfcObject): o is BimIfcBuildingStorey;
}
export declare class BimIfcDoor extends BimIfcObject {
    constructor(entityLabelInIfc: string, ifcLoaderElement: IBimIfcLoaderElement, rawProduct: BimProduct, parents: BimIfcObject[], enclosingFloor?: BimIfcBuildingStorey);
    get operationType(): string | undefined;
}
//# sourceMappingURL=bim-ifc-object.d.ts.map