🥮 mooncakes.io

    moonbit-ifc

    A zero-dependency IFC STEP parser and BIM extraction engine for MoonBit

    ifc
    bim
    step
    parser
    wasm
    Download zip
    Author
    Version
    0.1.3
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    40

    No dependencies

    #moonbit-ifc package notes

    The package-level API is documented in the repository README. The following snippet is intentionally mbt nocheck: it shows the public shape without making the package README depend on a particular fixture string.

    ///|
    let model = @ifc.parse(step_text)

    ///|
    let products = model.products()

    ///|
    let browser_payload = @ifc.model_to_json(model)

    See docs/architecture.md for the package boundaries and docs/scope.md for the supported IFC surface.

    EditError

    source
    pub suberror EditError {
      DuplicateEntity(id~ : Int)
      MissingEntity(id~ : Int)
      InvalidAttribute(index~ : Int)
      EmptyPatch
    } derive(Eq, 
    Debug    )

    ParseError

    source
    pub suberror ParseError {
      UnexpectedEnd(position~ : SourcePosition)
      UnexpectedCharacter(position~ : SourcePosition, character~ : Char)
      Expected(position~ : SourcePosition, token~ : String)
      InvalidNumber(position~ : SourcePosition, text~ : String)
      InvalidReference(position~ : SourcePosition, text~ : String)
      InvalidEntity(position~ : SourcePosition, text~ : String)
      InvalidHeader(position~ : SourcePosition, text~ : String)
      UnsupportedFile(text~ : String)
    } derive(
    Debug    )

    AssetKind

    source
    pub(all) enum AssetKind {
      Manifest
      Geometry
      Properties
      Spatial
      Product
    } derive(Eq, 
    Debug    )

    The kind of payload described by a WebBIM delivery manifest.

    AssetManifest

    source
    pub(all) struct AssetManifest {
      schema : String
      model_hash : Int
      entries : Array[AssetManifestEntry]
      product_count : Int
      chunk_count : Int
      point_count : Int
      triangle_count : Int
      bounds : BoundingBox
    } derive(
    Debug    )

    A complete delivery map for a parsed IFC model.

    AssetManifest::entries_of_kind

    source
    fn AssetManifest::entries_of_kind(self : AssetManifest, kind : AssetKind) -> Array[AssetManifestEntry]

    AssetManifest::entry

    source
    fn AssetManifest::entry(self : AssetManifest, path : String) -> AssetManifestEntry?

    AssetManifest::entry_count

    source
    fn AssetManifest::entry_count(self : AssetManifest) -> Int

    AssetManifest::geometry_entries

    source
    fn AssetManifest::geometry_entries(self : AssetManifest) -> Array[AssetManifestEntry]

    AssetManifest::headline

    source
    fn AssetManifest::headline(self : AssetManifest) -> String

    AssetManifest::is_cacheable

    source
    fn AssetManifest::is_cacheable(self : AssetManifest) -> Bool

    AssetManifest::paths

    source
    fn AssetManifest::paths(self : AssetManifest) -> Array[String]

    AssetManifest::product_entries

    source
    fn AssetManifest::product_entries(self : AssetManifest) -> Array[AssetManifestEntry]

    AssetManifest::spatial_entry

    source
    fn AssetManifest::spatial_entry(self : AssetManifest) -> AssetManifestEntry?

    AssetManifest::to_csv

    source
    fn AssetManifest::to_csv(self : AssetManifest) -> String

    AssetManifest::to_json

    source
    fn AssetManifest::to_json(self : AssetManifest) -> String

    AssetManifest::to_markdown

    source
    fn AssetManifest::to_markdown(self : AssetManifest) -> String

    AssetManifest::total_bytes

    source
    fn AssetManifest::total_bytes(self : AssetManifest) -> Int

    AssetManifest::total_points

    source
    fn AssetManifest::total_points(self : AssetManifest) -> Int

    AssetManifest::total_triangles

    source
    fn AssetManifest::total_triangles(self : AssetManifest) -> Int

    AssetManifestEntry

    source
    pub(all) struct AssetManifestEntry {
      path : String
      kind : AssetKind
      product_ids : Array[Int]
      byte_length : Int
      point_count : Int
      triangle_count : Int
      bounds : BoundingBox
      checksum : Int
      compressed : Bool
    } derive(
    Debug    )

    One downloadable payload and the products it covers.

    AssetManifestOptions

    source
    pub(all) struct AssetManifestOptions {
      base_uri : String
      chunk_size : Int
      include_properties : Bool
      include_spatial : Bool
      include_product_rows : Bool
      include_empty_chunks : Bool
    } derive(
    Debug    )

    Options for producing a deterministic, cache-friendly asset manifest.

    AssetManifestOptions::including_empty_chunks

    source
    fn AssetManifestOptions::including_empty_chunks(self : AssetManifestOptions, value : Bool) -> AssetManifestOptions

    AssetManifestOptions::including_product_rows

    source
    fn AssetManifestOptions::including_product_rows(self : AssetManifestOptions, value : Bool) -> AssetManifestOptions

    AssetManifestOptions::including_properties

    source
    fn AssetManifestOptions::including_properties(self : AssetManifestOptions, value : Bool) -> AssetManifestOptions

    AssetManifestOptions::including_spatial

    source
    fn AssetManifestOptions::including_spatial(self : AssetManifestOptions, value : Bool) -> AssetManifestOptions

    AssetManifestOptions::with_base_uri

    source
    fn AssetManifestOptions::with_base_uri(self : AssetManifestOptions, base_uri : String) -> AssetManifestOptions

    AssetManifestOptions::with_chunk_size

    source
    fn AssetManifestOptions::with_chunk_size(self : AssetManifestOptions, chunk_size : Int) -> AssetManifestOptions

    BenchmarkCase

    source
    pub(all) struct BenchmarkCase {
      name : String
      iterations : Int
      source_length : Int
      entity_count : Int
    } derive(
    Debug    )

    A single repeatable benchmark measurement.

    BenchmarkReport

    source
    pub(all) struct BenchmarkReport {
      toolchain : String
      cases : Array[BenchmarkResult]
      notes : Array[String]
    } derive(
    Debug    )

    BenchmarkReport::headline

    source
    fn BenchmarkReport::headline(self : BenchmarkReport) -> String

    BenchmarkReport::to_json

    source
    fn BenchmarkReport::to_json(self : BenchmarkReport) -> String

    BenchmarkReport::to_markdown

    source
    fn BenchmarkReport::to_markdown(self : BenchmarkReport) -> String

    BenchmarkResult

    source
    pub(all) struct BenchmarkResult {
      name : String
      iterations : Int
      elapsed_millis : UInt64
      operations_per_second : Double
      source_length : Int
      entity_count : Int
      allocated_entities : Int
    } derive(
    Debug    )

    BenchmarkResult::bytes_per_operation

    source
    fn BenchmarkResult::bytes_per_operation(self : BenchmarkResult) -> Double

    BenchmarkResult::is_measured

    source
    fn BenchmarkResult::is_measured(self : BenchmarkResult) -> Bool

    BimScene

    source
    pub(all) struct BimScene {
      items : Array[SceneItem]
      roots : Array[SpatialNode]
      bounds : BoundingBox
    } derive(
    Debug    )

    BimScene::find

    source
    fn BimScene::find(self : BimScene, id : Int) -> SceneItem?

    BimScene::geometry_count

    source
    fn BimScene::geometry_count(self : BimScene) -> Int

    BimScene::product_ids

    source
    fn BimScene::product_ids(self : BimScene) -> Array[Int]

    BimScene::to_json

    source
    fn BimScene::to_json(self : BimScene) -> String

    BoundingBox

    source
    pub(all) struct BoundingBox {
      min : Point3
      max : Point3
      empty : Bool
    } derive(
    Debug    )

    BoundingBox::center

    source
    fn BoundingBox::center(self : BoundingBox) -> Point3

    BoundingBox::depth

    source
    fn BoundingBox::depth(self : BoundingBox) -> Double

    BoundingBox::empty

    source
    fn BoundingBox::empty() -> BoundingBox

    BoundingBox::from_points

    source
    fn BoundingBox::from_points(points : Array[Point3]) -> BoundingBox

    BoundingBox::height

    source
    fn BoundingBox::height(self : BoundingBox) -> Double

    BoundingBox::volume

    source
    fn BoundingBox::volume(self : BoundingBox) -> Double

    BoundingBox::width

    source
    fn BoundingBox::width(self : BoundingBox) -> Double

    BoxRelation

    source
    pub(all) enum BoxRelation {
      Disjoint
      Touching
      Overlapping
      Contains
      Within
      Equal
    } derive(Eq, 
    Debug    )

    A relation between two axis-aligned boxes.

    CanonicalStepStats

    source
    pub(all) struct CanonicalStepStats {
      source_length : Int
      canonical_length : Int
      entity_count : Int
      changed : Bool
      duplicate_id_count : Int
      line_count : Int
    } derive(
    Debug    )

    Deterministic serialization metrics for a canonical STEP document.

    CanonicalStepStats::compression_ratio

    source
    fn CanonicalStepStats::compression_ratio(self : CanonicalStepStats) -> Double

    CanonicalStepStats::has_duplicates

    source
    fn CanonicalStepStats::has_duplicates(self : CanonicalStepStats) -> Bool

    CanonicalStepStats::headline

    source
    fn CanonicalStepStats::headline(self : CanonicalStepStats) -> String

    CanonicalStepStats::to_json

    source
    fn CanonicalStepStats::to_json(self : CanonicalStepStats) -> String

    CapabilityReport

    source
    pub(all) struct CapabilityReport {
      schema : SchemaVersion
      has_products : Bool
      has_spatial_structure : Bool
      has_properties : Bool
      has_geometry : Bool
      has_units : Bool
    } derive(
    Debug    )

    CatalogPage

    source
    pub(all) struct CatalogPage {
      products : Array[Product]
      total_matches : Int
      offset : Int
      limit : Int
      has_next : Bool
    } derive(
    Debug    )

    A page returned by a catalog query.

    CatalogQuery

    source
    pub(all) struct CatalogQuery {
      kind : ProductKind?
      ifc_type : String?
      name_contains : String?
      property_contains : String?
      container : Int?
      sort_key : CatalogSortKey
      direction : SortDirection
      offset : Int
      limit : Int
    } derive(
    Debug    )

    A composable query for indexed products.

    CatalogQuery::in_container

    source
    fn CatalogQuery::in_container(self : CatalogQuery, container : Int) -> CatalogQuery

    CatalogQuery::named

    source
    fn CatalogQuery::named(self : CatalogQuery, fragment : String) -> CatalogQuery

    CatalogQuery::new

    source

    CatalogQuery::of_kind

    source
    fn CatalogQuery::of_kind(self : CatalogQuery, kind : ProductKind) -> CatalogQuery

    CatalogQuery::of_type

    source
    fn CatalogQuery::of_type(self : CatalogQuery, ifc_type : String) -> CatalogQuery

    CatalogQuery::page

    source
    fn CatalogQuery::page(self : CatalogQuery, offset : Int, limit : Int) -> CatalogQuery

    CatalogQuery::sorted_by

    source
    fn CatalogQuery::sorted_by(self : CatalogQuery, sort_key : CatalogSortKey, direction : SortDirection) -> CatalogQuery

    CatalogQuery::with_property

    source
    fn CatalogQuery::with_property(self : CatalogQuery, fragment : String) -> CatalogQuery

    CatalogSortKey

    source
    pub(all) enum CatalogSortKey {
      EntityId
      EntityType
      ProductName
      ProductKind
      PropertyValue
    } derive(Eq, 
    Debug    )

    ChangeKind

    source
    pub(all) enum ChangeKind {
      Added
      Removed
      Modified
    } derive(Eq, 
    Debug    )

    ClashOptions

    source
    pub(all) struct ClashOptions {
      tolerance : Double
      minimum_overlap_volume : Double
      include_touching : Bool
      include_same_container : Bool
      ignored_types : Array[String]
      maximum_pairs : Int
    } derive(
    Debug    )

    Policy controlling which product pairs are reported as clashes.

    ClashOptions::ignoring_type

    source
    fn ClashOptions::ignoring_type(self : ClashOptions, name : String) -> ClashOptions

    ClashOptions::including_same_container

    source
    fn ClashOptions::including_same_container(self : ClashOptions, value : Bool) -> ClashOptions

    ClashOptions::including_touching

    source
    fn ClashOptions::including_touching(self : ClashOptions, value : Bool) -> ClashOptions

    ClashOptions::with_maximum_pairs

    source
    fn ClashOptions::with_maximum_pairs(self : ClashOptions, count : Int) -> ClashOptions

    ClashOptions::with_minimum_overlap

    source
    fn ClashOptions::with_minimum_overlap(self : ClashOptions, volume : Double) -> ClashOptions

    ClashOptions::with_tolerance

    source
    fn ClashOptions::with_tolerance(self : ClashOptions, tolerance : Double) -> ClashOptions

    ClashPair

    source
    pub(all) struct ClashPair {
      left : SpatialEntry
      right : SpatialEntry
      relation : BoxRelation
      overlap : BoundingBox
      overlap_volume : Double
      clearance : Double
    } derive(
    Debug    )

    A candidate pair found by broad-phase clash detection.

    ClashPair::has_volume

    source
    fn ClashPair::has_volume(self : ClashPair) -> Bool

    ClashPair::headline

    source
    fn ClashPair::headline(self : ClashPair) -> String

    ClashPair::intersection_center

    source
    fn ClashPair::intersection_center(self : ClashPair) -> Point3

    ClashPair::is_touching

    source
    fn ClashPair::is_touching(self : ClashPair) -> Bool

    ClashPair::minimum_separation

    source
    fn ClashPair::minimum_separation(self : ClashPair) -> Double

    ClashPair::type_key

    source
    fn ClashPair::type_key(self : ClashPair) -> String

    ClashReport

    source
    pub(all) struct ClashReport {
      pairs : Array[ClashPair]
      candidate_count : Int
      ignored_count : Int
      overlap_volume : Double
      by_type : Map[String, Int]
    } derive(
    Debug    )

    Aggregate result of a clash or clearance analysis.

    ClashReport::count

    source
    fn ClashReport::count(self : ClashReport) -> Int

    ClashReport::headline

    source
    fn ClashReport::headline(self : ClashReport) -> String

    ClashReport::highest_overlap

    source
    fn ClashReport::highest_overlap(self : ClashReport) -> ClashPair?

    ClashReport::is_empty

    source
    fn ClashReport::is_empty(self : ClashReport) -> Bool

    ClashReport::pairs_for_product

    source
    fn ClashReport::pairs_for_product(self : ClashReport, product_id : Int) -> Array[ClashPair]

    ClashReport::pairs_for_type

    source
    fn ClashReport::pairs_for_type(self : ClashReport, left_type : String, right_type : String) -> Array[ClashPair]

    ClashReport::product_ids

    source
    fn ClashReport::product_ids(self : ClashReport) -> Array[Int]

    ClashReport::severity

    source
    fn ClashReport::severity(self : ClashReport) -> String

    ClashReport::to_json

    source
    fn ClashReport::to_json(self : ClashReport) -> String

    ClashReport::to_markdown

    source
    fn ClashReport::to_markdown(self : ClashReport) -> String

    ClassificationReference

    source
    pub(all) struct ClassificationReference {
      entity_id : Int
      source : String?
      identification : String?
      name : String?
      referenced_entity : Int
    } derive(
    Debug    )

    A classification reference such as OmniClass, Uniclass or a local code.

    ClassificationReference::headline

    source
    fn ClassificationReference::headline(self : ClassificationReference) -> String

    CoordinateFrame

    source
    pub(all) struct CoordinateFrame {
      entity_id : Int
      name : String
      parent_id : Int?
      transform : Transform3
      depth : Int
    } derive(
    Debug    )

    A named coordinate system discovered from IFC placement entities.

    CoordinateFrame::apply

    source
    fn CoordinateFrame::apply(self : CoordinateFrame, point : Point3) -> Point3

    CoordinateFrame::headline

    source
    fn CoordinateFrame::headline(self : CoordinateFrame) -> String

    CoordinateFrame::is_root

    source
    fn CoordinateFrame::is_root(self : CoordinateFrame) -> Bool

    CoordinateFrame::origin

    source
    fn CoordinateFrame::origin(self : CoordinateFrame) -> Point3

    CoordinateReport

    source
    pub(all) struct CoordinateReport {
      frames : Array[CoordinateFrame]
      world_bounds : BoundingBox
      unit_scale : Double
      has_map_conversion : Bool
      warning_count : Int
    } derive(
    Debug    )

    A model coordinate conversion summary.

    CoordinateReport::frame

    source
    fn CoordinateReport::frame(self : CoordinateReport, id : Int) -> CoordinateFrame?

    CoordinateReport::headline

    source
    fn CoordinateReport::headline(self : CoordinateReport) -> String

    CoordinateReport::is_consistent

    source
    fn CoordinateReport::is_consistent(self : CoordinateReport) -> Bool

    CoordinateReport::max_depth

    source
    fn CoordinateReport::max_depth(self : CoordinateReport) -> Int

    CoordinateReport::roots

    source

    CoordinateReport::to_json

    source
    fn CoordinateReport::to_json(self : CoordinateReport) -> String

    CoordinateReport::to_markdown

    source
    fn CoordinateReport::to_markdown(self : CoordinateReport) -> String

    DeliveryAssetChange

    source
    pub(all) struct DeliveryAssetChange {
      path : String
      change : DeliveryChange
      before_checksum : Int?
      after_checksum : Int?
      affected_products : Array[Int]
      byte_delta : Int
    } derive(
    Debug    )

    One manifest path and the revision impact that applies to it.

    DeliveryChange

    source
    pub(all) enum DeliveryChange {
      AddedAsset
      RemovedAsset
      InvalidatedAsset
      RetainedAsset
    } derive(Eq, 
    Debug    )

    Change class for a cache-aware WebBIM delivery.

    Diagnostic

    source
    pub(all) struct Diagnostic {
      severity : DiagnosticSeverity
      code : String
      message : String
      entity_id : Int?
    } derive(
    Debug    )

    DiagnosticSeverity

    source
    pub(all) enum DiagnosticSeverity {
      Error
      Warning
      Note
    } derive(Eq, 
    Debug    )

    Entity

    source
    pub(all) struct Entity {
      id : Int
      name : String
      arguments : Array[Value]
    } derive(
    Debug    )

    A raw IFC entity. Unknown entity names and argument values are preserved.

    Entity::argument

    source
    fn Entity::argument(self : Entity, index : Int) -> Value?

    Entity::new

    source
    fn Entity::new(id~ : Int, name~ : String, arguments~ : Array[Value]) -> Entity

    EntityAttribute

    source
    pub(all) struct EntityAttribute {
      index : Int
      value : Value
    } derive(
    Debug    )

    EntityFieldChange

    source
    pub(all) struct EntityFieldChange {
      entity_id : Int
      attribute : Int
      before : Value?
      after : Value?
      kind : ChangeKind
    } derive(
    Debug    )

    A field-level change that is easier to review than a complete entity diff.

    EntityFieldChange::headline

    source
    fn EntityFieldChange::headline(self : EntityFieldChange) -> String

    EntityFilter

    source
    pub(all) enum EntityFilter {
      Name(String)
      Prefix(String)
      ProductOnly
      All
    } derive(
    Debug    )

    EntityGraph

    source
    pub(all) struct EntityGraph {
      nodes : Array[Int]
      edges : Array[GraphEdge]
      outgoing : Map[Int, Array[GraphEdge]]
      incoming : Map[Int, Array[GraphEdge]]
    } derive(
    Debug    )

    Indexed directed graph over raw IFC entity references.

    EntityGraph::components

    source
    fn EntityGraph::components(self : EntityGraph) -> Array[GraphComponent]

    EntityGraph::cycles

    source
    fn EntityGraph::cycles(self : EntityGraph) -> Array[Array[Int]]

    EntityGraph::degree

    source
    fn EntityGraph::degree(self : EntityGraph, id : Int) -> GraphDegree

    EntityGraph::degrees

    source
    fn EntityGraph::degrees(self : EntityGraph) -> Array[GraphDegree]

    EntityGraph::dependents

    source
    fn EntityGraph::dependents(self : EntityGraph, roots : Array[Int]) -> Array[Int]

    EntityGraph::direct_dependencies

    source
    fn EntityGraph::direct_dependencies(self : EntityGraph, id : Int) -> Array[Int]

    EntityGraph::direct_dependents

    source
    fn EntityGraph::direct_dependents(self : EntityGraph, id : Int) -> Array[Int]

    EntityGraph::edge_count

    source
    fn EntityGraph::edge_count(self : EntityGraph) -> Int

    EntityGraph::edges

    source
    fn EntityGraph::edges(self : EntityGraph) -> Array[GraphEdge]

    EntityGraph::edges_from

    source
    fn EntityGraph::edges_from(self : EntityGraph, id : Int) -> Array[GraphEdge]

    EntityGraph::edges_to

    source
    fn EntityGraph::edges_to(self : EntityGraph, id : Int) -> Array[GraphEdge]

    EntityGraph::has_node

    source
    fn EntityGraph::has_node(self : EntityGraph, id : Int) -> Bool

    EntityGraph::incoming_ids

    source
    fn EntityGraph::incoming_ids(self : EntityGraph, id : Int) -> Array[Int]

    EntityGraph::leaves

    source
    fn EntityGraph::leaves(self : EntityGraph) -> Array[Int]

    EntityGraph::new

    source
    fn EntityGraph::new(index : ModelIndex) -> EntityGraph

    EntityGraph::node_count

    source
    fn EntityGraph::node_count(self : EntityGraph) -> Int

    EntityGraph::nodes

    source
    fn EntityGraph::nodes(self : EntityGraph) -> Array[Int]

    EntityGraph::orphans

    source
    fn EntityGraph::orphans(self : EntityGraph) -> Array[Int]

    EntityGraph::outgoing_ids

    source
    fn EntityGraph::outgoing_ids(self : EntityGraph, id : Int) -> Array[Int]

    EntityGraph::reachable

    source
    fn EntityGraph::reachable(self : EntityGraph, roots : Array[Int]) -> Array[Int]

    EntityGraph::roots

    source
    fn EntityGraph::roots(self : EntityGraph) -> Array[Int]

    EntityGraph::shortest_path

    source
    fn EntityGraph::shortest_path(self : EntityGraph, start : Int, goal : Int) -> GraphPath?

    Find a shortest reference path, useful for explaining why two IFC records are connected.

    EntityGraph::topological_order

    source
    fn EntityGraph::topological_order(self : EntityGraph) -> Array[Int]

    Return a stable topological order; cyclic nodes are appended in source order.

    EntityPatch

    source
    pub(all) enum EntityPatch {
      Add(Entity)
      Remove(Int)
      Replace(Entity)
      SetAttribute(id~ : Int, index~ : Int, value~ : Value)
    } derive(
    Debug    )

    EntityPatch::description

    source
    fn EntityPatch::description(self : EntityPatch) -> String

    EntityPatch::id

    source
    fn EntityPatch::id(self : EntityPatch) -> Int

    EntityRange

    source
    pub(all) struct EntityRange {
      first_id : Int
      last_id : Int
      entity_count : Int
      contiguous : Bool
    } derive(
    Debug    )

    EntityRange::summary

    source
    fn EntityRange::summary(self : EntityRange) -> String

    ExportBundle

    source
    pub(all) struct ExportBundle {
      headline : String
      json : String
      products_csv : String
      properties_csv : String
      scene_json : String
    } derive(
    Debug    )

    ExportBundle::file_names

    source
    fn ExportBundle::file_names(self : ExportBundle) -> Array[String]

    ExportBundle::has_content

    source
    fn ExportBundle::has_content(self : ExportBundle) -> Bool

    ExportBundle::payload

    source
    fn ExportBundle::payload(self : ExportBundle) -> String

    ExportBundle::report

    source
    fn ExportBundle::report(self : ExportBundle) -> String

    ExportFormat

    source
    pub(all) enum ExportFormat {
      Obj
      Ply
      JsonLines
      WebBim
    } derive(Eq, 
    Debug    )

    ExportOptions

    source
    pub(all) struct ExportOptions {
      format : ExportFormat
      include_empty_products : Bool
      include_normals : Bool
      include_properties : Bool
      precision : Int
    } derive(
    Debug    )

    ExportOptions::including_empty

    source
    fn ExportOptions::including_empty(self : ExportOptions, enabled : Bool) -> ExportOptions

    ExportOptions::including_normals

    source
    fn ExportOptions::including_normals(self : ExportOptions, enabled : Bool) -> ExportOptions

    ExportOptions::including_properties

    source
    fn ExportOptions::including_properties(self : ExportOptions, enabled : Bool) -> ExportOptions

    ExportOptions::with_format

    source
    fn ExportOptions::with_format(self : ExportOptions, format : ExportFormat) -> ExportOptions

    ExportOptions::with_precision

    source
    fn ExportOptions::with_precision(self : ExportOptions, precision : Int) -> ExportOptions

    ExportedAsset

    source
    pub(all) struct ExportedAsset {
      format : ExportFormat
      file_name : String
      content : String
      product_count : Int
      point_count : Int
      triangle_count : Int
    } derive(
    Debug    )

    ExportedAsset::headline

    source
    fn ExportedAsset::headline(self : ExportedAsset) -> String

    ExportedAsset::is_non_empty

    source
    fn ExportedAsset::is_non_empty(self : ExportedAsset) -> Bool

    ExportedAsset::line_count

    source
    fn ExportedAsset::line_count(self : ExportedAsset) -> Int

    FormulaTakeoff

    source
    pub(all) struct FormulaTakeoff {
      rows : Array[ProductTakeoff]
      notes : Array[QuantityNote]
      formulas : Array[QuantityFormula]
      product_count : Int
      missing_formula_count : Int
    } derive(
    Debug    )

    A takeoff report produced from configurable property formulas.

    FormulaTakeoff::find

    source
    fn FormulaTakeoff::find(self : FormulaTakeoff, product_id : Int) -> ProductTakeoff?

    FormulaTakeoff::formula_names

    source
    fn FormulaTakeoff::formula_names(self : FormulaTakeoff) -> Array[String]

    FormulaTakeoff::headline

    source
    fn FormulaTakeoff::headline(self : FormulaTakeoff) -> String

    FormulaTakeoff::note_count

    source
    fn FormulaTakeoff::note_count(self : FormulaTakeoff) -> Int

    FormulaTakeoff::quantity

    source
    fn FormulaTakeoff::quantity(self : FormulaTakeoff, product_id : Int, kind : QuantityKind) -> QuantityValue?

    FormulaTakeoff::row_count

    source
    fn FormulaTakeoff::row_count(self : FormulaTakeoff) -> Int

    FormulaTakeoff::to_csv

    source
    fn FormulaTakeoff::to_csv(self : FormulaTakeoff) -> String

    FormulaTakeoff::to_json

    source
    fn FormulaTakeoff::to_json(self : FormulaTakeoff) -> String

    FormulaTakeoff::to_markdown

    source
    fn FormulaTakeoff::to_markdown(self : FormulaTakeoff) -> String

    FormulaTakeoff::total

    source
    fn FormulaTakeoff::total(self : FormulaTakeoff, kind : QuantityKind) -> Double

    FormulaTakeoff::warnings

    source

    Geometry

    source
    pub(all) struct Geometry {
      source_id : Int
      kind : GeometryKind
      points : Array[Point3]
      references : Array[Int]
      depth : Double?
      profile_width : Double?
      profile_height : Double?
      profile_radius : Double?
      face_count : Int
      triangle_count : Int
    } derive(
    Debug    )

    GeometryInventory

    source
    pub(all) struct GeometryInventory {
      products : Array[ProductGeometryReport]
      represented_product_count : Int
      empty_representation_count : Int
      invalid_mesh_count : Int
      total_surface_area : Double
      total_volume : Double
    } derive(
    Debug    )

    Aggregate geometry coverage and quality metrics.

    GeometryInventory::by_product

    source
    fn GeometryInventory::by_product(self : GeometryInventory, id : Int) -> ProductGeometryReport?

    GeometryInventory::headline

    source
    fn GeometryInventory::headline(self : GeometryInventory) -> String

    GeometryInventory::largest_by_area

    source

    GeometryInventory::largest_by_volume

    source

    GeometryInventory::product_count

    source
    fn GeometryInventory::product_count(self : GeometryInventory) -> Int

    GeometryInventory::represented_ratio

    source
    fn GeometryInventory::represented_ratio(self : GeometryInventory) -> Double

    GeometryInventory::to_csv

    source
    fn GeometryInventory::to_csv(self : GeometryInventory) -> String

    GeometryInventory::to_json

    source
    fn GeometryInventory::to_json(self : GeometryInventory) -> String

    GeometryInventory::valid_ratio

    source
    fn GeometryInventory::valid_ratio(self : GeometryInventory) -> Double

    GeometryKind

    source
    pub(all) enum GeometryKind {
      Extrusion
      FacetedBrep
      TriangulatedMesh
      CsgSolid
      Profile
      Polyline
      PointCloud
      Unknown
    } derive(Eq, Hash, 
    Debug    )

    GraphAnalysis

    source
    pub(all) struct GraphAnalysis {
      nodes : Int
      edges : Int
      roots : Array[Int]
      leaves : Array[Int]
      components : Array[GraphComponent]
      cycles : Array[Array[Int]]
      max_depth : Int
      orphan_ids : Array[Int]
    } derive(
    Debug    )

    Rich graph metrics for impact analysis and model diagnostics.

    GraphAnalysis::component_count

    source
    fn GraphAnalysis::component_count(self : GraphAnalysis) -> Int

    GraphAnalysis::cycle_count

    source
    fn GraphAnalysis::cycle_count(self : GraphAnalysis) -> Int

    GraphAnalysis::headline

    source
    fn GraphAnalysis::headline(self : GraphAnalysis) -> String

    GraphAnalysis::is_acyclic

    source
    fn GraphAnalysis::is_acyclic(self : GraphAnalysis) -> Bool

    GraphAnalysis::largest_component

    source
    fn GraphAnalysis::largest_component(self : GraphAnalysis) -> GraphComponent?

    GraphAnalysis::orphan_count

    source
    fn GraphAnalysis::orphan_count(self : GraphAnalysis) -> Int

    GraphAnalysis::to_json

    source
    fn GraphAnalysis::to_json(self : GraphAnalysis) -> String

    GraphAnalysis::to_markdown

    source
    fn GraphAnalysis::to_markdown(self : GraphAnalysis) -> String

    GraphComponent

    source
    pub(all) struct GraphComponent {
      root : Int
      entity_ids : Array[Int]
      edge_count : Int
      cyclic : Bool
    } derive(
    Debug    )

    A connected component of the undirected entity graph.

    GraphComponent::headline

    source
    fn GraphComponent::headline(self : GraphComponent) -> String

    GraphDegree

    source
    pub(all) struct GraphDegree {
      id : Int
      incoming : Int
      outgoing : Int
      total : Int
      orphan : Bool
    } derive(
    Debug    )

    Degree information for one graph node.

    GraphDegree::headline

    source
    fn GraphDegree::headline(self : GraphDegree) -> String

    GraphEdge

    source
    pub(all) struct GraphEdge {
      from : Int
      to : Int
      relation : String
      argument : Int
    } derive(Eq, 
    Debug    )

    One directed relationship in the entity dependency graph.

    GraphEdge::headline

    source
    fn GraphEdge::headline(self : GraphEdge) -> String

    GraphPath

    source
    pub(all) struct GraphPath {
      ids : Array[Int]
      edges : Array[GraphEdge]
      total_cost : Int
    } derive(
    Debug    )

    A path through the entity dependency graph.

    GraphPath::headline

    source
    fn GraphPath::headline(self : GraphPath) -> String

    GraphStats

    source
    pub(all) struct GraphStats {
      entity_count : Int
      reference_count : Int
      distinct_targets : Int
      max_out_degree : Int
      orphan_reference_count : Int
    } derive(
    Debug    )

    GuidReport

    source
    pub(all) struct GuidReport {
      value : String
      valid : Bool
      decoded_bytes : Int
      normalized : String
      message : String
    } derive(
    Debug    )

    IFC compressed GUID validation result.

    GuidReport::headline

    source
    fn GuidReport::headline(self : GuidReport) -> String

    GuidReport::is_canonical

    source
    fn GuidReport::is_canonical(self : GuidReport) -> Bool

    GuidReport::to_json

    source
    fn GuidReport::to_json(self : GuidReport) -> String

    pub(all) struct Header {
      description : Array[String]
      file_name : String?
      time_stamp : String?
      authors : Array[String]
      organizations : Array[String]
      preprocessor_version : String?
      originating_system : String?
      authorization : String?
      schema_identifiers : Array[String]
    } derive(
    Debug    )

    Inspection

    source
    pub(all) struct Inspection {
      model : Model
      summary : ModelSummary
      metrics : ModelMetrics
      validation : ValidationReport
      capabilities : CapabilityReport
    } derive(
    Debug    )

    Inspection::headline

    source
    fn Inspection::headline(self : Inspection) -> String

    Inspection::is_valid

    source
    fn Inspection::is_valid(self : Inspection) -> Bool

    Inspection::scene

    source
    fn Inspection::scene(self : Inspection) -> BimScene

    Inspection::to_json

    source
    fn Inspection::to_json(self : Inspection) -> String

    ManifestNode

    source
    pub(all) struct ManifestNode {
      product_id : Int
      ifc_type : String
      name : String?
      kind : ProductKind
      property_names : Array[String]
      geometry_count : Int
      bounds : BoundingBox
    } derive(
    Debug    )

    MaterialAssignment

    source
    pub(all) struct MaterialAssignment {
      product_id : Int
      association_id : Int
      material_id : Int?
      material_name : String?
      layers : Array[MaterialLayer]
      constituents : Array[String]
    } derive(
    Debug    )

    Material assignments attached to one product.

    MaterialAssignment::headline

    source
    fn MaterialAssignment::headline(self : MaterialAssignment) -> String

    MaterialAssignment::material_names

    source
    fn MaterialAssignment::material_names(self : MaterialAssignment) -> Array[String]

    MaterialInventory

    source
    pub(all) struct MaterialInventory {
      assignments : Array[MaterialAssignment]
      distinct_materials : Array[String]
      layered_product_count : Int
      unassigned_product_count : Int
    } derive(
    Debug    )

    Model-wide material inventory and coverage metrics.

    MaterialInventory::assignment_count

    source
    fn MaterialInventory::assignment_count(self : MaterialInventory) -> Int

    MaterialInventory::headline

    source
    fn MaterialInventory::headline(self : MaterialInventory) -> String

    MaterialInventory::material_count

    source
    fn MaterialInventory::material_count(self : MaterialInventory) -> Int

    MaterialInventory::products_with_material

    source
    fn MaterialInventory::products_with_material(self : MaterialInventory, name : String) -> Array[Int]

    MaterialInventory::thickness_for_product

    source
    fn MaterialInventory::thickness_for_product(self : MaterialInventory, product_id : Int) -> Double

    MaterialInventory::to_csv

    source
    fn MaterialInventory::to_csv(self : MaterialInventory) -> String

    MaterialInventory::to_json

    source
    fn MaterialInventory::to_json(self : MaterialInventory) -> String

    MaterialLayer

    source
    pub(all) struct MaterialLayer {
      entity_id : Int
      material_id : Int?
      material_name : String?
      thickness : Double?
      priority : Int?
      is_unbounded : Bool
    } derive(
    Debug    )

    A material layer decoded from an IFC material profile.

    MaterialLayer::headline

    source
    fn MaterialLayer::headline(self : MaterialLayer) -> String

    Mesh

    source
    pub(all) struct Mesh {
      points : Array[Point3]
      triangles : Array[(Int, Int, Int)]
    } derive(
    Debug    )

    MeshAnalysis

    source
    pub(all) struct MeshAnalysis {
      mesh : Mesh
      stats : MeshStats
      bounds : BoundingBox
      normals : Array[Vector3]
    } derive(
    Debug    )

    A mesh together with reusable diagnostics for downstream renderers.

    MeshAnalysis::from_mesh

    source
    fn MeshAnalysis::from_mesh(mesh : Mesh) -> MeshAnalysis

    MeshAnalysis::is_valid

    source
    fn MeshAnalysis::is_valid(self : MeshAnalysis) -> Bool

    MeshIssue

    source
    pub(all) struct MeshIssue {
      code : String
      message : String
      point_index : Int?
      triangle_index : Int?
    } derive(
    Debug    )

    One structural problem found by mesh validation.

    MeshIssue::headline

    source
    fn MeshIssue::headline(self : MeshIssue) -> String

    MeshPipelineOptions

    source
    pub(all) struct MeshPipelineOptions {
      weld_tolerance : Double
      degenerate_tolerance : Double
      maximum_triangles : Int
      recenter : Bool
      scale : Double
      flip_winding : Bool
      generate_normals : Bool
      compact_vertices : Bool
    } derive(
    Debug    )

    Options controlling mesh cleanup and level-of-detail generation.

    MeshPipelineOptions::compacting

    source
    fn MeshPipelineOptions::compacting(self : MeshPipelineOptions, value : Bool) -> MeshPipelineOptions

    MeshPipelineOptions::flipped

    source
    fn MeshPipelineOptions::flipped(self : MeshPipelineOptions, value : Bool) -> MeshPipelineOptions

    MeshPipelineOptions::recentered

    source
    fn MeshPipelineOptions::recentered(self : MeshPipelineOptions, value : Bool) -> MeshPipelineOptions

    MeshPipelineOptions::scaled

    source
    fn MeshPipelineOptions::scaled(self : MeshPipelineOptions, value : Double) -> MeshPipelineOptions

    MeshPipelineOptions::with_degenerate_tolerance

    source
    fn MeshPipelineOptions::with_degenerate_tolerance(self : MeshPipelineOptions, value : Double) -> MeshPipelineOptions

    MeshPipelineOptions::with_maximum_triangles

    source
    fn MeshPipelineOptions::with_maximum_triangles(self : MeshPipelineOptions, value : Int) -> MeshPipelineOptions

    MeshPipelineOptions::with_normals

    source
    fn MeshPipelineOptions::with_normals(self : MeshPipelineOptions, value : Bool) -> MeshPipelineOptions

    MeshPipelineOptions::with_weld_tolerance

    source
    fn MeshPipelineOptions::with_weld_tolerance(self : MeshPipelineOptions, value : Double) -> MeshPipelineOptions

    MeshPipelineResult

    source
    pub(all) struct MeshPipelineResult {
      mesh : Mesh
      normals : Array[Vector3]
      stats : MeshPipelineStats
    } derive(
    Debug    )

    Processed mesh and optional normals for a renderer or exporter.

    MeshPipelineResult::bounds

    source

    MeshPipelineResult::headline

    source
    fn MeshPipelineResult::headline(self : MeshPipelineResult) -> String

    MeshPipelineResult::is_valid

    source
    fn MeshPipelineResult::is_valid(self : MeshPipelineResult) -> Bool

    MeshPipelineResult::point_count

    source
    fn MeshPipelineResult::point_count(self : MeshPipelineResult) -> Int

    MeshPipelineResult::to_json

    source
    fn MeshPipelineResult::to_json(self : MeshPipelineResult) -> String

    MeshPipelineResult::to_obj

    source
    fn MeshPipelineResult::to_obj(self : MeshPipelineResult) -> String

    MeshPipelineResult::triangle_count

    source
    fn MeshPipelineResult::triangle_count(self : MeshPipelineResult) -> Int

    MeshPipelineStats

    source
    pub(all) struct MeshPipelineStats {
      input_points : Int
      input_triangles : Int
      output_points : Int
      output_triangles : Int
      removed_points : Int
      removed_triangles : Int
      surface_area : Double
      volume : Double
      bounds : BoundingBox
      valid : Bool
    } derive(
    Debug    )

    Quality counters emitted by a mesh processing pipeline.

    MeshPipelineStats::headline

    source
    fn MeshPipelineStats::headline(self : MeshPipelineStats) -> String

    MeshStats

    source
    pub(all) struct MeshStats {
      point_count : Int
      triangle_count : Int
      boundary_edge_count : Int
      non_manifold_edge_count : Int
      degenerate_triangle_count : Int
      connected_component_count : Int
      surface_area : Double
      signed_volume : Double
    } derive(
    Debug    )

    Counts and quality signals calculated from a triangle mesh.

    MeshStats::headline

    source
    fn MeshStats::headline(self : MeshStats) -> String

    MeshStats::is_closed

    source
    fn MeshStats::is_closed(self : MeshStats) -> Bool

    MeshStats::is_manifold

    source
    fn MeshStats::is_manifold(self : MeshStats) -> Bool

    MeshStats::volume

    source
    fn MeshStats::volume(self : MeshStats) -> Double

    MeshValidation

    source
    pub(all) struct MeshValidation {
      valid : Bool
      issues : Array[MeshIssue]
      referenced_point_count : Int
      unreferenced_point_count : Int
      degenerate_triangle_count : Int
    } derive(
    Debug    )

    Validation summary for a mesh before it reaches a renderer.

    MeshValidation::headline

    source
    fn MeshValidation::headline(self : MeshValidation) -> String

    Model

    source
    pub(all) struct Model {
      header : Header
      entities : Array[Entity]
    } derive(
    Debug    )

    Model::apply_patch

    source
    fn Model::apply_patch(self : Model, patch : ModelPatch) -> Model raise EditError

    Model::entity_count

    source
    fn Model::entity_count(self : Model) -> Int

    Model::entity_names

    source
    fn Model::entity_names(self : Model) -> Array[String]

    Model::filter_entities

    source
    fn Model::filter_entities(self : Model, filter : EntityFilter) -> Array[Entity]

    Model::index

    source
    fn Model::index(self : Model) -> ModelIndex

    Model::new

    source
    fn Model::new(header~ : Header, entities~ : Array[Entity]) -> Model

    Model::products

    source
    fn Model::products(self : Model) -> Array[Product]

    Model::property_sets

    source
    fn Model::property_sets(self : Model) -> Array[PropertySet] raise ParseError

    Model::schema

    source
    fn Model::schema(self : Model) -> String

    Model::summary

    source
    fn Model::summary(self : Model) -> ModelSummary

    Model::to_step

    source
    fn Model::to_step(self : Model) -> String

    Serialize the generic model back to a valid ISO 10303-21 document.

    Model::validate

    source
    fn Model::validate(self : Model) -> ValidationReport

    ModelCatalog

    source
    pub(all) struct ModelCatalog {
      model : Model
      index : ModelIndex
      products : Array[Product]
      property_sets : Array[PropertySet]
      roots : Array[SpatialNode]
      metrics : ModelMetrics
      type_counts : Map[String, Int]
    } derive(
    Debug    )

    A precomputed model view for applications that issue many queries.

    ModelCatalog::entity

    source
    fn ModelCatalog::entity(self : ModelCatalog, id : Int) -> Entity?

    ModelCatalog::has_entity

    source
    fn ModelCatalog::has_entity(self : ModelCatalog, id : Int) -> Bool

    ModelCatalog::new

    source
    fn ModelCatalog::new(model : Model) -> ModelCatalog raise ParseError

    Build the indexes that are normally needed by an application session.

    The catalog deliberately keeps the original Model alongside its indexes. This makes it possible to move from an optimized query back to a lossless entity without reparsing the source text.

    ModelCatalog::products_named

    source
    fn ModelCatalog::products_named(self : ModelCatalog, fragment : String) -> Array[Product]

    ModelCatalog::products_of_kind

    source
    fn ModelCatalog::products_of_kind(self : ModelCatalog, kind : ProductKind) -> Array[Product]

    ModelCatalog::property

    source
    fn ModelCatalog::property(self : ModelCatalog, product : Product, name : String) -> Property? raise ParseError

    ModelCatalog::property_sets_for

    source
    fn ModelCatalog::property_sets_for(self : ModelCatalog, product : Product) -> Array[PropertySet] raise ParseError

    ModelCatalog::query

    source
    fn ModelCatalog::query(self : ModelCatalog, query : CatalogQuery) -> CatalogPage raise ParseError

    Execute a filtered, stable, paginated query over the catalog.

    ModelCatalog::query_all

    source
    fn ModelCatalog::query_all(self : ModelCatalog, query : CatalogQuery) -> Array[Product] raise ParseError

    ModelCatalog::schema

    source
    fn ModelCatalog::schema(self : ModelCatalog) -> String

    ModelCatalog::spatial_root

    source
    fn ModelCatalog::spatial_root(self : ModelCatalog) -> SpatialNode?

    ModelCatalog::summary

    source
    fn ModelCatalog::summary(self : ModelCatalog) -> ModelSummary

    ModelCatalog::type_count

    source
    fn ModelCatalog::type_count(self : ModelCatalog, name : String) -> Int

    ModelCatalog::type_histogram

    source
    fn ModelCatalog::type_histogram(self : ModelCatalog) -> Map[String, Int]

    ModelChange

    source
    pub(all) struct ModelChange {
      kind : ChangeKind
      entity_id : Int
      before : Entity?
      after : Entity?
    } derive(
    Debug    )

    ModelDeliveryReport

    source
    pub(all) struct ModelDeliveryReport {
      source_length : Int
      profile : ModelProfile
      quality : ModelQualityReport
      manifest : AssetManifest
      canonical : CanonicalStepStats
    } derive(
    Debug    )

    One local report used to gate a model before it reaches a viewer or exporter.

    ModelDeliveryReport::asset_bytes

    source
    fn ModelDeliveryReport::asset_bytes(self : ModelDeliveryReport, kind : AssetKind) -> Int

    ModelDeliveryReport::canonical_passed

    source
    fn ModelDeliveryReport::canonical_passed(self : ModelDeliveryReport) -> Bool

    ModelDeliveryReport::gate_results

    source
    fn ModelDeliveryReport::gate_results(self : ModelDeliveryReport) -> Map[String, Bool]

    ModelDeliveryReport::has_geometry

    source
    fn ModelDeliveryReport::has_geometry(self : ModelDeliveryReport) -> Bool

    ModelDeliveryReport::headline

    source
    fn ModelDeliveryReport::headline(self : ModelDeliveryReport) -> String

    ModelDeliveryReport::is_ready

    source
    fn ModelDeliveryReport::is_ready(self : ModelDeliveryReport) -> Bool

    ModelDeliveryReport::quality_passed

    source
    fn ModelDeliveryReport::quality_passed(self : ModelDeliveryReport) -> Bool

    ModelDeliveryReport::score

    source
    fn ModelDeliveryReport::score(self : ModelDeliveryReport) -> Int

    ModelDeliveryReport::to_json

    source
    fn ModelDeliveryReport::to_json(self : ModelDeliveryReport) -> String

    ModelDeliveryReport::to_markdown

    source
    fn ModelDeliveryReport::to_markdown(self : ModelDeliveryReport) -> String

    ModelDiff

    source
    pub(all) struct ModelDiff {
      changes : Array[ModelChange]
      added : Int
      removed : Int
      modified : Int
    } derive(
    Debug    )

    ModelDiff::changed_ids

    source
    fn ModelDiff::changed_ids(self : ModelDiff) -> Array[Int]

    ModelDiff::is_empty

    source
    fn ModelDiff::is_empty(self : ModelDiff) -> Bool

    ModelDiff::summary

    source
    fn ModelDiff::summary(self : ModelDiff) -> String

    ModelIndex

    source
    pub(all) struct ModelIndex {
      entities : Array[Entity]
      by_id : Map[Int, Entity]
      by_name : Map[String, Array[Int]]
    } derive(
    Debug    )

    ModelIndex::all

    source
    fn ModelIndex::all(self : ModelIndex) -> Array[Entity]

    ModelIndex::entities_named

    source
    fn ModelIndex::entities_named(self : ModelIndex, name : String) -> Array[Entity]

    ModelIndex::entity

    source
    fn ModelIndex::entity(self : ModelIndex, id : Int) -> Entity?

    ModelIndex::has

    source
    fn ModelIndex::has(self : ModelIndex, id : Int) -> Bool

    ModelIndex::ids_named

    source
    fn ModelIndex::ids_named(self : ModelIndex, name : String) -> Array[Int]

    ModelIndex::require

    source
    fn ModelIndex::require(self : ModelIndex, id : Int) -> Entity raise ParseError

    ModelMetrics

    source
    pub(all) struct ModelMetrics {
      source_length : Int
      entity_count : Int
      product_count : Int
      relationship_count : Int
      geometry_count : Int
      property_count : Int
      spatial_depth : Int
      reference_count : Int
    } derive(
    Debug    )

    ModelMetrics::headline

    source
    fn ModelMetrics::headline(self : ModelMetrics) -> String

    ModelPatch

    source
    pub(all) struct ModelPatch {
      operations : Array[EntityPatch]
      added : Int
      removed : Int
      replaced : Int
      changed_attributes : Int
    } derive(
    Debug    )

    ModelPatch::add

    source
    fn ModelPatch::add(self : ModelPatch, entity : Entity) -> Unit

    ModelPatch::is_empty

    source
    fn ModelPatch::is_empty(self : ModelPatch) -> Bool

    ModelPatch::new

    source
    fn ModelPatch::new() -> ModelPatch

    ModelPatch::operation_count

    source
    fn ModelPatch::operation_count(self : ModelPatch) -> Int

    ModelPatch::push

    source
    fn ModelPatch::push(self : ModelPatch, operation : EntityPatch) -> Unit

    ModelPatch::remove

    source
    fn ModelPatch::remove(self : ModelPatch, id : Int) -> Unit

    ModelPatch::replace

    source
    fn ModelPatch::replace(self : ModelPatch, entity : Entity) -> Unit

    ModelPatch::set_attribute

    source
    fn ModelPatch::set_attribute(self : ModelPatch, id : Int, index : Int, value : Value) -> Unit

    ModelProfile

    source
    pub(all) struct ModelProfile {
      schema : SchemaVersion
      entity_count : Int
      product_count : Int
      family_counts : Map[String, Int]
      type_counts : Map[String, Int]
      known_entity_count : Int
      unknown_entity_count : Int
      relationship_count : Int
      geometry_count : Int
      property_set_count : Int
    } derive(
    Debug    )

    A model-level semantic profile used by import dashboards.

    ModelProfile::family_count

    source
    fn ModelProfile::family_count(self : ModelProfile, family : String) -> Int

    ModelProfile::family_names

    source
    fn ModelProfile::family_names(self : ModelProfile) -> Array[String]

    ModelProfile::headline

    source
    fn ModelProfile::headline(self : ModelProfile) -> String

    ModelProfile::is_extension_heavy

    source
    fn ModelProfile::is_extension_heavy(self : ModelProfile) -> Bool

    ModelProfile::known_ratio

    source
    fn ModelProfile::known_ratio(self : ModelProfile) -> Double

    ModelProfile::to_json

    source
    fn ModelProfile::to_json(self : ModelProfile) -> String

    ModelProfile::to_markdown

    source
    fn ModelProfile::to_markdown(self : ModelProfile) -> String

    ModelProfile::top_types

    source
    fn ModelProfile::top_types(self : ModelProfile, limit : Int) -> Array[(String, Int)]

    ModelProfile::type_count

    source
    fn ModelProfile::type_count(self : ModelProfile, name : String) -> Int

    ModelQualityReport

    source
    pub(all) struct ModelQualityReport {
      findings : Array[QualityFinding]
      score : Int
      entity_count : Int
      product_count : Int
      orphan_count : Int
      duplicate_id_count : Int
      named_product_ratio : Double
      guid_ratio : Double
      unknown_entity_ratio : Double
    } derive(
    Debug    )

    A scorecard combining structural, semantic, unit and geometry signals.

    ModelQualityReport::count_level

    source
    fn ModelQualityReport::count_level(self : ModelQualityReport, level : QualityLevel) -> Int

    ModelQualityReport::finding_code

    source
    fn ModelQualityReport::finding_code(self : ModelQualityReport, code : String) -> QualityFinding?

    ModelQualityReport::finding_count

    source
    fn ModelQualityReport::finding_count(self : ModelQualityReport) -> Int

    ModelQualityReport::findings_at

    source

    ModelQualityReport::has_errors

    source
    fn ModelQualityReport::has_errors(self : ModelQualityReport) -> Bool

    ModelQualityReport::headline

    source
    fn ModelQualityReport::headline(self : ModelQualityReport) -> String

    ModelQualityReport::is_healthy

    source
    fn ModelQualityReport::is_healthy(self : ModelQualityReport) -> Bool

    ModelQualityReport::to_json

    source
    fn ModelQualityReport::to_json(self : ModelQualityReport) -> String

    ModelQualityReport::to_markdown

    source
    fn ModelQualityReport::to_markdown(self : ModelQualityReport) -> String

    ModelRule

    source
    pub(all) struct ModelRule {
      code : String
      description : String
      severity : DiagnosticSeverity
      entity_type : String?
      minimum_arguments : Int?
      required_attributes : Array[Int]
      required_properties : Array[String]
      minimum_value : Double?
      maximum_value : Double?
    } derive(
    Debug    )

    A rule for validating a model against project delivery requirements.

    ModelRule::for_entity

    source
    fn ModelRule::for_entity(self : ModelRule, entity_type : String) -> ModelRule

    ModelRule::headline

    source
    fn ModelRule::headline(self : ModelRule) -> String

    ModelRule::is_error

    source
    fn ModelRule::is_error(self : ModelRule) -> Bool

    ModelRule::new

    source
    fn ModelRule::new(code~ : String, description~ : String, severity? : DiagnosticSeverity) -> ModelRule

    ModelRule::requiring_attribute

    source
    fn ModelRule::requiring_attribute(self : ModelRule, index : Int) -> ModelRule

    ModelRule::requiring_property

    source
    fn ModelRule::requiring_property(self : ModelRule, name : String) -> ModelRule

    ModelRule::with_minimum_arguments

    source
    fn ModelRule::with_minimum_arguments(self : ModelRule, count : Int) -> ModelRule

    ModelRule::with_value_range

    source
    fn ModelRule::with_value_range(self : ModelRule, minimum : Double?, maximum : Double?) -> ModelRule

    ModelSlice

    source
    pub(all) struct ModelSlice {
      model : Model
      selected_ids : Array[Int]
      dependency_ids : Array[Int]
      omitted_ids : Array[Int]
      root_ids : Array[Int]
    } derive(
    Debug    )

    A dependency-closed model slice for partial loading.

    ModelSlice::contains

    source
    fn ModelSlice::contains(self : ModelSlice, id : Int) -> Bool

    ModelSlice::dependency_count

    source
    fn ModelSlice::dependency_count(self : ModelSlice) -> Int

    ModelSlice::difference

    source
    fn ModelSlice::difference(self : ModelSlice, other : ModelSlice) -> Array[Int]

    ModelSlice::entities_by_type

    source
    fn ModelSlice::entities_by_type(self : ModelSlice, name : String) -> Array[Entity]

    ModelSlice::entity

    source
    fn ModelSlice::entity(self : ModelSlice, id : Int) -> Entity?

    ModelSlice::headline

    source
    fn ModelSlice::headline(self : ModelSlice) -> String

    ModelSlice::ids_by_type

    source
    fn ModelSlice::ids_by_type(self : ModelSlice, name : String) -> Array[Int]

    ModelSlice::is_closed

    source
    fn ModelSlice::is_closed(self : ModelSlice) -> Bool

    ModelSlice::omitted_count

    source
    fn ModelSlice::omitted_count(self : ModelSlice) -> Int

    ModelSlice::product_count

    source
    fn ModelSlice::product_count(self : ModelSlice) -> Int

    ModelSlice::products_by_kind

    source
    fn ModelSlice::products_by_kind(self : ModelSlice, kind : ProductKind) -> Array[Product]

    ModelSlice::references_omitted

    source
    fn ModelSlice::references_omitted(self : ModelSlice) -> Array[Int]

    ModelSlice::root_count

    source
    fn ModelSlice::root_count(self : ModelSlice) -> Int

    ModelSlice::round_trip

    source
    fn ModelSlice::round_trip(self : ModelSlice) -> Model raise ParseError

    ModelSlice::summary

    source
    fn ModelSlice::summary(self : ModelSlice) -> Array[String]

    ModelSlice::to_json

    source
    fn ModelSlice::to_json(self : ModelSlice) -> String

    ModelSlice::to_markdown

    source
    fn ModelSlice::to_markdown(self : ModelSlice) -> String

    ModelSlice::to_step

    source
    fn ModelSlice::to_step(self : ModelSlice) -> String

    ModelSlice::with_additional_roots

    source
    fn ModelSlice::with_additional_roots(self : ModelSlice, ids : Array[Int], include_dependencies? : Bool) -> ModelSlice

    ModelSlice::without_roots

    source
    fn ModelSlice::without_roots(self : ModelSlice, ids : Array[Int]) -> ModelSlice

    ModelSnapshot

    source
    pub(all) struct ModelSnapshot {
      schema : String
      source_length : Int
      entity_count : Int
      product_count : Int
      shape_signatures : Array[String]
      reference_targets : Array[Int]
    } derive(
    Debug    )

    A compact model snapshot used to compare revisions without serializing twice.

    ModelSnapshot::entity_delta

    source
    fn ModelSnapshot::entity_delta(self : ModelSnapshot, other : ModelSnapshot) -> Int

    ModelSnapshot::headline

    source
    fn ModelSnapshot::headline(self : ModelSnapshot) -> String

    ModelSnapshot::product_delta

    source
    fn ModelSnapshot::product_delta(self : ModelSnapshot, other : ModelSnapshot) -> Int

    ModelSnapshot::same_references

    source
    fn ModelSnapshot::same_references(self : ModelSnapshot, other : ModelSnapshot) -> Bool

    ModelSnapshot::same_shape

    source
    fn ModelSnapshot::same_shape(self : ModelSnapshot, other : ModelSnapshot) -> Bool

    ModelSnapshot::to_json

    source
    fn ModelSnapshot::to_json(self : ModelSnapshot) -> String

    ModelSummary

    source
    pub(all) struct ModelSummary {
      schema : String
      entity_count : Int
      product_count : Int
      property_set_count : Int
      geometry_count : Int
      spatial_count : Int
    } derive(
    Debug    )

    ModelWorkspace

    source
    pub(all) struct ModelWorkspace {
      model : Model
      catalog : ModelCatalog
      spatial : SpatialIndex
      graph : GraphAnalysis
      health : SourceHealth
      quantities : TakeoffReport?
    } derive(
    Debug    )

    A reusable high-level workspace built around one parsed model.

    ModelWorkspace::catalog

    source

    ModelWorkspace::clashes

    source
    fn ModelWorkspace::clashes(self : ModelWorkspace, options? : ClashOptions) -> ClashReport

    ModelWorkspace::delivery_report

    source
    fn ModelWorkspace::delivery_report(self : ModelWorkspace) -> RuleReport raise ParseError

    ModelWorkspace::find

    source
    fn ModelWorkspace::find(self : ModelWorkspace, product_id : Int) -> Product?

    ModelWorkspace::from_model

    source
    fn ModelWorkspace::from_model(model : Model, source? : String) -> ModelWorkspace raise ParseError

    ModelWorkspace::graph_analysis

    source
    fn ModelWorkspace::graph_analysis(self : ModelWorkspace) -> GraphAnalysis

    ModelWorkspace::has_quantities

    source
    fn ModelWorkspace::has_quantities(self : ModelWorkspace) -> Bool

    ModelWorkspace::headline

    source
    fn ModelWorkspace::headline(self : ModelWorkspace) -> String raise ParseError

    ModelWorkspace::model

    source
    fn ModelWorkspace::model(self : ModelWorkspace) -> Model

    ModelWorkspace::open

    source
    fn ModelWorkspace::open(source : String) -> ModelWorkspace raise ParseError

    Parse once and prepare the indexes commonly needed by BIM applications.

    ModelWorkspace::products

    source
    fn ModelWorkspace::products(self : ModelWorkspace) -> Array[Product]

    ModelWorkspace::query

    source

    ModelWorkspace::rules

    source
    fn ModelWorkspace::rules(self : ModelWorkspace, rules : Array[ModelRule]) -> RuleReport raise ParseError

    ModelWorkspace::snapshot

    source

    ModelWorkspace::source_health

    source
    fn ModelWorkspace::source_health(self : ModelWorkspace) -> SourceHealth

    ModelWorkspace::spatial_index

    source
    fn ModelWorkspace::spatial_index(self : ModelWorkspace) -> SpatialIndex

    ModelWorkspace::summary

    source

    ModelWorkspace::takeoff

    source
    fn ModelWorkspace::takeoff(self : ModelWorkspace, options? : TakeoffOptions) -> TakeoffReport raise ParseError

    ModelWorkspace::to_json

    source
    fn ModelWorkspace::to_json(self : ModelWorkspace) -> String raise ParseError

    ModelWorkspace::with_quantities

    source
    fn ModelWorkspace::with_quantities(self : ModelWorkspace, options? : TakeoffOptions) -> ModelWorkspace raise ParseError

    NormalizedQuantity

    source
    pub(all) struct NormalizedQuantity {
      product_id : Int
      kind : QuantityKind
      value : Double
      unit : String
      source : String
      estimated : Bool
      recognized : Bool
    } derive(
    Debug    )

    A quantity normalized to the requested presentation unit.

    NormalizedQuantity::headline

    source
    fn NormalizedQuantity::headline(self : NormalizedQuantity) -> String

    NormalizedQuantity::to_json

    source
    fn NormalizedQuantity::to_json(self : NormalizedQuantity) -> String

    NumberComparison

    source
    pub(all) enum NumberComparison {
      LessThan
      LessOrEqual
      EqualTo
      GreaterOrEqual
      GreaterThan
      Between
    } derive(Eq, 
    Debug    )

    Comparison used by a numeric query predicate.

    Point3

    source
    pub(all) struct Point3 {
      x : Double
      y : Double
      z : Double
    } derive(
    Debug    )

    Product

    source
    pub(all) struct Product {
      id : Int
      ifc_type : String
      kind : ProductKind
      global_id : String?
      name : String?
      description : String?
      object_type : String?
      placement : Int?
      representation : Int?
      tag : String?
      property_sets : Array[Int]
      container : Int?
    } derive(
    Debug    )

    ProductExpression

    source
    pub(all) enum ProductExpression {
      MatchAll
      MatchNone
      Predicate(ProductPredicate)
      Not(ProductExpression)
      AllOf(Array[ProductExpression])
      AnyOf(Array[ProductExpression])
    } derive(
    Debug    )

    Boolean composition of product predicates.

    ProductExpression::all

    source

    ProductExpression::and_

    source

    ProductExpression::any

    source

    ProductExpression::describe

    source
    fn ProductExpression::describe(self : ProductExpression) -> String

    ProductExpression::not

    source

    ProductExpression::or_

    source

    ProductGeometryReport

    source
    pub(all) struct ProductGeometryReport {
      product_id : Int
      geometry_count : Int
      mesh_count : Int
      point_count : Int
      triangle_count : Int
      bounds : BoundingBox
      surface_area : Double
      volume : Double
      estimated_volume : Bool
      valid_mesh_count : Int
    } derive(
    Debug    )

    A compact report for one product's decoded geometric representations.

    ProductGeometryReport::center

    source

    ProductGeometryReport::has_mesh

    source
    fn ProductGeometryReport::has_mesh(self : ProductGeometryReport) -> Bool

    ProductGeometryReport::headline

    source
    fn ProductGeometryReport::headline(self : ProductGeometryReport) -> String

    ProductGeometryReport::is_valid

    source
    fn ProductGeometryReport::is_valid(self : ProductGeometryReport) -> Bool

    ProductGeometryReport::to_json

    source
    fn ProductGeometryReport::to_json(self : ProductGeometryReport) -> String

    ProductKind

    source
    pub(all) enum ProductKind {
      Project
      Site
      Building
      Storey
      Space
      Wall
      Door
      Window
      Beam
      Column
      Slab
      Roof
      Stair
      Ramp
      Opening
      Generic
    } derive(Eq, Hash, 
    Debug    )

    ProductPredicate

    source
    pub(all) enum ProductPredicate {
      ProductKind(ProductKind)
      EntityType(String)
      EntityTypePrefix(String)
      NameContains(String)
      DescriptionContains(String)
      GlobalId(String)
      Tag(String)
      InContainer(Int)
      HasProperties
      HasGeometry
      PropertyExists(String)
      PropertyText(String, String)
      PropertyNumber(String, NumberComparison, Double, Double?)
      IdRange(Int, Int)
      GeometryKind(GeometryKind)
      Quantity(QuantityKind, NumberComparison, Double, Double?)
    } derive(
    Debug    )

    A composable predicate over extracted IFC products.

    ProductPredicate::describe

    source
    fn ProductPredicate::describe(self : ProductPredicate) -> String

    ProductQuery

    source
    pub(all) struct ProductQuery {
      kind : ProductKind?
      ifc_type : String?
      name_contains : String?
      container : Int?
      has_properties : Bool
    } derive(
    Debug    )

    ProductQuery::in_container

    source
    fn ProductQuery::in_container(self : ProductQuery, id : Int) -> ProductQuery

    ProductQuery::named

    source
    fn ProductQuery::named(self : ProductQuery, fragment : String) -> ProductQuery

    ProductQuery::new

    source

    ProductQuery::of_kind

    source
    fn ProductQuery::of_kind(self : ProductQuery, kind : ProductKind) -> ProductQuery

    ProductQuery::of_type

    source
    fn ProductQuery::of_type(self : ProductQuery, ifc_type : String) -> ProductQuery

    ProductQuery::with_properties

    source
    fn ProductQuery::with_properties(self : ProductQuery) -> ProductQuery

    ProductQueryPage

    source
    pub(all) struct ProductQueryPage {
      products : Array[Product]
      total_matches : Int
      offset : Int
      limit : Int
      has_next : Bool
      examined : Int
    } derive(
    Debug    )

    One page returned by a product query plan.

    ProductQueryPage::count

    source
    fn ProductQueryPage::count(self : ProductQueryPage) -> Int

    ProductQueryPage::headline

    source
    fn ProductQueryPage::headline(self : ProductQueryPage) -> String

    ProductQueryPage::ids

    source
    fn ProductQueryPage::ids(self : ProductQueryPage) -> Array[Int]

    ProductQueryPage::is_empty

    source
    fn ProductQueryPage::is_empty(self : ProductQueryPage) -> Bool

    ProductQueryPage::next_offset

    source
    fn ProductQueryPage::next_offset(self : ProductQueryPage) -> Int?

    ProductQueryPage::to_json

    source
    fn ProductQueryPage::to_json(self : ProductQueryPage) -> String

    ProductQueryPlan

    source
    pub(all) struct ProductQueryPlan {
      expression : ProductExpression
      sort : ProductSort
      descending : Bool
      offset : Int
      limit : Int
      include_empty_geometry : Bool
    } derive(
    Debug    )

    A reusable query plan for repeated product searches.

    ProductQueryPlan::execute

    source
    fn ProductQueryPlan::execute(self : ProductQueryPlan, model : Model) -> ProductQueryPage raise ParseError

    ProductQueryPlan::explain

    source
    fn ProductQueryPlan::explain(self : ProductQueryPlan) -> String

    ProductQueryPlan::expression

    source

    ProductQueryPlan::including_empty_geometry

    source
    fn ProductQueryPlan::including_empty_geometry(self : ProductQueryPlan, value : Bool) -> ProductQueryPlan

    ProductQueryPlan::is_unbounded

    source
    fn ProductQueryPlan::is_unbounded(self : ProductQueryPlan) -> Bool

    ProductQueryPlan::new

    source

    ProductQueryPlan::page

    source
    fn ProductQueryPlan::page(self : ProductQueryPlan, offset : Int, limit : Int) -> ProductQueryPlan

    ProductQueryPlan::sort_key

    source

    ProductQueryPlan::sorted_by

    source
    fn ProductQueryPlan::sorted_by(self : ProductQueryPlan, sort : ProductSort, descending? : Bool) -> ProductQueryPlan

    ProductQueryPlan::where_

    source

    ProductQueryPlan::where_predicate

    source
    fn ProductQueryPlan::where_predicate(self : ProductQueryPlan, predicate : ProductPredicate) -> ProductQueryPlan

    ProductSort

    source
    pub(all) enum ProductSort {
      ById
      ByType
      ByName
      ByKind
      ByQuantity(QuantityKind)
      ByDistance(Point3)
    } derive(
    Debug    )

    Stable ordering options for a compiled product query.

    ProductTakeoff

    source
    pub(all) struct ProductTakeoff {
      product : Product
      quantities : Array[QuantityValue]
      geometry_count : Int
      mesh_triangle_count : Int
      bounds : BoundingBox
    } derive(
    Debug    )

    Quantities calculated for one IFC product.

    ProductTakeoff::has_geometry

    source
    fn ProductTakeoff::has_geometry(self : ProductTakeoff) -> Bool

    ProductTakeoff::headline

    source
    fn ProductTakeoff::headline(self : ProductTakeoff) -> String

    ProductTakeoff::is_estimated

    source
    fn ProductTakeoff::is_estimated(self : ProductTakeoff, kind : QuantityKind) -> Bool

    ProductTakeoff::quantity

    source
    fn ProductTakeoff::quantity(self : ProductTakeoff, kind : QuantityKind) -> QuantityValue?

    ProductTakeoff::to_json

    source
    fn ProductTakeoff::to_json(self : ProductTakeoff) -> String

    ProductTakeoff::value

    source
    fn ProductTakeoff::value(self : ProductTakeoff, kind : QuantityKind) -> Double

    Property

    source
    pub(all) struct Property {
      name : String
      description : String?
      value : Value
      unit : Int?
    } derive(
    Debug    )

    PropertyColumn

    source
    pub(all) struct PropertyColumn {
      name : String
      value_type : String
      populated_count : Int
      numeric_count : Int
      distinct_count : Int
    } derive(
    Debug    )

    A normalized column in a property schedule.

    PropertyColumn::coverage

    source
    fn PropertyColumn::coverage(self : PropertyColumn, row_count : Int) -> Double

    PropertyColumn::headline

    source
    fn PropertyColumn::headline(self : PropertyColumn) -> String

    PropertyColumn::is_numeric

    source
    fn PropertyColumn::is_numeric(self : PropertyColumn) -> Bool

    PropertyRow

    source
    pub(all) struct PropertyRow {
      product_id : Int
      ifc_type : String
      name : String?
      values : Map[String, String]
      missing_count : Int
    } derive(
    Debug    )

    One row in a property schedule.

    PropertyRow::has_value

    source
    fn PropertyRow::has_value(self : PropertyRow, name : String) -> Bool

    PropertyRow::headline

    source
    fn PropertyRow::headline(self : PropertyRow) -> String

    PropertyRow::value

    source
    fn PropertyRow::value(self : PropertyRow, name : String) -> String?

    PropertySet

    source
    pub(all) struct PropertySet {
      id : Int
      name : String?
      description : String?
      properties : Array[Property]
    } derive(
    Debug    )

    PropertyTable

    source
    pub(all) struct PropertyTable {
      columns : Array[PropertyColumn]
      rows : Array[PropertyRow]
      product_count : Int
      missing_value_count : Int
    } derive(
    Debug    )

    Tabular property data suitable for CSV or browser grids.

    PropertyTable::column

    source
    fn PropertyTable::column(self : PropertyTable, name : String) -> PropertyColumn?

    PropertyTable::column_names

    source
    fn PropertyTable::column_names(self : PropertyTable) -> Array[String]

    PropertyTable::complete_rows

    source
    fn PropertyTable::complete_rows(self : PropertyTable) -> Array[PropertyRow]

    PropertyTable::coverage

    source
    fn PropertyTable::coverage(self : PropertyTable, name : String) -> Double

    PropertyTable::headline

    source
    fn PropertyTable::headline(self : PropertyTable) -> String

    PropertyTable::missing_rows

    source
    fn PropertyTable::missing_rows(self : PropertyTable) -> Array[PropertyRow]

    PropertyTable::numeric_rows

    source
    fn PropertyTable::numeric_rows(self : PropertyTable, name : String, comparison : NumberComparison, expected : Double, upper? : Double?) -> Array[PropertyRow]

    PropertyTable::product_ids

    source
    fn PropertyTable::product_ids(self : PropertyTable) -> Array[Int]

    PropertyTable::row

    source
    fn PropertyTable::row(self : PropertyTable, product_id : Int) -> PropertyRow?

    PropertyTable::rows_with_value

    source
    fn PropertyTable::rows_with_value(self : PropertyTable, name : String, value : String) -> Array[PropertyRow]

    PropertyTable::to_csv

    source
    fn PropertyTable::to_csv(self : PropertyTable) -> String

    PropertyTable::to_json

    source
    fn PropertyTable::to_json(self : PropertyTable) -> String

    PropertyTable::to_markdown

    source
    fn PropertyTable::to_markdown(self : PropertyTable) -> String

    QualityFinding

    source
    pub(all) struct QualityFinding {
      code : String
      level : QualityLevel
      message : String
      entity_id : Int?
      measured : Double
      threshold : Double
      repair_hint : String
    } derive(
    Debug    )

    A concrete, actionable quality finding.

    QualityFinding::headline

    source
    fn QualityFinding::headline(self : QualityFinding) -> String

    QualityFinding::to_json

    source
    fn QualityFinding::to_json(self : QualityFinding) -> String

    QualityLevel

    source
    pub(all) enum QualityLevel {
      Pass
      Notice
      Warning
      Error
    } derive(Eq, 
    Debug    )

    Severity used by the cross-layer model quality audit.

    QualityPolicy

    source
    pub(all) struct QualityPolicy {
      maximum_orphans : Int
      minimum_named_product_ratio : Double
      minimum_guid_ratio : Double
      maximum_duplicate_ids : Int
      maximum_unknown_entity_ratio : Double
      require_units : Bool
      require_spatial_structure : Bool
      require_geometry_for_products : Bool
    } derive(
    Debug    )

    Thresholds for the model quality audit.

    QualityPolicy::allow_orphans

    source
    fn QualityPolicy::allow_orphans(self : QualityPolicy, maximum_orphans : Int) -> QualityPolicy

    QualityPolicy::requiring_geometry

    source
    fn QualityPolicy::requiring_geometry(self : QualityPolicy, required : Bool) -> QualityPolicy

    QualityPolicy::requiring_spatial_structure

    source
    fn QualityPolicy::requiring_spatial_structure(self : QualityPolicy, required : Bool) -> QualityPolicy

    QualityPolicy::requiring_units

    source
    fn QualityPolicy::requiring_units(self : QualityPolicy, required : Bool) -> QualityPolicy

    QualityPolicy::with_guid_ratio

    source
    fn QualityPolicy::with_guid_ratio(self : QualityPolicy, minimum_guid_ratio : Double) -> QualityPolicy

    QualityPolicy::with_name_ratio

    source
    fn QualityPolicy::with_name_ratio(self : QualityPolicy, minimum_named_product_ratio : Double) -> QualityPolicy

    QualityPolicy::with_unknown_ratio

    source
    fn QualityPolicy::with_unknown_ratio(self : QualityPolicy, maximum_unknown_entity_ratio : Double) -> QualityPolicy

    QuantityFormula

    source
    pub(all) struct QuantityFormula {
      kind : QuantityKind
      property_names : Array[String]
      fallback_to_geometry : Bool
      multiplier : Double
      unit : String
    } derive(
    Debug    )

    A formula override used by quantity schedules.

    QuantityFormula::from_properties

    source
    fn QuantityFormula::from_properties(self : QuantityFormula, names : Array[String]) -> QuantityFormula

    QuantityFormula::new

    source
    fn QuantityFormula::new(kind : QuantityKind, unit? : String) -> QuantityFormula

    QuantityFormula::scaled

    source
    fn QuantityFormula::scaled(self : QuantityFormula, multiplier : Double) -> QuantityFormula

    QuantityFormula::with_fallback

    source
    fn QuantityFormula::with_fallback(self : QuantityFormula, value : Bool) -> QuantityFormula

    QuantityGrouping

    source
    pub(all) enum QuantityGrouping {
      ProductType
      ProductKind
      Container
      Property(String)
    } derive(
    Debug    )

    Grouping keys used when rolling up quantity takeoff rows.

    QuantityKind

    source
    pub(all) enum QuantityKind {
      Count
      Length
      Area
      Volume
      SurfaceArea
      Height
      Width
      Depth
    } derive(Eq, Hash, 
    Debug    )

    The quantity kind used by takeoff and estimation APIs.

    QuantityNote

    source
    pub(all) struct QuantityNote {
      product_id : Int
      kind : QuantityKind
      message : String
      severity : DiagnosticSeverity
    } derive(
    Debug    )

    A non-fatal note explaining a missing or estimated quantity.

    QuantityNote::headline

    source
    fn QuantityNote::headline(self : QuantityNote) -> String

    QuantityValue

    source
    pub(all) struct QuantityValue {
      kind : QuantityKind
      value : Double
      unit : String
      source : String
      estimated : Bool
    } derive(
    Debug    )

    A measured quantity with its source and unit semantics.

    QuantityValue::headline

    source
    fn QuantityValue::headline(self : QuantityValue) -> String

    RelationIndex

    source
    pub(all) struct RelationIndex {
      links : Array[RelationLink]
      parents : Map[Int, Array[Int]]
      children : Map[Int, Array[Int]]
      containers : Map[Int, Int]
      property_sets : Map[Int, Array[Int]]
      classifications : Map[Int, Array[Int]]
    } derive(
    Debug    )

    Precomputed relationship maps for repeated semantic queries.

    RelationIndex::ancestors

    source
    fn RelationIndex::ancestors(self : RelationIndex, id : Int) -> Array[Int]

    RelationIndex::child_ids

    source
    fn RelationIndex::child_ids(self : RelationIndex, id : Int) -> Array[Int]

    RelationIndex::classification_ids

    source
    fn RelationIndex::classification_ids(self : RelationIndex, product_id : Int) -> Array[Int]

    RelationIndex::container_id

    source
    fn RelationIndex::container_id(self : RelationIndex, product_id : Int) -> Int?

    RelationIndex::descendants

    source
    fn RelationIndex::descendants(self : RelationIndex, id : Int) -> Array[Int]

    RelationIndex::headline

    source
    fn RelationIndex::headline(self : RelationIndex) -> String

    fn RelationIndex::link_count(self : RelationIndex) -> Int

    fn RelationIndex::links_for(self : RelationIndex, id : Int) -> Array[RelationLink]

    RelationIndex::new

    source

    Build normalized relation maps from raw IFC relationship entities.

    RelationIndex::parent_ids

    source
    fn RelationIndex::parent_ids(self : RelationIndex, id : Int) -> Array[Int]

    RelationIndex::products_without_container

    source
    fn RelationIndex::products_without_container(self : RelationIndex, products : Array[Product]) -> Array[Int]

    RelationIndex::products_without_properties

    source
    fn RelationIndex::products_without_properties(self : RelationIndex, products : Array[Product]) -> Array[Int]

    RelationIndex::property_set_ids

    source
    fn RelationIndex::property_set_ids(self : RelationIndex, product_id : Int) -> Array[Int]

    RelationIndex::relationship_histogram

    source
    fn RelationIndex::relationship_histogram(self : RelationIndex) -> Map[String, Int]

    RelationIndex::root_ids

    source
    fn RelationIndex::root_ids(self : RelationIndex) -> Array[Int]

    RelationIndex::to_json

    source
    fn RelationIndex::to_json(self : RelationIndex) -> String

    pub(all) struct RelationLink {
      relation_id : Int
      relation_type : String
      relating_id : Int?
      related_ids : Array[Int]
      role : String
    } derive(
    Debug    )

    A normalized IFC relationship edge.

    RelationLink::headline

    source
    fn RelationLink::headline(self : RelationLink) -> String

    RelationLink::is_many_to_one

    source
    fn RelationLink::is_many_to_one(self : RelationLink) -> Bool

    RenderManifest

    source
    pub(all) struct RenderManifest {
      schema : String
      nodes : Array[ManifestNode]
      bounds : BoundingBox
    } derive(
    Debug    )

    RenderManifest::find

    source
    fn RenderManifest::find(self : RenderManifest, product_id : Int) -> ManifestNode?

    RenderManifest::to_json

    source
    fn RenderManifest::to_json(self : RenderManifest) -> String

    RevisionDelivery

    source
    pub(all) struct RevisionDelivery {
      before_hash : Int
      after_hash : Int
      changes : Array[DeliveryAssetChange]
      affected_products : Array[Int]
      invalidated_count : Int
      retained_count : Int
      added_count : Int
      removed_count : Int
      bytes_added : Int
      bytes_removed : Int
    } derive(
    Debug    )

    Cache invalidation plan generated from two model revisions.

    RevisionDelivery::byte_delta

    source
    fn RevisionDelivery::byte_delta(self : RevisionDelivery) -> Int

    RevisionDelivery::change_count

    source
    fn RevisionDelivery::change_count(self : RevisionDelivery) -> Int

    RevisionDelivery::headline

    source
    fn RevisionDelivery::headline(self : RevisionDelivery) -> String

    RevisionDelivery::is_empty

    source
    fn RevisionDelivery::is_empty(self : RevisionDelivery) -> Bool

    RevisionDelivery::paths_for

    source
    fn RevisionDelivery::paths_for(self : RevisionDelivery, change : DeliveryChange) -> Array[String]

    RevisionDelivery::products_for_path

    source
    fn RevisionDelivery::products_for_path(self : RevisionDelivery, path : String) -> Array[Int]

    RevisionDelivery::requires_geometry_refresh

    source
    fn RevisionDelivery::requires_geometry_refresh(self : RevisionDelivery) -> Bool

    RevisionDelivery::requires_property_refresh

    source
    fn RevisionDelivery::requires_property_refresh(self : RevisionDelivery) -> Bool

    RevisionDelivery::to_json

    source
    fn RevisionDelivery::to_json(self : RevisionDelivery) -> String

    RevisionDelivery::to_markdown

    source
    fn RevisionDelivery::to_markdown(self : RevisionDelivery) -> String

    RevisionImpact

    source
    pub(all) struct RevisionImpact {
      changed_ids : Array[Int]
      affected_ids : Array[Int]
      affected_products : Array[Int]
      affected_spatial_nodes : Array[Int]
      field_changes : Array[EntityFieldChange]
      risk : String
    } derive(
    Debug    )

    Dependency impact of a model revision.

    RevisionImpact::affected_count

    source
    fn RevisionImpact::affected_count(self : RevisionImpact) -> Int

    RevisionImpact::contains_product

    source
    fn RevisionImpact::contains_product(self : RevisionImpact, id : Int) -> Bool

    RevisionImpact::field_change_count

    source
    fn RevisionImpact::field_change_count(self : RevisionImpact) -> Int

    RevisionImpact::headline

    source
    fn RevisionImpact::headline(self : RevisionImpact) -> String

    RevisionImpact::is_empty

    source
    fn RevisionImpact::is_empty(self : RevisionImpact) -> Bool

    RevisionReport

    source
    pub(all) struct RevisionReport {
      diff : ModelDiff
      impact : RevisionImpact
      added_products : Array[Int]
      removed_products : Array[Int]
      modified_products : Array[Int]
    } derive(
    Debug    )

    A deterministic revision report combining content and dependency changes.

    RevisionReport::change_count

    source
    fn RevisionReport::change_count(self : RevisionReport) -> Int

    RevisionReport::changed_product_ids

    source
    fn RevisionReport::changed_product_ids(self : RevisionReport) -> Array[Int]

    RevisionReport::field_changes_for

    source
    fn RevisionReport::field_changes_for(self : RevisionReport, id : Int) -> Array[EntityFieldChange]

    RevisionReport::headline

    source
    fn RevisionReport::headline(self : RevisionReport) -> String

    RevisionReport::impact_count

    source
    fn RevisionReport::impact_count(self : RevisionReport) -> Int

    RevisionReport::is_empty

    source
    fn RevisionReport::is_empty(self : RevisionReport) -> Bool

    RevisionReport::risk

    source
    fn RevisionReport::risk(self : RevisionReport) -> String

    RevisionReport::to_json

    source
    fn RevisionReport::to_json(self : RevisionReport) -> String

    RevisionReport::to_markdown

    source
    fn RevisionReport::to_markdown(self : RevisionReport) -> String

    RuleReport

    source
    pub(all) struct RuleReport {
      rules : Array[ModelRule]
      violations : Array[RuleViolation]
      error_count : Int
      warning_count : Int
      checked_entities : Int
      checked_products : Int
    } derive(
    Debug    )

    Result of a configurable model rule evaluation.

    RuleReport::codes

    source
    fn RuleReport::codes(self : RuleReport) -> Array[String]

    RuleReport::errors

    source
    fn RuleReport::errors(self : RuleReport) -> Array[RuleViolation]

    RuleReport::for_code

    source
    fn RuleReport::for_code(self : RuleReport, code : String) -> Array[RuleViolation]

    RuleReport::for_entity

    source
    fn RuleReport::for_entity(self : RuleReport, id : Int) -> Array[RuleViolation]

    RuleReport::format

    source
    fn RuleReport::format(self : RuleReport) -> String

    RuleReport::headline

    source
    fn RuleReport::headline(self : RuleReport) -> String

    RuleReport::is_valid

    source
    fn RuleReport::is_valid(self : RuleReport) -> Bool

    RuleReport::merge

    source
    fn RuleReport::merge(self : RuleReport, other : RuleReport) -> RuleReport

    RuleReport::to_json

    source
    fn RuleReport::to_json(self : RuleReport) -> String

    RuleReport::to_markdown

    source
    fn RuleReport::to_markdown(self : RuleReport) -> String

    RuleReport::violation_count

    source
    fn RuleReport::violation_count(self : RuleReport) -> Int

    RuleReport::warnings

    source
    fn RuleReport::warnings(self : RuleReport) -> Array[RuleViolation]

    RuleViolation

    source
    pub(all) struct RuleViolation {
      rule_code : String
      severity : DiagnosticSeverity
      entity_id : Int?
      entity_type : String?
      message : String
      property_name : String?
    } derive(
    Debug    )

    A single rule violation with enough context for UI display.

    RuleViolation::headline

    source
    fn RuleViolation::headline(self : RuleViolation) -> String

    SceneCamera

    source
    pub(all) struct SceneCamera {
      position : Point3
      forward : Vector3
      up : Vector3
      near_distance : Double
      far_distance : Double
      vertical_fov : Double
      aspect_ratio : Double
      projection : SceneProjection
    } derive(
    Debug    )

    Camera parameters shared by a WebAssembly viewer and native tools.

    SceneCamera::headline

    source
    fn SceneCamera::headline(self : SceneCamera) -> String

    SceneCamera::is_valid

    source
    fn SceneCamera::is_valid(self : SceneCamera) -> Bool

    SceneCamera::looking_at

    source
    fn SceneCamera::looking_at(self : SceneCamera, target : Point3) -> SceneCamera

    SceneCamera::real_up

    source
    fn SceneCamera::real_up(self : SceneCamera) -> Vector3

    SceneCamera::right

    source
    fn SceneCamera::right(self : SceneCamera) -> Vector3

    SceneCamera::with_clip

    source
    fn SceneCamera::with_clip(self : SceneCamera, near_distance : Double, far_distance : Double) -> SceneCamera

    SceneCamera::with_forward

    source
    fn SceneCamera::with_forward(self : SceneCamera, forward : Vector3) -> SceneCamera

    SceneCamera::with_lens

    source
    fn SceneCamera::with_lens(self : SceneCamera, vertical_fov : Double, aspect_ratio : Double) -> SceneCamera

    SceneCamera::with_position

    source
    fn SceneCamera::with_position(self : SceneCamera, position : Point3) -> SceneCamera

    SceneCamera::with_projection

    source
    fn SceneCamera::with_projection(self : SceneCamera, projection : SceneProjection) -> SceneCamera

    SceneChunk

    source
    pub(all) struct SceneChunk {
      index : Int
      product_ids : Array[Int]
      bounds : BoundingBox
      point_count : Int
      triangle_count : Int
    } derive(
    Debug    )

    A set of scene chunks used to stream large WebBIM models.

    SceneChunk::center

    source
    fn SceneChunk::center(self : SceneChunk) -> Point3

    SceneChunk::contains_product

    source
    fn SceneChunk::contains_product(self : SceneChunk, id : Int) -> Bool

    SceneChunk::headline

    source
    fn SceneChunk::headline(self : SceneChunk) -> String

    SceneChunk::intersects

    source
    fn SceneChunk::intersects(self : SceneChunk, bounds : BoundingBox, tolerance? : Double) -> Bool

    SceneChunk::is_empty

    source
    fn SceneChunk::is_empty(self : SceneChunk) -> Bool

    SceneChunk::product_count

    source
    fn SceneChunk::product_count(self : SceneChunk) -> Int

    SceneItem

    source
    pub(all) struct SceneItem {
      product : Product
      geometries : Array[Geometry]
      transform : Transform3
      bounds : BoundingBox
    } derive(
    Debug    )

    SceneLod

    source
    pub(all) enum SceneLod {
      Full
      Medium
      Coarse
      BoundsOnly
    } derive(Eq, 
    Debug    )

    Render detail selected for one visible product.

    ScenePartition

    source
    pub(all) struct ScenePartition {
      chunks : Array[SceneChunk]
      bounds : BoundingBox
      chunk_size : Int
      product_count : Int
    } derive(
    Debug    )

    A deterministic spatial partition of renderable products.

    ScenePartition::average_products_per_chunk

    source
    fn ScenePartition::average_products_per_chunk(self : ScenePartition) -> Double

    ScenePartition::chunk

    source
    fn ScenePartition::chunk(self : ScenePartition, index : Int) -> SceneChunk?

    ScenePartition::chunk_count

    source
    fn ScenePartition::chunk_count(self : ScenePartition) -> Int

    ScenePartition::chunk_for_product

    source
    fn ScenePartition::chunk_for_product(self : ScenePartition, id : Int) -> SceneChunk?

    ScenePartition::chunks_at_point

    source
    fn ScenePartition::chunks_at_point(self : ScenePartition, point : Point3, tolerance? : Double) -> Array[SceneChunk]

    ScenePartition::chunks_intersecting

    source
    fn ScenePartition::chunks_intersecting(self : ScenePartition, bounds : BoundingBox, tolerance? : Double) -> Array[SceneChunk]

    ScenePartition::headline

    source
    fn ScenePartition::headline(self : ScenePartition) -> String

    ScenePartition::largest_chunk

    source
    fn ScenePartition::largest_chunk(self : ScenePartition) -> SceneChunk?

    ScenePartition::product_ids

    source
    fn ScenePartition::product_ids(self : ScenePartition) -> Array[Int]

    ScenePartition::to_json

    source
    fn ScenePartition::to_json(self : ScenePartition) -> String

    ScenePartition::to_markdown

    source
    fn ScenePartition::to_markdown(self : ScenePartition) -> String

    ScenePick

    source
    pub(all) struct ScenePick {
      origin : Point3
      direction : Vector3
      product_id : Int?
      distance : Double?
      point : Point3?
    } derive(
    Debug    )

    A picking ray and its closest hit.

    ScenePick::headline

    source
    fn ScenePick::headline(self : ScenePick) -> String

    ScenePick::is_hit

    source
    fn ScenePick::is_hit(self : ScenePick) -> Bool

    ScenePick::to_json

    source
    fn ScenePick::to_json(self : ScenePick) -> String

    SceneProjection

    source
    pub(all) enum SceneProjection {
      Perspective
      Orthographic
    } derive(Eq, 
    Debug    )

    Projection mode used by a render-oriented visibility query.

    SceneQueryOptions

    source
    pub(all) struct SceneQueryOptions {
      tolerance : Double
      minimum_distance : Double
      maximum_items : Int
      full_detail_distance : Double
      medium_detail_distance : Double
      include_empty : Bool
      include_back_facing : Bool
    } derive(
    Debug    )

    Controls culling, LOD selection and the amount of render work returned.

    SceneQueryOptions::including_back_facing

    source
    fn SceneQueryOptions::including_back_facing(self : SceneQueryOptions, include_back_facing : Bool) -> SceneQueryOptions

    SceneQueryOptions::including_empty

    source
    fn SceneQueryOptions::including_empty(self : SceneQueryOptions, include_empty : Bool) -> SceneQueryOptions

    SceneQueryOptions::with_lod_distances

    source
    fn SceneQueryOptions::with_lod_distances(self : SceneQueryOptions, full_detail_distance : Double, medium_detail_distance : Double) -> SceneQueryOptions

    SceneQueryOptions::with_maximum_items

    source
    fn SceneQueryOptions::with_maximum_items(self : SceneQueryOptions, maximum_items : Int) -> SceneQueryOptions

    SceneQueryOptions::with_tolerance

    source
    fn SceneQueryOptions::with_tolerance(self : SceneQueryOptions, tolerance : Double) -> SceneQueryOptions

    SceneSelection

    source
    pub(all) struct SceneSelection {
      items : Array[SceneVisibleItem]
      tested_count : Int
      culled_count : Int
      full_count : Int
      medium_count : Int
      coarse_count : Int
      bounds_only_count : Int
      visible_bounds : BoundingBox
    } derive(
    Debug    )

    Result of a visibility query over an indexed IFC model.

    SceneSelection::by_lod

    source

    SceneSelection::contains

    source
    fn SceneSelection::contains(self : SceneSelection, product_id : Int) -> Bool

    SceneSelection::from_index

    source
    fn SceneSelection::from_index(index : SpatialIndex, camera : SceneCamera, options? : SceneQueryOptions) -> SceneSelection

    Select visible products and a stable LOD for a camera frame.

    SceneSelection::headline

    source
    fn SceneSelection::headline(self : SceneSelection) -> String

    SceneSelection::ids

    source
    fn SceneSelection::ids(self : SceneSelection) -> Array[Int]

    SceneSelection::item

    source
    fn SceneSelection::item(self : SceneSelection, product_id : Int) -> SceneVisibleItem?

    SceneSelection::lod_histogram

    source
    fn SceneSelection::lod_histogram(self : SceneSelection) -> Map[String, Int]

    SceneSelection::to_json

    source
    fn SceneSelection::to_json(self : SceneSelection) -> String

    SceneSelection::to_markdown

    source
    fn SceneSelection::to_markdown(self : SceneSelection) -> String

    SceneSelection::triangle_budget

    source
    fn SceneSelection::triangle_budget(self : SceneSelection) -> Int

    SceneSelection::visible_count

    source
    fn SceneSelection::visible_count(self : SceneSelection) -> Int

    SceneVisibleItem

    source
    pub(all) struct SceneVisibleItem {
      product_id : Int
      ifc_type : String
      distance : Double
      depth : Double
      projected_radius : Double
      lod : SceneLod
      triangle_count : Int
      bounds : BoundingBox
    } derive(
    Debug    )

    A visible item with a conservative screen-independent LOD choice.

    SchemaIssue

    source
    pub(all) struct SchemaIssue {
      code : String
      entity_id : Int
      entity_name : String
      message : String
      severity : DiagnosticSeverity
    } derive(
    Debug    )

    SchemaProfile

    source
    pub(all) struct SchemaProfile {
      name : String
      version : SchemaVersion
      rules : Array[SchemaRule]
      known_entity_count : Int
    } derive(
    Debug    )

    SchemaProfile::rule

    source
    fn SchemaProfile::rule(self : SchemaProfile, entity_name : String) -> SchemaRule?

    SchemaReport

    source
    pub(all) struct SchemaReport {
      profile : SchemaProfile
      checked_entities : Int
      issues : Array[SchemaIssue]
      error_count : Int
      warning_count : Int
    } derive(
    Debug    )

    SchemaReport::format

    source
    fn SchemaReport::format(self : SchemaReport) -> String

    SchemaReport::headline

    source
    fn SchemaReport::headline(self : SchemaReport) -> String

    SchemaReport::is_valid

    source
    fn SchemaReport::is_valid(self : SchemaReport) -> Bool

    SchemaReport::unknown_entity_count

    source
    fn SchemaReport::unknown_entity_count(self : SchemaReport) -> Int

    SchemaRule

    source
    pub(all) struct SchemaRule {
      entity_name : String
      minimum_arguments : Int
      maximum_arguments : Int?
      required_reference_arguments : Array[Int]
      family : String
      description : String
    } derive(
    Debug    )

    A lightweight schema rule used by the validation layer.

    SchemaVersion

    source
    pub(all) enum SchemaVersion {
      IFC2X3
      IFC4
      IFC4X3
      UnknownSchema(String)
    } derive(Eq, 
    Debug    )

    SearchField

    source
    pub(all) enum SearchField {
      EntityType
      EntityText
      ProductName
      ProductGlobalId
      ProductTag
      PropertyName
      PropertyValue
    } derive(Eq, 
    Debug    )

    SearchHit

    source
    pub(all) struct SearchHit {
      entity_id : Int
      product_id : Int?
      field : SearchField
      value : String
    } derive(
    Debug    )

    SectionOptions

    source
    pub(all) struct SectionOptions {
      tolerance : Double
      include_coplanar_edges : Bool
      maximum_segments : Int
      join_tolerance : Double
    } derive(
    Debug    )

    Controls numerical tolerance and segment limits for a section cut.

    SectionOptions::including_coplanar_edges

    source
    fn SectionOptions::including_coplanar_edges(self : SectionOptions, enabled : Bool) -> SectionOptions

    SectionOptions::with_join_tolerance

    source
    fn SectionOptions::with_join_tolerance(self : SectionOptions, tolerance : Double) -> SectionOptions

    SectionOptions::with_maximum_segments

    source
    fn SectionOptions::with_maximum_segments(self : SectionOptions, maximum : Int) -> SectionOptions

    SectionOptions::with_tolerance

    source
    fn SectionOptions::with_tolerance(self : SectionOptions, tolerance : Double) -> SectionOptions

    SectionPlane

    source
    pub(all) struct SectionPlane {
      origin : Point3
      normal : Vector3
    } derive(
    Debug    )

    A plane used to extract a coordination or quantity-takeoff section.

    SectionPlane::headline

    source
    fn SectionPlane::headline(self : SectionPlane) -> String

    SectionPlane::horizontal

    source
    fn SectionPlane::horizontal(height : Double) -> SectionPlane

    SectionPlane::is_valid

    source
    fn SectionPlane::is_valid(self : SectionPlane) -> Bool

    SectionPlane::new

    source
    fn SectionPlane::new(origin~ : Point3, normal~ : Vector3) -> SectionPlane

    SectionPlane::project

    source
    fn SectionPlane::project(self : SectionPlane, point : Point3) -> Point3

    SectionPlane::signed_distance

    source
    fn SectionPlane::signed_distance(self : SectionPlane, point : Point3) -> Double

    SectionPlane::vertical_x

    source
    fn SectionPlane::vertical_x(offset : Double) -> SectionPlane

    SectionPlane::vertical_y

    source
    fn SectionPlane::vertical_y(offset : Double) -> SectionPlane

    SectionPolyline

    source
    pub(all) struct SectionPolyline {
      product_id : Int
      points : Array[Point3]
      closed : Bool
      length : Double
      area : Double
    } derive(
    Debug    )

    A connected sequence of section points assembled from raw segments.

    SectionPolyline::first

    source
    fn SectionPolyline::first(self : SectionPolyline) -> Point3?

    SectionPolyline::is_degenerate

    source
    fn SectionPolyline::is_degenerate(self : SectionPolyline, tolerance? : Double) -> Bool

    SectionPolyline::last

    source

    SectionPolyline::point_count

    source
    fn SectionPolyline::point_count(self : SectionPolyline) -> Int

    SectionResult

    source
    pub(all) struct SectionResult {
      plane : SectionPlane
      segments : Array[SectionSegment]
      polylines : Array[SectionPolyline]
      product_ids : Array[Int]
      intersected_triangle_count : Int
      total_length : Double
      bounds : BoundingBox
    } derive(
    Debug    )

    Aggregate output of a section extraction.

    SectionResult::closed_count

    source
    fn SectionResult::closed_count(self : SectionResult) -> Int

    SectionResult::headline

    source
    fn SectionResult::headline(self : SectionResult) -> String

    SectionResult::polyline_count

    source
    fn SectionResult::polyline_count(self : SectionResult) -> Int

    SectionResult::polylines_for_product

    source
    fn SectionResult::polylines_for_product(self : SectionResult, product_id : Int) -> Array[SectionPolyline]

    SectionResult::product_count

    source
    fn SectionResult::product_count(self : SectionResult) -> Int

    SectionResult::segment_count

    source
    fn SectionResult::segment_count(self : SectionResult) -> Int

    SectionResult::segments_for_product

    source
    fn SectionResult::segments_for_product(self : SectionResult, product_id : Int) -> Array[SectionSegment]

    SectionResult::to_csv

    source
    fn SectionResult::to_csv(self : SectionResult) -> String

    SectionResult::to_json

    source
    fn SectionResult::to_json(self : SectionResult) -> String

    SectionResult::to_markdown

    source
    fn SectionResult::to_markdown(self : SectionResult) -> String

    SectionResult::total_area

    source
    fn SectionResult::total_area(self : SectionResult) -> Double

    SectionSegment

    source
    pub(all) struct SectionSegment {
      product_id : Int
      source_triangle : Int
      start : Point3
      end : Point3
      length : Double
      coplanar : Bool
    } derive(
    Debug    )

    One line segment produced by intersecting a triangle with a plane.

    SortDirection

    source
    pub(all) enum SortDirection {
      Ascending
      Descending
    } derive(Eq, 
    Debug    )

    SourceHealth

    source
    pub(all) struct SourceHealth {
      byte_length : Int
      line_count : Int
      record_count : Int
      maximum_record_length : Int
      reference_count : Int
      balanced_parentheses : Bool
      balanced_strings : Bool
      has_iso_header : Bool
      has_end_marker : Bool
    } derive(
    Debug    )

    Cheap source-level health indicators used before allocating a full model.

    SourceHealth::is_well_formed

    source
    fn SourceHealth::is_well_formed(self : SourceHealth) -> Bool

    SourceHealth::summary

    source
    fn SourceHealth::summary(self : SourceHealth) -> String

    SourcePosition

    source
    pub(all) struct SourcePosition {
      offset : Int
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    A source position measured in Unicode code units.

    SourcePosition::new

    source
    fn SourcePosition::new(offset~ : Int, line~ : Int, column~ : Int) -> SourcePosition

    SourceWindow

    source
    pub(all) struct SourceWindow {
      start : Int
      end : Int
      text : String
      line : Int
    } derive(
    Debug    )

    SpaceAdjacency

    source
    pub(all) struct SpaceAdjacency {
      left_space : Int
      right_space : Int
      shared_elements : Array[Int]
      boundary_count : Int
      distance : Double
    } derive(
    Debug    )

    A shared building element that connects two spaces.

    SpaceAdjacency::headline

    source
    fn SpaceAdjacency::headline(self : SpaceAdjacency) -> String

    SpaceAdjacencyGraph

    source
    pub(all) struct SpaceAdjacencyGraph {
      spaces : Array[Int]
      edges : Array[SpaceAdjacency]
      neighbors : Map[Int, Array[Int]]
    } derive(
    Debug    )

    Space adjacency graph for navigation and evacuation analysis.

    SpaceAdjacencyGraph::degree

    source
    fn SpaceAdjacencyGraph::degree(self : SpaceAdjacencyGraph, id : Int) -> Int

    SpaceAdjacencyGraph::edge

    source
    fn SpaceAdjacencyGraph::edge(self : SpaceAdjacencyGraph, left : Int, right : Int) -> SpaceAdjacency?

    SpaceAdjacencyGraph::edge_count

    source
    fn SpaceAdjacencyGraph::edge_count(self : SpaceAdjacencyGraph) -> Int

    SpaceAdjacencyGraph::headline

    source
    fn SpaceAdjacencyGraph::headline(self : SpaceAdjacencyGraph) -> String

    SpaceAdjacencyGraph::isolated_spaces

    source
    fn SpaceAdjacencyGraph::isolated_spaces(self : SpaceAdjacencyGraph) -> Array[Int]

    SpaceAdjacencyGraph::neighbors

    source
    fn SpaceAdjacencyGraph::neighbors(self : SpaceAdjacencyGraph, id : Int) -> Array[Int]

    SpaceAdjacencyGraph::new

    source

    Build a room adjacency graph from IfcRelSpaceBoundary records.

    SpaceAdjacencyGraph::reachable

    source
    fn SpaceAdjacencyGraph::reachable(self : SpaceAdjacencyGraph, start : Int) -> Array[Int]

    SpaceAdjacencyGraph::shortest_path

    source
    fn SpaceAdjacencyGraph::shortest_path(self : SpaceAdjacencyGraph, start : Int, goal : Int) -> Array[Int]?

    SpaceAdjacencyGraph::space_count

    source
    fn SpaceAdjacencyGraph::space_count(self : SpaceAdjacencyGraph) -> Int

    SpaceAdjacencyGraph::to_json

    source
    fn SpaceAdjacencyGraph::to_json(self : SpaceAdjacencyGraph) -> String

    SpaceAdjacencyGraph::to_markdown

    source
    fn SpaceAdjacencyGraph::to_markdown(self : SpaceAdjacencyGraph) -> String

    SpatialEntry

    source
    pub(all) struct SpatialEntry {
      product_id : Int
      entity_id : Int
      ifc_type : String
      name : String?
      container : Int?
      bounds : BoundingBox
      geometry_count : Int
      point_count : Int
      triangle_count : Int
    } derive(
    Debug    )

    A product's world-space spatial record.

    SpatialEntry::center

    source
    fn SpatialEntry::center(self : SpatialEntry) -> Point3

    SpatialEntry::headline

    source
    fn SpatialEntry::headline(self : SpatialEntry) -> String

    SpatialEntry::is_empty

    source
    fn SpatialEntry::is_empty(self : SpatialEntry) -> Bool

    SpatialEntry::volume

    source
    fn SpatialEntry::volume(self : SpatialEntry) -> Double

    SpatialHit

    source
    pub(all) struct SpatialHit {
      product_id : Int
      entity_id : Int
      bounds : BoundingBox
      relation : BoxRelation
      distance : Double
      overlap_volume : Double
    } derive(
    Debug    )

    A hit returned from a spatial query.

    SpatialHit::headline

    source
    fn SpatialHit::headline(self : SpatialHit) -> String

    SpatialIndex

    source
    pub(all) struct SpatialIndex {
      entries : Array[SpatialEntry]
      cells : Map[String, Array[Int]]
      bounds : BoundingBox
      cell_size : Double
    } derive(
    Debug    )

    A configurable spatial grid used for broad-phase BIM queries.

    SpatialIndex::bounds

    source
    fn SpatialIndex::bounds(self : SpatialIndex) -> BoundingBox

    SpatialIndex::bounds_for_products

    source
    fn SpatialIndex::bounds_for_products(self : SpatialIndex, product_ids : Array[Int]) -> BoundingBox

    SpatialIndex::cell_count

    source
    fn SpatialIndex::cell_count(self : SpatialIndex) -> Int

    SpatialIndex::cell_size

    source
    fn SpatialIndex::cell_size(self : SpatialIndex) -> Double

    SpatialIndex::contains_product

    source
    fn SpatialIndex::contains_product(self : SpatialIndex, product_id : Int) -> Bool

    SpatialIndex::distance_between

    source
    fn SpatialIndex::distance_between(self : SpatialIndex, left_id : Int, right_id : Int) -> Double?

    SpatialIndex::entries

    source

    SpatialIndex::entry

    source
    fn SpatialIndex::entry(self : SpatialIndex, product_id : Int) -> SpatialEntry?

    SpatialIndex::intersections

    source
    fn SpatialIndex::intersections(self : SpatialIndex, query : BoundingBox, tolerance? : Double) -> Array[SpatialEntry]

    SpatialIndex::nearest

    source
    fn SpatialIndex::nearest(self : SpatialIndex, point : Point3, maximum_distance? : Double) -> SpatialHit?

    SpatialIndex::new

    source
    fn SpatialIndex::new(model : Model, options? : SpatialIndexOptions) -> SpatialIndex raise ParseError

    Build a broad-phase spatial index from transformed product meshes.

    SpatialIndex::product_ids

    source
    fn SpatialIndex::product_ids(self : SpatialIndex) -> Array[Int]

    SpatialIndex::products_in_container

    source
    fn SpatialIndex::products_in_container(self : SpatialIndex, container_id : Int) -> Array[SpatialEntry]

    SpatialIndex::query_box

    source
    fn SpatialIndex::query_box(self : SpatialIndex, query : BoundingBox, tolerance? : Double) -> Array[SpatialHit]

    SpatialIndex::query_point

    source
    fn SpatialIndex::query_point(self : SpatialIndex, point : Point3, tolerance? : Double) -> Array[SpatialHit]

    SpatialIndex::query_range

    source
    fn SpatialIndex::query_range(self : SpatialIndex, minimum : Point3, maximum : Point3, tolerance? : Double) -> Array[SpatialHit]

    SpatialIndex::query_sphere

    source
    fn SpatialIndex::query_sphere(self : SpatialIndex, center : Point3, radius : Double) -> Array[SpatialHit]

    SpatialIndex::raycast

    source
    fn SpatialIndex::raycast(self : SpatialIndex, origin : Point3, direction : Vector3, maximum_distance? : Double) -> Array[SpatialHit]

    SpatialIndex::raycast_first

    source
    fn SpatialIndex::raycast_first(self : SpatialIndex, origin : Point3, direction : Vector3, maximum_distance? : Double) -> SpatialHit?

    SpatialIndex::relation_between

    source
    fn SpatialIndex::relation_between(self : SpatialIndex, left_id : Int, right_id : Int, tolerance? : Double) -> BoxRelation?

    SpatialIndex::to_json

    source
    fn SpatialIndex::to_json(self : SpatialIndex) -> String

    SpatialIndex::total_geometry_count

    source
    fn SpatialIndex::total_geometry_count(self : SpatialIndex) -> Int

    SpatialIndex::total_triangles

    source
    fn SpatialIndex::total_triangles(self : SpatialIndex) -> Int

    SpatialIndex::type_histogram

    source
    fn SpatialIndex::type_histogram(self : SpatialIndex) -> Map[String, Int]

    SpatialIndex::within

    source
    fn SpatialIndex::within(self : SpatialIndex, container : BoundingBox, tolerance? : Double) -> Array[SpatialEntry]

    SpatialIndexOptions

    source
    pub(all) struct SpatialIndexOptions {
      cell_size : Double
      include_empty : Bool
      maximum_entries : Int
    } derive(
    Debug    )

    Options for constructing a spatial index.

    SpatialIndexOptions::including_empty

    source
    fn SpatialIndexOptions::including_empty(self : SpatialIndexOptions, include_empty : Bool) -> SpatialIndexOptions

    SpatialIndexOptions::with_cell_size

    source
    fn SpatialIndexOptions::with_cell_size(self : SpatialIndexOptions, cell_size : Double) -> SpatialIndexOptions

    SpatialIndexOptions::with_maximum_entries

    source
    fn SpatialIndexOptions::with_maximum_entries(self : SpatialIndexOptions, maximum_entries : Int) -> SpatialIndexOptions

    SpatialMetrics

    source
    pub(all) struct SpatialMetrics {
      node_count : Int
      leaf_count : Int
      product_count : Int
      max_depth : Int
      occupied_volume : Double
      bounds : BoundingBox
    } derive(
    Debug    )

    Spatial roll-up metrics for a subtree or an entire model.

    SpatialNode

    source
    pub(all) struct SpatialNode {
      id : Int
      ifc_type : String
      name : String?
      children : Array[SpatialNode]
      products : Array[Int]
    } derive(
    Debug    )

    SpatialNode::all_product_ids

    source
    fn SpatialNode::all_product_ids(self : SpatialNode) -> Array[Int]

    SpatialNode::contains

    source
    fn SpatialNode::contains(self : SpatialNode, id : Int) -> Bool

    SpatialNode::depth

    source
    fn SpatialNode::depth(self : SpatialNode) -> Int

    Return the number of levels below a spatial node. IFC aggregation is a graph in the file, but applications consume it as a bounded tree.

    SpatialNode::find

    source
    fn SpatialNode::find(self : SpatialNode, id : Int) -> SpatialNode?

    SpatialNode::is_leaf

    source
    fn SpatialNode::is_leaf(self : SpatialNode) -> Bool

    SpatialNode::leaf_count

    source
    fn SpatialNode::leaf_count(self : SpatialNode) -> Int

    SpatialNode::leaves

    source
    fn SpatialNode::leaves(self : SpatialNode) -> Array[SpatialNode]

    SpatialNode::node_count

    source
    fn SpatialNode::node_count(self : SpatialNode) -> Int

    SpatialNode::nodes_at_depth

    source
    fn SpatialNode::nodes_at_depth(self : SpatialNode, wanted : Int) -> Array[SpatialNode]

    SpatialNode::path_to

    source
    fn SpatialNode::path_to(self : SpatialNode, target : Int) -> Array[Int]?

    SpatialNode::product_count

    source
    fn SpatialNode::product_count(self : SpatialNode) -> Int

    SpatialNode::type_histogram

    source
    fn SpatialNode::type_histogram(self : SpatialNode) -> Map[String, Int]

    SpatialNode::unique_product_ids

    source
    fn SpatialNode::unique_product_ids(self : SpatialNode) -> Array[Int]

    SpatialSchedule

    source
    pub(all) struct SpatialSchedule {
      rows : Array[SpatialScheduleRow]
      total_spaces : Int
      total_products : Int
      total_area : Double
      total_volume : Double
    } derive(
    Debug    )

    Spatial schedule for all rooms and storeys in a model.

    SpatialSchedule::average_space_area

    source
    fn SpatialSchedule::average_space_area(self : SpatialSchedule) -> Double

    SpatialSchedule::find

    source
    fn SpatialSchedule::find(self : SpatialSchedule, id : Int) -> SpatialScheduleRow?

    SpatialSchedule::headline

    source
    fn SpatialSchedule::headline(self : SpatialSchedule) -> String

    SpatialSchedule::named

    source
    fn SpatialSchedule::named(self : SpatialSchedule, fragment : String) -> Array[SpatialScheduleRow]

    SpatialSchedule::row_count

    source
    fn SpatialSchedule::row_count(self : SpatialSchedule) -> Int

    SpatialSchedule::spaces

    source

    SpatialSchedule::storeys

    source

    SpatialSchedule::to_csv

    source
    fn SpatialSchedule::to_csv(self : SpatialSchedule) -> String

    SpatialSchedule::to_json

    source
    fn SpatialSchedule::to_json(self : SpatialSchedule) -> String

    SpatialSchedule::to_markdown

    source
    fn SpatialSchedule::to_markdown(self : SpatialSchedule) -> String

    SpatialSchedule::total_doors

    source
    fn SpatialSchedule::total_doors(self : SpatialSchedule) -> Int

    SpatialSchedule::total_walls

    source
    fn SpatialSchedule::total_walls(self : SpatialSchedule) -> Int

    SpatialSchedule::total_windows

    source
    fn SpatialSchedule::total_windows(self : SpatialSchedule) -> Int

    SpatialScheduleRow

    source
    pub(all) struct SpatialScheduleRow {
      id : Int
      name : String
      ifc_type : String
      path : Array[Int]
      product_count : Int
      door_count : Int
      window_count : Int
      wall_count : Int
      area : Double
      volume : Double
      bounds : BoundingBox
    } derive(
    Debug    )

    A room or space schedule row used by coordination tools.

    SpatialScheduleRow::headline

    source
    fn SpatialScheduleRow::headline(self : SpatialScheduleRow) -> String

    SpatialScheduleRow::opening_count

    source
    fn SpatialScheduleRow::opening_count(self : SpatialScheduleRow) -> Int

    SpatialScheduleRow::path_text

    source
    fn SpatialScheduleRow::path_text(self : SpatialScheduleRow) -> String

    StepDocumentStats

    source
    pub(all) struct StepDocumentStats {
      byte_length : Int
      line_count : Int
      entity_count : Int
      reference_count : Int
      string_count : Int
      comment_count : Int
    } derive(
    Debug    )

    StepRecord

    source
    pub(all) struct StepRecord {
      id : Int
      name : String
      start_offset : Int
      end_offset : Int
      line : Int
      raw : String
    } derive(
    Debug    )

    A physical STEP entity record found by the streaming scanner.

    StepRecord::contains_reference

    source
    fn StepRecord::contains_reference(self : StepRecord, id : Int) -> Bool

    StepRecord::is_relationship

    source
    fn StepRecord::is_relationship(self : StepRecord) -> Bool

    StepRecord::length

    source
    fn StepRecord::length(self : StepRecord) -> Int

    StepRecord::reference_count

    source
    fn StepRecord::reference_count(self : StepRecord) -> Int

    StepRecord::source_window

    source
    fn StepRecord::source_window(self : StepRecord, source : String) -> SourceWindow

    StepRecord::summary

    source
    fn StepRecord::summary(self : StepRecord) -> String

    StreamBatch

    source
    pub(all) struct StreamBatch {
      sequence : Int
      start_offset : Int
      end_offset : Int
      records : Array[StepRecord]
      complete : Bool
    } derive(
    Debug    )

    A bounded batch of raw STEP records.

    StreamBatch::first_id

    source
    fn StreamBatch::first_id(self : StreamBatch) -> Int?

    StreamBatch::headline

    source
    fn StreamBatch::headline(self : StreamBatch) -> String

    StreamBatch::is_empty

    source
    fn StreamBatch::is_empty(self : StreamBatch) -> Bool

    StreamBatch::last_id

    source
    fn StreamBatch::last_id(self : StreamBatch) -> Int?

    StreamBatch::parse_entities

    source
    fn StreamBatch::parse_entities(self : StreamBatch) -> Array[Entity] raise ParseError

    StreamBatch::record_count

    source
    fn StreamBatch::record_count(self : StreamBatch) -> Int

    StreamBatch::to_json

    source
    fn StreamBatch::to_json(self : StreamBatch) -> String

    StreamFilter

    source
    pub(all) struct StreamFilter {
      names : Array[String]
      first_id : Int?
      last_id : Int?
      minimum_length : Int
      maximum_length : Int
      maximum_records : Int
    } derive(
    Debug    )

    Filter used by the low-allocation STEP record stream API.

    StreamFilter::between_ids

    source
    fn StreamFilter::between_ids(self : StreamFilter, first : Int?, last : Int?) -> StreamFilter

    StreamFilter::describe

    source
    fn StreamFilter::describe(self : StreamFilter) -> String

    StreamFilter::is_unbounded

    source
    fn StreamFilter::is_unbounded(self : StreamFilter) -> Bool

    StreamFilter::limiting

    source
    fn StreamFilter::limiting(self : StreamFilter, count : Int) -> StreamFilter

    StreamFilter::matches

    source
    fn StreamFilter::matches(self : StreamFilter, record : StepRecord) -> Bool

    StreamFilter::named

    source
    fn StreamFilter::named(self : StreamFilter, name : String) -> StreamFilter

    StreamFilter::with_maximum_length

    source
    fn StreamFilter::with_maximum_length(self : StreamFilter, length : Int) -> StreamFilter

    StreamFilter::with_minimum_length

    source
    fn StreamFilter::with_minimum_length(self : StreamFilter, length : Int) -> StreamFilter

    StreamFilter::with_name_set

    source
    fn StreamFilter::with_name_set(self : StreamFilter, names : Array[String]) -> StreamFilter

    StreamSelection

    source
    pub(all) struct StreamSelection {
      records : Array[StepRecord]
      examined : Int
      selected : Int
      truncated : Bool
      first_offset : Int
      last_offset : Int
    } derive(
    Debug    )

    Summary of a filtered stream operation.

    StreamSelection::first

    source

    StreamSelection::headline

    source
    fn StreamSelection::headline(self : StreamSelection) -> String

    StreamSelection::ids

    source
    fn StreamSelection::ids(self : StreamSelection) -> Array[Int]

    StreamSelection::is_empty

    source
    fn StreamSelection::is_empty(self : StreamSelection) -> Bool

    StreamSelection::last

    source

    StreamSelection::names

    source
    fn StreamSelection::names(self : StreamSelection) -> Array[String]

    StreamSelection::parse_entities

    source
    fn StreamSelection::parse_entities(self : StreamSelection) -> Array[Entity] raise ParseError

    StreamSelection::to_json

    source
    fn StreamSelection::to_json(self : StreamSelection) -> String

    StreamStats

    source
    pub(all) struct StreamStats {
      source_length : Int
      record_count : Int
      reference_count : Int
      max_record_length : Int
      comment_count : Int
      line_count : Int
      schema : String?
    } derive(
    Debug    )

    Statistics collected without constructing the complete entity graph.

    StreamStats::density

    source
    fn StreamStats::density(self : StreamStats) -> Double

    StreamStats::headline

    source
    fn StreamStats::headline(self : StreamStats) -> String

    TakeoffGroup

    source
    pub(all) struct TakeoffGroup {
      key : String
      product_count : Int
      quantities : Array[QuantityValue]
    } derive(
    Debug    )

    A roll-up row grouped by type, container or an application key.

    TakeoffGroup::headline

    source
    fn TakeoffGroup::headline(self : TakeoffGroup) -> String

    TakeoffGroup::quantity

    source
    fn TakeoffGroup::quantity(self : TakeoffGroup, kind : QuantityKind) -> QuantityValue?

    TakeoffGroup::value

    source
    fn TakeoffGroup::value(self : TakeoffGroup, kind : QuantityKind) -> Double

    TakeoffOptions

    source
    pub(all) struct TakeoffOptions {
      grouping : QuantityGrouping
      include_empty : Bool
      include_unknown : Bool
      use_mesh_measurements : Bool
      include_surface_area : Bool
      minimum_value : Double
    } derive(
    Debug    )

    Options for geometry and property driven quantity extraction.

    TakeoffOptions::group_by

    source
    fn TakeoffOptions::group_by(self : TakeoffOptions, grouping : QuantityGrouping) -> TakeoffOptions

    TakeoffOptions::including_empty

    source
    fn TakeoffOptions::including_empty(self : TakeoffOptions, value : Bool) -> TakeoffOptions

    TakeoffOptions::including_surface_area

    source
    fn TakeoffOptions::including_surface_area(self : TakeoffOptions, value : Bool) -> TakeoffOptions

    TakeoffOptions::including_unknown

    source
    fn TakeoffOptions::including_unknown(self : TakeoffOptions, value : Bool) -> TakeoffOptions

    TakeoffOptions::using_mesh_measurements

    source
    fn TakeoffOptions::using_mesh_measurements(self : TakeoffOptions, value : Bool) -> TakeoffOptions

    TakeoffOptions::with_minimum_value

    source
    fn TakeoffOptions::with_minimum_value(self : TakeoffOptions, value : Double) -> TakeoffOptions

    TakeoffReport

    source
    pub(all) struct TakeoffReport {
      products : Array[ProductTakeoff]
      groups : Array[TakeoffGroup]
      unit_system : UnitSystem
      source_schema : String
      skipped_products : Int
    } derive(
    Debug    )

    Complete quantity takeoff result.

    TakeoffReport::estimated_count

    source
    fn TakeoffReport::estimated_count(self : TakeoffReport, kind : QuantityKind) -> Int

    TakeoffReport::find_group

    source
    fn TakeoffReport::find_group(self : TakeoffReport, key : String) -> TakeoffGroup?

    TakeoffReport::find_product

    source
    fn TakeoffReport::find_product(self : TakeoffReport, id : Int) -> ProductTakeoff?

    TakeoffReport::group_count

    source
    fn TakeoffReport::group_count(self : TakeoffReport) -> Int

    TakeoffReport::group_keys

    source
    fn TakeoffReport::group_keys(self : TakeoffReport) -> Array[String]

    TakeoffReport::headline

    source
    fn TakeoffReport::headline(self : TakeoffReport) -> String

    TakeoffReport::product_count

    source
    fn TakeoffReport::product_count(self : TakeoffReport) -> Int

    TakeoffReport::quantity_kinds

    source
    fn TakeoffReport::quantity_kinds(self : TakeoffReport) -> Array[String]

    TakeoffReport::to_csv

    source
    fn TakeoffReport::to_csv(self : TakeoffReport) -> String

    TakeoffReport::to_json

    source
    fn TakeoffReport::to_json(self : TakeoffReport) -> String

    TakeoffReport::to_markdown

    source
    fn TakeoffReport::to_markdown(self : TakeoffReport) -> String

    TakeoffReport::total

    source
    fn TakeoffReport::total(self : TakeoffReport, kind : QuantityKind) -> Double

    TakeoffReport::total_in_si

    source
    fn TakeoffReport::total_in_si(self : TakeoffReport, kind : QuantityKind) -> Double

    TopologyIssue

    source
    pub(all) struct TopologyIssue {
      kind : TopologyIssueKind
      triangle : Int?
      vertex_a : Int?
      vertex_b : Int?
      message : String
    } derive(
    Debug    )

    TopologyIssue::headline

    source
    fn TopologyIssue::headline(self : TopologyIssue) -> String

    TopologyIssue::to_json

    source
    fn TopologyIssue::to_json(self : TopologyIssue) -> String

    TopologyIssueKind

    source
    pub(all) enum TopologyIssueKind {
      InvalidIndex
      DegenerateTriangle
      BoundaryEdge
      NonManifoldEdge
      DisconnectedComponent
      EmptyMesh
    } derive(Eq, 
    Debug    )

    A topology problem that can be surfaced before export or clash analysis.

    TopologyReport

    source
    pub(all) struct TopologyReport {
      point_count : Int
      triangle_count : Int
      valid_triangle_count : Int
      edge_count : Int
      boundary_edge_count : Int
      non_manifold_edge_count : Int
      degenerate_triangle_count : Int
      invalid_index_count : Int
      component_count : Int
      euler_characteristic : Int
      surface_area : Double
      signed_volume : Double
      issues : Array[TopologyIssue]
    } derive(
    Debug    )

    TopologyReport::headline

    source
    fn TopologyReport::headline(self : TopologyReport) -> String

    TopologyReport::is_closed

    source
    fn TopologyReport::is_closed(self : TopologyReport) -> Bool

    TopologyReport::is_manifold

    source
    fn TopologyReport::is_manifold(self : TopologyReport) -> Bool

    TopologyReport::is_renderable

    source
    fn TopologyReport::is_renderable(self : TopologyReport) -> Bool

    TopologyReport::is_solid_candidate

    source
    fn TopologyReport::is_solid_candidate(self : TopologyReport) -> Bool

    TopologyReport::issue_count

    source
    fn TopologyReport::issue_count(self : TopologyReport) -> Int

    TopologyReport::issues_of

    source

    TopologyReport::signed_volume

    source
    fn TopologyReport::signed_volume(self : TopologyReport) -> Double

    TopologyReport::to_json

    source
    fn TopologyReport::to_json(self : TopologyReport) -> String

    TopologyReport::to_markdown

    source
    fn TopologyReport::to_markdown(self : TopologyReport) -> String

    Transform3

    source
    pub(all) struct Transform3 {
      m00 : Double
      m01 : Double
      m02 : Double
      m10 : Double
      m11 : Double
      m12 : Double
      m20 : Double
      m21 : Double
      m22 : Double
      tx : Double
      ty : Double
      tz : Double
    } derive(
    Debug    )

    Transform3::apply

    source
    fn Transform3::apply(self : Transform3, point : Point3) -> Point3

    Transform3::identity

    source
    fn Transform3::identity() -> Transform3

    Transform3::multiply

    source
    fn Transform3::multiply(self : Transform3, other : Transform3) -> Transform3

    Transform3::translation

    source
    fn Transform3::translation(x~ : Double, y~ : Double, z~ : Double) -> Transform3

    UnitAuditReport

    source
    pub(all) struct UnitAuditReport {
      rows : Array[UnitAuditRow]
      recognized_count : Int
      unknown_count : Int
      duplicate_kind_count : Int
      length_scale : Double
      area_scale : Double
      volume_scale : Double
    } derive(
    Debug    )

    Summary of the unit declarations and quantity conversions in a model.

    UnitAuditReport::headline

    source
    fn UnitAuditReport::headline(self : UnitAuditReport) -> String

    UnitAuditReport::is_consistent

    source
    fn UnitAuditReport::is_consistent(self : UnitAuditReport) -> Bool

    UnitAuditReport::row_count

    source
    fn UnitAuditReport::row_count(self : UnitAuditReport) -> Int

    UnitAuditReport::rows_for

    source
    fn UnitAuditReport::rows_for(self : UnitAuditReport, kind : UnitKind) -> Array[UnitAuditRow]

    UnitAuditReport::scale

    source
    fn UnitAuditReport::scale(self : UnitAuditReport, kind : UnitKind) -> Double

    UnitAuditReport::to_json

    source
    fn UnitAuditReport::to_json(self : UnitAuditReport) -> String

    UnitAuditReport::to_markdown

    source
    fn UnitAuditReport::to_markdown(self : UnitAuditReport) -> String

    UnitAuditRow

    source
    pub(all) struct UnitAuditRow {
      entity_id : Int
      kind : UnitKind
      name : String
      prefix : String?
      to_si : Double
      status : UnitAuditStatus
      message : String
    } derive(
    Debug    )

    A normalized unit declaration from the model.

    UnitAuditStatus

    source
    pub(all) enum UnitAuditStatus {
      Consistent
      Missing
      Duplicate
      Unknown
      Incompatible
    } derive(Eq, 
    Debug    )

    A warning emitted while checking a model's unit declarations.

    UnitConversion

    source
    pub(all) struct UnitConversion {
      kind : UnitKind
      value : Double
      converted : Double
      from_unit : String
      to_unit : String
      factor : Double
      recognized : Bool
    } derive(
    Debug    )

    One explicit conversion between two labels.

    UnitConversion::headline

    source
    fn UnitConversion::headline(self : UnitConversion) -> String

    UnitConversion::is_compatible

    source
    fn UnitConversion::is_compatible(self : UnitConversion) -> Bool

    UnitConversion::to_json

    source
    fn UnitConversion::to_json(self : UnitConversion) -> String

    UnitKind

    source
    pub(all) enum UnitKind {
      Length
      Area
      Volume
      Mass
      Time
      PlaneAngle
      UnknownUnit
    } derive(Eq, 
    Debug    )

    UnitScale

    source
    pub(all) struct UnitScale {
      kind : UnitKind
      name : String
      prefix : String?
      to_si : Double
    } derive(
    Debug    )

    UnitSemantic

    source
    pub(all) struct UnitSemantic {
      label : String
      normalized : String
      kind : UnitKind
      to_si : Double
      recognized : Bool
    } derive(
    Debug    )

    A unit label resolved to a dimensional kind and an SI scale.

    UnitSystem

    source
    pub(all) struct UnitSystem {
      units : Array[UnitScale]
    } derive(
    Debug    )

    UnitSystem::area_to_square_meters

    source
    fn UnitSystem::area_to_square_meters(self : UnitSystem, value : Double) -> Double

    UnitSystem::find

    source
    fn UnitSystem::find(self : UnitSystem, kind : UnitKind) -> UnitScale?

    UnitSystem::from_si

    source
    fn UnitSystem::from_si(self : UnitSystem, kind : UnitKind, value : Double) -> Double

    UnitSystem::length_to_meters

    source
    fn UnitSystem::length_to_meters(self : UnitSystem, value : Double) -> Double

    UnitSystem::meters_to_length

    source
    fn UnitSystem::meters_to_length(self : UnitSystem, value : Double) -> Double

    UnitSystem::scale

    source
    fn UnitSystem::scale(self : UnitSystem, kind : UnitKind) -> Double

    UnitSystem::to_si

    source
    fn UnitSystem::to_si(self : UnitSystem, kind : UnitKind, value : Double) -> Double

    UnitSystem::volume_to_cubic_meters

    source
    fn UnitSystem::volume_to_cubic_meters(self : UnitSystem, value : Double) -> Double

    ValidationReport

    source
    pub(all) struct ValidationReport {
      diagnostics : Array[Diagnostic]
      error_count : Int
      warning_count : Int
    } derive(
    Debug    )

    ValidationReport::diagnostic_codes

    source
    fn ValidationReport::diagnostic_codes(self : ValidationReport) -> Array[String]

    ValidationReport::format

    source
    fn ValidationReport::format(self : ValidationReport) -> String

    ValidationReport::is_valid

    source
    fn ValidationReport::is_valid(self : ValidationReport) -> Bool

    Value

    source
    pub(all) enum Value {
      Null
      Omitted
      Integer(Int64)
      Real(Double)
      String(String)
      Enumeration(String)
      Reference(Int)
      Binary(String)
      Typed(name~ : String, value~ : Value)
      List(Array[Value])
    } derive(Eq, 
    Debug    )

    A value in an IFC STEP entity argument list.

    Value::as_double

    source
    fn Value::as_double(self : Value) -> Double?

    Value::as_int

    source
    fn Value::as_int(self : Value) -> Int?

    Value::as_reference

    source
    fn Value::as_reference(self : Value) -> Int?

    Value::as_string

    source
    fn Value::as_string(self : Value) -> String?

    Value::is_null

    source
    fn Value::is_null(self : Value) -> Bool

    Value::to_step

    source
    fn Value::to_step(self : Value) -> String

    Value::to_step_lossless

    source
    fn Value::to_step_lossless(self : Value) -> String

    ValueStats

    source
    pub(all) struct ValueStats {
      node_count : Int
      maximum_depth : Int
      reference_count : Int
      string_count : Int
      number_count : Int
      list_count : Int
      omitted_count : Int
    } derive(
    Debug    )

    Aggregate shape information for a nested STEP value.

    ValueStats::is_reasonable

    source
    fn ValueStats::is_reasonable(self : ValueStats, maximum_depth : Int) -> Bool

    ValueStats::summary

    source
    fn ValueStats::summary(self : ValueStats) -> String

    Vector3

    source
    pub(all) struct Vector3 {
      x : Double
      y : Double
      z : Double
    } derive(
    Debug    )

    A three-dimensional vector used by mesh and placement analysis.

    Vector3::add

    source
    fn Vector3::add(self : Vector3, other : Vector3) -> Vector3

    Vector3::cross

    source
    fn Vector3::cross(self : Vector3, other : Vector3) -> Vector3

    Vector3::dot

    source
    fn Vector3::dot(self : Vector3, other : Vector3) -> Double

    Vector3::from_points

    source
    fn Vector3::from_points(start : Point3, end : Point3) -> Vector3

    Vector3::is_zero

    source
    fn Vector3::is_zero(self : Vector3) -> Bool

    Vector3::length

    source
    fn Vector3::length(self : Vector3) -> Double

    Vector3::new

    source
    fn Vector3::new(x~ : Double, y~ : Double, z~ : Double) -> Vector3

    Vector3::normalized

    source
    fn Vector3::normalized(self : Vector3) -> Vector3

    Vector3::scale

    source
    fn Vector3::scale(self : Vector3, factor : Double) -> Vector3

    Vector3::subtract

    source
    fn Vector3::subtract(self : Vector3, other : Vector3) -> Vector3

    Vector3::to_point

    source
    fn Vector3::to_point(self : Vector3) -> Point3

    WorkspaceSummary

    source
    pub(all) struct WorkspaceSummary {
      schema : String
      source_length : Int
      entity_count : Int
      product_count : Int
      indexed_products : Int
      graph_nodes : Int
      graph_edges : Int
      rule_errors : Int
      rule_warnings : Int
    } derive(
    Debug    )

    A compact health and capability view of a model workspace.

    WorkspaceSummary::headline

    source
    fn WorkspaceSummary::headline(self : WorkspaceSummary) -> String

    WorkspaceSummary::is_healthy

    source
    fn WorkspaceSummary::is_healthy(self : WorkspaceSummary) -> Bool

    WorkspaceSummary::to_json

    source
    fn WorkspaceSummary::to_json(self : WorkspaceSummary) -> String

    acceptance_checklist

    source
    fn acceptance_checklist(model : Model) -> Array[String]

    acceptance_checklist_markdown

    source
    fn acceptance_checklist_markdown(model : Model) -> String

    all_property_sets

    source
    fn all_property_sets(index : ModelIndex) -> Array[PropertySet] raise ParseError

    analyze_entity_graph

    source
    fn analyze_entity_graph(graph : EntityGraph) -> GraphAnalysis

    analyze_model

    source
    fn analyze_model(source : String, model : Model) -> ModelMetrics

    analyze_product_mesh

    source
    fn analyze_product_mesh(index : ModelIndex, product : Product) -> MeshAnalysis raise ParseError

    apply_patch

    source
    fn apply_patch(model : Model, patch : ModelPatch) -> Model raise EditError

    Apply a sequence of edits while preserving the model header and entity order.

    asset_manifest

    source
    fn asset_manifest(model : Model, options? : AssetManifestOptions) -> AssetManifest raise ParseError

    Build paths and resource statistics without serializing model geometry twice.

    asset_manifest_checksums

    source
    fn asset_manifest_checksums(manifest : AssetManifest) -> Map[String, Int]

    asset_manifest_entry_json

    source
    fn asset_manifest_entry_json(manifest : AssetManifest, path : String) -> String?

    asset_manifest_is_complete

    source
    fn asset_manifest_is_complete(manifest : AssetManifest) -> Bool

    asset_manifest_kind_histogram

    source
    fn asset_manifest_kind_histogram(manifest : AssetManifest) -> Map[String, Int]

    asset_manifest_paths

    source
    fn asset_manifest_paths(manifest : AssetManifest, kind : AssetKind) -> Array[String]

    asset_manifest_product_paths

    source
    fn asset_manifest_product_paths(manifest : AssetManifest, product_id : Int) -> Array[String]

    asset_manifest_summary

    source
    fn asset_manifest_summary(manifest : AssetManifest) -> Array[String]

    attribute

    source
    fn attribute(entity : Entity, index : Int) -> EntityAttribute?

    attribute_text

    source
    fn attribute_text(entity : Entity, index : Int) -> String?

    attributes

    source
    fn attributes(entity : Entity) -> Array[EntityAttribute]

    benchmark_case

    source
    fn benchmark_case(name : String, product_count : Int, iterations : Int) -> BenchmarkCase raise ParseError

    benchmark_cases

    source
    fn benchmark_cases() -> Array[BenchmarkCase] raise ParseError

    benchmark_fixture

    source
    fn benchmark_fixture(product_count : Int) -> String

    Deterministic STEP workload generator used by the local benchmark command. It creates real IFC wall products, placements, representations and extrusions instead of timing a synthetic string operation.

    benchmark_parse_case

    source
    fn benchmark_parse_case(case : BenchmarkCase) -> BenchmarkResult raise ParseError

    benchmark_pipeline_case

    source
    fn benchmark_pipeline_case(case : BenchmarkCase) -> BenchmarkResult raise ParseError

    benchmark_result_summary

    source
    fn benchmark_result_summary(result : BenchmarkResult) -> String

    benchmark_smoke

    source
    fn benchmark_smoke(source : String) -> BenchmarkResult raise ParseError

    benchmark_stream_case

    source
    fn benchmark_stream_case(case : BenchmarkCase) -> BenchmarkResult

    bounds_of_geometry

    source
    fn bounds_of_geometry(geometry : Geometry) -> BoundingBox

    bounds_of_mesh

    source
    fn bounds_of_mesh(mesh : Mesh) -> BoundingBox

    box_distance

    source
    fn box_distance(left : BoundingBox, right : BoundingBox) -> Double

    box_intersection

    source
    fn box_intersection(left : BoundingBox, right : BoundingBox) -> BoundingBox

    box_relation

    source
    fn box_relation(left : BoundingBox, right : BoundingBox, tolerance : Double) -> BoxRelation

    box_relation_text

    source
    fn box_relation_text(relation : BoxRelation) -> String

    build_scene

    source
    fn build_scene(model : Model) -> BimScene

    Build a renderer-neutral scene for WebBIM or other front ends.

    canonical_diff

    source
    fn canonical_diff(left : Model, right : Model) -> Array[String]

    canonical_entity_ids

    source
    fn canonical_entity_ids(model : Model) -> Array[Int]

    canonical_entity_names

    source
    fn canonical_entity_names(model : Model) -> Array[String]

    canonical_model

    source
    fn canonical_model(model : Model, deduplicate? : Bool) -> Model

    Produce a deterministic entity order while preserving all argument values.

    canonical_model_hash

    source
    fn canonical_model_hash(model : Model) -> Int

    canonical_model_without_duplicates

    source
    fn canonical_model_without_duplicates(model : Model) -> Model

    canonical_models_equal

    source
    fn canonical_models_equal(left : Model, right : Model) -> Bool

    canonical_record_text

    source
    fn canonical_record_text(entity : Entity) -> String

    canonical_records

    source
    fn canonical_records(model : Model) -> Array[String]

    canonical_step_stats

    source
    fn canonical_step_stats(source : String) -> CanonicalStepStats raise ParseError

    canonical_step_summary

    source
    fn canonical_step_summary(source : String) -> Array[String] raise ParseError

    canonicalize_step

    source
    fn canonicalize_step(source : String, deduplicate? : Bool) -> String raise ParseError

    capability_report

    source
    fn capability_report(model : Model) -> CapabilityReport

    catalog

    source
    fn catalog(source : String) -> ModelCatalog raise ParseError

    Construct a reusable catalog from an IFC STEP source.

    catalog_query

    source
    fn catalog_query(model : Model, query : CatalogQuery) -> Array[Product] raise ParseError

    clash_pairs_between

    source
    fn clash_pairs_between(spatial : SpatialIndex, left_ids : Array[Int], right_ids : Array[Int], options? : ClashOptions) -> Array[ClashPair]

    clash_report

    source
    fn clash_report(model : Model, options? : ClashOptions) -> ClashReport raise ParseError

    Construct a spatial index and run a clash report in one call.

    clash_report_summary

    source
    fn clash_report_summary(report : ClashReport) -> Array[String]

    clash_type_histogram

    source
    fn clash_type_histogram(report : ClashReport) -> Map[String, Int]

    classification_codes

    source
    fn classification_codes(index : ModelIndex, product : Product) -> Array[String]

    classification_name

    source
    fn classification_name(reference : ClassificationReference) -> String

    classification_references

    source
    fn classification_references(index : ModelIndex, product : Product) -> Array[ClassificationReference]

    Decode classification associations for one product.

    clearances_below

    source
    fn clearances_below(spatial : SpatialIndex, clearance : Double, options? : ClashOptions) -> Array[ClashPair]

    compare_revision

    source
    fn compare_revision(before : Model, after : Model) -> RevisionReport

    compare_step

    source
    fn compare_step(left : String, right : String) -> ModelDiff raise ParseError

    convert_unit_value

    source
    fn convert_unit_value(value : Double, from_unit : String, to_unit : String) -> UnitConversion

    coordinate_frames

    source
    fn coordinate_frames(model : Model) -> Array[CoordinateFrame]

    coordinate_report

    source
    fn coordinate_report(model : Model) -> CoordinateReport raise ParseError

    Collect placement frames and world bounds for coordinate-aware consumers.

    coordinate_transform_for

    source
    fn coordinate_transform_for(model : Model, placement_id : Int) -> Transform3?

    curve_bounds

    source
    fn curve_bounds(index : ModelIndex, id : Int) -> BoundingBox

    curve_length

    source
    fn curve_length(index : ModelIndex, id : Int, closed? : Bool) -> Double

    curve_points

    source
    fn curve_points(index : ModelIndex, id : Int) -> Array[Point3]

    curves_in_entity

    source
    fn curves_in_entity(index : ModelIndex, entity : Entity) -> Array[Int]

    default_asset_manifest_options

    source
    fn default_asset_manifest_options() -> AssetManifestOptions

    default_clash_options

    source
    fn default_clash_options() -> ClashOptions

    Defaults for coordination checks: report volumetric intersections but not merely touching faces.

    default_export_options

    source
    fn default_export_options() -> ExportOptions

    default_mesh_pipeline_options

    source
    fn default_mesh_pipeline_options() -> MeshPipelineOptions

    default_quality_policy

    source
    fn default_quality_policy() -> QualityPolicy

    default_scene_camera

    source
    fn default_scene_camera() -> SceneCamera

    Camera defaults are intentionally conservative for building-scale models.

    default_scene_query_options

    source
    fn default_scene_query_options() -> SceneQueryOptions

    default_schema_profile

    source
    fn default_schema_profile() -> SchemaProfile

    default_section_options

    source
    fn default_section_options() -> SectionOptions

    default_spatial_index_options

    source
    fn default_spatial_index_options() -> SpatialIndexOptions

    Return conservative construction defaults for a building-scale model.

    default_stream_filter

    source
    fn default_stream_filter() -> StreamFilter

    default_takeoff_options

    source
    fn default_takeoff_options() -> TakeoffOptions

    delivery_change_name

    source
    fn delivery_change_name(change : DeliveryChange) -> String

    delivery_model_rules

    source
    fn delivery_model_rules() -> Array[ModelRule]

    delivery_rule_report

    source
    fn delivery_rule_report(model : Model) -> RuleReport raise ParseError

    dependency_layers

    source
    fn dependency_layers(index : ModelIndex, roots : Array[Int]) -> Array[Array[Int]]

    detect_clashes

    source
    fn detect_clashes(spatial : SpatialIndex, options? : ClashOptions) -> ClashReport

    Detect product-level clashes using the spatial grid as the broad phase.

    diff_models

    source
    fn diff_models(left : Model, right : Model) -> ModelDiff

    duplicate_entity_ids

    source
    fn duplicate_entity_ids(model : Model) -> Array[Int]

    duplicate_model_guids

    source
    fn duplicate_model_guids(model : Model) -> Array[String]

    entities_referencing

    source
    fn entities_referencing(index : ModelIndex, id : Int) -> Array[Entity]

    entity_family

    source
    fn entity_family(entity : Entity) -> String

    entity_graph

    source
    fn entity_graph(model : Model) -> EntityGraph

    entity_ids_in_range

    source
    fn entity_ids_in_range(model : Model, first : Int, last : Int) -> Array[Int]

    entity_names_case_insensitive

    source
    fn entity_names_case_insensitive(model : Model, name : String) -> Array[String]

    entity_range

    source
    fn entity_range(model : Model) -> EntityRange

    entity_references

    source
    fn entity_references(entity : Entity) -> Array[Int]

    entity_shape_signature

    source
    fn entity_shape_signature(entity : Entity) -> String

    entity_to_json

    source
    fn entity_to_json(entity : Entity) -> String

    entity_value

    source
    fn entity_value(entity : Entity, index : Int) -> Value?

    estimated_volume

    source
    fn estimated_volume(geometry : Geometry) -> Double?

    evaluate_rules

    source
    fn evaluate_rules(model : Model, rules : Array[ModelRule]) -> RuleReport raise ParseError

    Apply custom rules plus model-wide integrity rules without changing the model.

    execute_query_plan

    source
    fn execute_query_plan(model : Model, plan : ProductQueryPlan) -> ProductQueryPage raise ParseError

    Execute a reusable product query plan against a parsed model.

    export_bundle

    source
    fn export_bundle(source : String) -> ExportBundle raise ParseError

    export_format_from_name

    source
    fn export_format_from_name(name : String) -> ExportFormat?

    export_model_asset

    source
    fn export_model_asset(model : Model, options : ExportOptions) -> ExportedAsset raise ParseError

    export_preview

    source
    fn export_preview(asset : ExportedAsset, maximum_lines : Int) -> String

    export_step_asset

    source
    fn export_step_asset(source : String, options : ExportOptions) -> ExportedAsset raise ParseError

    export_supported_formats

    source
    fn export_supported_formats() -> Array[String]

    extract_products

    source
    fn extract_products(index : ModelIndex) -> Array[Product]

    Extract common IFC products while preserving the original generic entities.

    extract_property_set

    source
    fn extract_property_set(index : ModelIndex, id : Int) -> PropertySet raise ParseError

    Decode one IfcPropertySet and its IfcPropertySingleValue members.

    family_histogram

    source
    fn family_histogram(index : ModelIndex) -> Map[String, Int]

    flatten_spatial

    source
    fn flatten_spatial(root : SpatialNode) -> Array[SpatialNode]

    formula_quantity

    source
    fn formula_quantity(model : Model, product_id : Int, formula : QuantityFormula) -> QuantityValue? raise ParseError

    formula_takeoff

    source
    fn formula_takeoff(model : Model, formulas : Array[QuantityFormula]) -> FormulaTakeoff raise ParseError

    Evaluate application-specific quantity formulas against IFC properties.

    formula_takeoff_for_kind

    source
    fn formula_takeoff_for_kind(model : Model, kind : ProductKind, formulas : Array[QuantityFormula]) -> FormulaTakeoff raise ParseError

    geometries_for_product

    source
    fn geometries_for_product(index : ModelIndex, product : Product) -> Array[Geometry]

    geometry

    source
    fn geometry(index : ModelIndex, id : Int) -> Geometry raise ParseError

    geometry_entities

    source
    fn geometry_entities(index : ModelIndex) -> Array[Entity]

    geometry_for_product

    source
    fn geometry_for_product(index : ModelIndex, product : Product) -> Geometry?

    geometry_inventory

    source
    fn geometry_inventory(model : Model) -> GeometryInventory raise ParseError

    Build a geometry inventory with one row per product.

    geometry_inventory_summary

    source
    fn geometry_inventory_summary(inventory : GeometryInventory) -> Array[String]

    geometry_kind_counts

    source
    fn geometry_kind_counts(index : ModelIndex) -> Map[String, Int]

    Count geometry adapters by their stable output kind name.

    geometry_report_for_product

    source
    fn geometry_report_for_product(model : Model, product_id : Int) -> ProductGeometryReport? raise ParseError

    geometry_to_json

    source
    fn geometry_to_json(geometry : Geometry) -> String

    graph_analysis

    source
    fn graph_analysis(model : Model) -> GraphAnalysis

    graph_component_for

    source
    fn graph_component_for(model : Model, id : Int) -> GraphComponent?

    graph_cycles

    source
    fn graph_cycles(model : Model) -> Array[Array[Int]]

    graph_degrees

    source
    fn graph_degrees(model : Model) -> Array[GraphDegree]

    graph_dependents

    source
    fn graph_dependents(model : Model, targets : Array[Int]) -> Array[Int]

    graph_path

    source
    fn graph_path(model : Model, start : Int, goal : Int) -> GraphPath?

    graph_reachable

    source
    fn graph_reachable(model : Model, roots : Array[Int]) -> Array[Int]

    graph_stats

    source
    fn graph_stats(index : ModelIndex) -> GraphStats

    graph_topological_order

    source
    fn graph_topological_order(model : Model) -> Array[Int]

    guid_fingerprint_map

    source
    fn guid_fingerprint_map(model : Model) -> Map[String, Int]

    guid_quality_score

    source
    fn guid_quality_score(model : Model) -> Int

    guid_quality_summary

    source
    fn guid_quality_summary(model : Model) -> Array[String]

    ifc_guid_alphabet

    source
    fn ifc_guid_alphabet() -> String

    ifc_guid_fingerprint

    source
    fn ifc_guid_fingerprint(value : String) -> String

    ifc_guid_from_product

    source
    fn ifc_guid_from_product(model : Model, product_id : Int) -> GuidReport?

    ifc_guid_is_valid

    source
    fn ifc_guid_is_valid(value : String) -> Bool

    inspect_step

    source
    fn inspect_step(source : String) -> Inspection raise ParseError

    Parse once and prepare the high-level data used by inspectors and CI tools.

    invalid_model_guids

    source
    fn invalid_model_guids(model : Model) -> Array[GuidReport]

    inverse_transform

    source
    fn inverse_transform(transform : Transform3) -> Transform3?

    Invert a general affine transform, including non-uniform scaling.

    is_geometry_entity

    source
    fn is_geometry_entity(entity : Entity) -> Bool

    is_property_entity

    source
    fn is_property_entity(entity : Entity) -> Bool

    is_relationship

    source
    fn is_relationship(entity : Entity) -> Bool

    limit_mesh_triangles

    source
    fn limit_mesh_triangles(mesh : Mesh, maximum : Int) -> Mesh

    local_to_world

    source
    fn local_to_world(transform : Transform3, point : Point3) -> Point3

    manifest_product_names

    source
    fn manifest_product_names(manifest : RenderManifest) -> Array[String]

    material_assignments

    source
    fn material_assignments(index : ModelIndex, product : Product) -> Array[MaterialAssignment]

    Decode material associations for one product.

    material_inventory

    source
    fn material_inventory(model : Model) -> MaterialInventory

    Build an inventory used by material schedules and specification checks.

    material_layers_for_product

    source
    fn material_layers_for_product(index : ModelIndex, product : Product) -> Array[MaterialLayer]

    material_report_lines

    source
    fn material_report_lines(inventory : MaterialInventory) -> Array[String]

    material_thickness

    source
    fn material_thickness(index : ModelIndex, product : Product) -> Double

    materials_for_product

    source
    fn materials_for_product(index : ModelIndex, product : Product) -> Array[String]

    merge_bounds

    source
    fn merge_bounds(left : BoundingBox, right : BoundingBox) -> BoundingBox

    merge_meshes

    source
    fn merge_meshes(meshes : Array[Mesh]) -> Mesh

    mesh_area

    source
    fn mesh_area(mesh : Mesh) -> Double

    mesh_area_by_normal

    source
    fn mesh_area_by_normal(mesh : Mesh, axis : Vector3, tolerance? : Double) -> Double

    mesh_aspect_ratio

    source
    fn mesh_aspect_ratio(mesh : Mesh) -> Double

    mesh_bounds_json

    source
    fn mesh_bounds_json(mesh : Mesh) -> String

    mesh_centered

    source
    fn mesh_centered(mesh : Mesh) -> Mesh

    mesh_centroid

    source
    fn mesh_centroid(mesh : Mesh) -> Point3

    mesh_compact

    source
    fn mesh_compact(mesh : Mesh) -> Mesh

    mesh_diagonal

    source
    fn mesh_diagonal(mesh : Mesh) -> Double

    mesh_edge_length_statistics

    source
    fn mesh_edge_length_statistics(mesh : Mesh) -> (Double, Double, Double)

    mesh_flip_winding

    source
    fn mesh_flip_winding(mesh : Mesh) -> Mesh

    mesh_for_geometry

    source
    fn mesh_for_geometry(index : ModelIndex, id : Int) -> Mesh raise ParseError

    mesh_for_geometry_advanced

    source
    fn mesh_for_geometry_advanced(index : ModelIndex, geometry : Geometry) -> Mesh raise ParseError

    Build an explicit mesh for the currently supported solid summaries.

    mesh_for_product_advanced

    source
    fn mesh_for_product_advanced(index : ModelIndex, product : Product) -> Mesh raise ParseError

    mesh_for_product_pipeline

    source
    fn mesh_for_product_pipeline(index : ModelIndex, product : Product, options? : MeshPipelineOptions) -> MeshPipelineResult raise ParseError

    mesh_horizontal_area

    source
    fn mesh_horizontal_area(mesh : Mesh) -> Double

    mesh_is_renderable

    source
    fn mesh_is_renderable(mesh : Mesh) -> Bool

    mesh_lod

    source
    fn mesh_lod(mesh : Mesh, target_triangles : Int) -> Mesh

    Generate a coarse level of detail by welding vertices into a deterministic grid.

    mesh_lod_result

    source
    fn mesh_lod_result(mesh : Mesh, target_triangles : Int, options? : MeshPipelineOptions) -> MeshPipelineResult

    mesh_normal_histogram

    source
    fn mesh_normal_histogram(mesh : Mesh, bins : Int) -> Map[String, Int]

    mesh_normals

    source
    fn mesh_normals(mesh : Mesh) -> Array[Vector3]

    mesh_pipeline

    source
    fn mesh_pipeline(mesh : Mesh, options? : MeshPipelineOptions) -> MeshPipelineResult

    mesh_pipeline_summary

    source
    fn mesh_pipeline_summary(result : MeshPipelineResult) -> Array[String]

    mesh_point_count

    source
    fn mesh_point_count(mesh : Mesh) -> Int

    mesh_quality_histogram

    source
    fn mesh_quality_histogram(mesh : Mesh, bins : Int) -> Map[Int, Int]

    mesh_stats

    source
    fn mesh_stats(mesh : Mesh) -> MeshStats

    Calculate topology quality and geometric measurements for a mesh.

    mesh_to_json_stats

    source
    fn mesh_to_json_stats(analysis : MeshAnalysis) -> String

    mesh_transform_scale

    source
    fn mesh_transform_scale(mesh : Mesh, scale : Double) -> Mesh

    mesh_triangle_count

    source
    fn mesh_triangle_count(mesh : Mesh) -> Int

    mesh_triangle_quality

    source
    fn mesh_triangle_quality(mesh : Mesh, triangle_index : Int) -> Double?

    mesh_unique_triangles

    source
    fn mesh_unique_triangles(mesh : Mesh) -> Mesh

    mesh_validation

    source
    fn mesh_validation(mesh : Mesh) -> MeshValidation

    mesh_vertical_area

    source
    fn mesh_vertical_area(mesh : Mesh) -> Double

    mesh_volume

    source
    fn mesh_volume(mesh : Mesh) -> Double

    mesh_world_centroid

    source
    fn mesh_world_centroid(index : ModelIndex, product : Product) -> Point3 raise ParseError

    metrics_from_step

    source
    fn metrics_from_step(source : String) -> ModelMetrics raise ParseError

    minimal_fixture

    source
    fn minimal_fixture() -> String

    A compact, valid IFC4 fixture used by examples and regression tests.

    model_bounds

    source
    fn model_bounds(index : ModelIndex, products : Array[Product]) -> BoundingBox

    model_complexity_score

    source
    fn model_complexity_score(model : Model) -> Int

    A compact, deterministic quality view for CI logs and acceptance reports.

    model_delivery_asset_breakdown

    source
    fn model_delivery_asset_breakdown(report : ModelDeliveryReport) -> Array[String]

    model_delivery_gate

    source
    fn model_delivery_gate(source : String) -> Bool raise ParseError

    model_delivery_gate_with_policy

    source
    fn model_delivery_gate_with_policy(source : String, policy : QualityPolicy, options : AssetManifestOptions) -> Bool raise ParseError

    model_delivery_report

    source
    fn model_delivery_report(source : String) -> ModelDeliveryReport raise ParseError

    Build the profile, quality score, cache manifest and canonical STEP statistics together.

    model_delivery_report_with_policy

    source
    fn model_delivery_report_with_policy(source : String, policy : QualityPolicy, options : AssetManifestOptions) -> ModelDeliveryReport raise ParseError

    model_delivery_summary

    source
    fn model_delivery_summary(source : String) -> Array[String] raise ParseError

    model_geometry_coverage

    source
    fn model_geometry_coverage(model : Model) -> Double

    model_guid_reports

    source
    fn model_guid_reports(model : Model) -> Array[GuidReport]

    model_index_json

    source
    fn model_index_json(model : Model) -> String

    model_orphan_reference_ids

    source
    fn model_orphan_reference_ids(model : Model) -> Array[Int]

    model_profile

    source
    fn model_profile(model : Model) -> ModelProfile

    Build a reusable semantic profile without decoding every geometry mesh.

    model_profile_family_histogram

    source
    fn model_profile_family_histogram(model : Model) -> Map[String, Int]

    model_profile_summary

    source
    fn model_profile_summary(model : Model) -> Array[String]

    model_profile_type_histogram

    source
    fn model_profile_type_histogram(model : Model) -> Map[String, Int]

    model_property_coverage

    source
    fn model_property_coverage(model : Model) -> Double

    model_quality_audit

    source
    fn model_quality_audit(model : Model, policy? : QualityPolicy) -> ModelQualityReport raise ParseError

    Run the complete quality audit with deterministic finding order.

    model_quality_errors

    source
    fn model_quality_errors(model : Model) -> Array[QualityFinding] raise ParseError

    model_quality_grade

    source
    fn model_quality_grade(model : Model) -> String

    model_quality_json

    source
    fn model_quality_json(model : Model) -> String

    model_quality_lines

    source
    fn model_quality_lines(model : Model) -> Array[String]

    model_quality_report

    source
    fn model_quality_report(model : Model) -> String

    model_quality_summary

    source
    fn model_quality_summary(model : Model) -> Array[String] raise ParseError

    model_quality_warnings

    source
    fn model_quality_warnings(model : Model) -> Array[QualityFinding] raise ParseError

    model_reference_targets

    source
    fn model_reference_targets(model : Model) -> Array[Int]

    model_shape_signatures

    source
    fn model_shape_signatures(model : Model) -> Array[String]

    model_slice

    source
    fn model_slice(model : Model, root_ids : Array[Int], include_dependencies? : Bool) -> ModelSlice

    Create a dependency-closed model slice rooted at raw entity IDs.

    model_slice_for_box

    source
    fn model_slice_for_box(model : Model, bounds : BoundingBox, include_dependencies? : Bool) -> ModelSlice raise ParseError

    model_slice_for_products

    source
    fn model_slice_for_products(model : Model, product_ids : Array[Int], include_dependencies? : Bool) -> ModelSlice

    model_slice_for_query

    source
    fn model_slice_for_query(model : Model, plan : ProductQueryPlan, include_dependencies? : Bool) -> ModelSlice raise ParseError

    model_snapshot

    source
    fn model_snapshot(model : Model) -> ModelSnapshot

    model_spatial_coverage

    source
    fn model_spatial_coverage(model : Model) -> Bool

    model_summary_json

    source
    fn model_summary_json(model : Model) -> String raise ParseError

    model_to_json

    source
    fn model_to_json(model : Model) -> String raise ParseError

    model_value_stats

    source
    fn model_value_stats(model : Model) -> ValueStats

    model_with_entity

    source
    fn model_with_entity(model : Model, entity : Entity) -> Model raise EditError

    model_without_entity

    source
    fn model_without_entity(model : Model, id : Int) -> Model raise EditError

    model_world_bounds

    source
    fn model_world_bounds(model : Model) -> BoundingBox raise ParseError

    normalize_ifc_guid

    source
    fn normalize_ifc_guid(value : String) -> String

    normalize_quantity

    source
    fn normalize_quantity(product_id : Int, quantity : QuantityValue, target_unit~ : String?) -> NormalizedQuantity

    normalize_step_newlines

    source
    fn normalize_step_newlines(source : String) -> String

    normalize_takeoff

    source
    fn normalize_takeoff(report : TakeoffReport, target_length_unit? : String, target_area_unit? : String, target_volume_unit? : String) -> Array[NormalizedQuantity]

    normalized_quantities_for_product

    source
    fn normalized_quantities_for_product(rows : Array[NormalizedQuantity], product_id : Int) -> Array[NormalizedQuantity]

    normalized_quantities_to_csv

    source
    fn normalized_quantities_to_csv(rows : Array[NormalizedQuantity]) -> String

    normalized_quantities_to_json

    source
    fn normalized_quantities_to_json(rows : Array[NormalizedQuantity]) -> String

    normalized_quantities_total

    source
    fn normalized_quantities_total(rows : Array[NormalizedQuantity], kind : QuantityKind) -> Double

    normalized_quantities_unrecognized

    source
    fn normalized_quantities_unrecognized(rows : Array[NormalizedQuantity]) -> Array[NormalizedQuantity]

    normalized_quantity_summary

    source
    fn normalized_quantity_summary(rows : Array[NormalizedQuantity]) -> Array[String]

    normalized_quantity_unit_histogram

    source
    fn normalized_quantity_unit_histogram(rows : Array[NormalizedQuantity]) -> Map[String, Int]

    parse

    source
    fn parse(source : String) -> Model raise ParseError

    Parse an IFC2x3 or IFC4 ISO 10303-21 physical file.

    parse_many

    source
    fn parse_many(source : String) -> Array[Model] raise ParseError

    parse_step_record

    source
    fn parse_step_record(record : StepRecord) -> Entity raise ParseError

    Parse one scanned record through the normal lossless parser.

    patch_between

    source
    fn patch_between(left : Model, right : Model) -> ModelPatch raise EditError

    Convert a structural diff into a replayable patch.

    patch_descriptions

    source
    fn patch_descriptions(patch : ModelPatch) -> Array[String]

    patch_round_trip

    source
    fn patch_round_trip(before : Model, after : Model) -> Bool raise EditError

    patch_summary

    source
    fn patch_summary(patch : ModelPatch) -> String

    placement_transform

    source
    fn placement_transform(index : ModelIndex, id : Int) -> Transform3?

    polyline_length

    source
    fn polyline_length(points : Array[Point3], closed? : Bool) -> Double

    process_mesh

    source
    fn process_mesh(mesh : Mesh, options? : MeshPipelineOptions) -> MeshPipelineResult

    Apply deterministic cleanup, welding, orientation and optional LOD limits.

    product_by_id

    source
    fn product_by_id(products : Array[Product], id : Int) -> Product?

    product_json_by_id

    source
    fn product_json_by_id(model : Model, id : Int) -> String?

    product_kind_counts

    source
    fn product_kind_counts(products : Array[Product]) -> Map[String, Int]

    Count products by their normalized IFC family name.

    product_to_json

    source
    fn product_to_json(product : Product) -> String

    product_transform

    source
    fn product_transform(index : ModelIndex, product : Product) -> Transform3

    products_in_container

    source
    fn products_in_container(index : ModelIndex, id : Int) -> Array[Product]

    products_json_named

    source
    fn products_json_named(model : Model, fragment : String) -> String

    products_named

    source
    fn products_named(index : ModelIndex, fragment : String) -> Array[Product]

    products_of_kind

    source
    fn products_of_kind(products : Array[Product], kind : ProductKind) -> Array[Product]

    products_to_csv

    source
    fn products_to_csv(products : Array[Product]) -> String

    property_coverage_report

    source
    fn property_coverage_report(model : Model, names : Array[String]) -> Array[String] raise ParseError

    property_name_counts

    source
    fn property_name_counts(property_sets : Array[PropertySet]) -> Map[String, Int]

    property_named

    source
    fn property_named(property_sets : Array[PropertySet], name : String) -> Property?

    property_names

    source
    fn property_names(property_set : PropertySet) -> Array[String]

    property_number

    source
    fn property_number(property_sets : Array[PropertySet], name : String) -> Double?

    property_set_to_json

    source
    fn property_set_to_json(property_set : PropertySet) -> String

    property_sets_for_product

    source
    fn property_sets_for_product(index : ModelIndex, product : Product) -> Array[PropertySet] raise ParseError

    property_sets_to_csv

    source
    fn property_sets_to_csv(property_sets : Array[PropertySet]) -> String

    property_string

    source
    fn property_string(property_sets : Array[PropertySet], name : String) -> String?

    property_table

    source
    fn property_table(model : Model, names? : Array[String]) -> PropertyTable raise ParseError

    Flatten selected IFC properties into a deterministic table.

    property_table_for_kind

    source
    fn property_table_for_kind(model : Model, kind : ProductKind, names? : Array[String]) -> PropertyTable raise ParseError

    property_table_for_products

    source
    fn property_table_for_products(model : Model, products : Array[Product], names? : Array[String]) -> PropertyTable raise ParseError

    property_to_json

    source
    fn property_to_json(property : Property) -> String

    property_values

    source
    fn property_values(model : Model, name : String) -> Map[String, Int] raise ParseError

    quantity_kind_dimension

    source
    fn quantity_kind_dimension(kind : QuantityKind) -> UnitKind

    quantity_kind_name

    source
    fn quantity_kind_name(kind : QuantityKind) -> String

    quantity_kind_unit

    source
    fn quantity_kind_unit(kind : QuantityKind) -> String

    quantity_note

    source
    fn quantity_note(product_id : Int, kind : QuantityKind, message : String, severity? : DiagnosticSeverity) -> QuantityNote

    quantity_takeoff

    source
    fn quantity_takeoff(model : Model, options? : TakeoffOptions) -> TakeoffReport raise ParseError

    Calculate geometry and property quantities for all products in a model.

    quantity_value_in_si

    source
    fn quantity_value_in_si(units : UnitSystem, value : QuantityValue) -> Double

    query_by_name

    source
    fn query_by_name(model : Model, name : String) -> Array[Product] raise ParseError

    query_geometry

    source
    fn query_geometry(model : Model, kind : GeometryKind) -> Array[Product] raise ParseError

    query_kind

    source
    fn query_kind(model : Model, kind : ProductKind) -> Array[Product] raise ParseError

    query_plan

    source
    fn query_plan(model : Model) -> ProductQueryPlan

    query_plan_report

    source
    fn query_plan_report(model : Model, plan : ProductQueryPlan) -> Array[String] raise ParseError

    query_products

    source
    fn query_products(index : ModelIndex, query : ProductQuery) -> Array[Product]

    query_property

    source
    fn query_property(model : Model, name : String, value : String) -> Array[Product] raise ParseError

    reachable_entities

    source
    fn reachable_entities(index : ModelIndex, roots : Array[Int]) -> Array[Entity]

    Follow generic STEP references without imposing an IFC schema.

    record_length_histogram

    source
    fn record_length_histogram(source : String) -> Map[Int, Int]

    records_in_range

    source
    fn records_in_range(source : String, start_offset : Int, end_offset : Int) -> Array[StepRecord]

    records_named

    source
    fn records_named(source : String, name : String) -> Array[StepRecord]

    records_named_safe

    source
    fn records_named_safe(source : String, name : String) -> Array[StepRecord]

    references

    source
    fn references(value : Value) -> Array[Int]

    relation_ancestors

    source
    fn relation_ancestors(model : Model, id : Int) -> Array[Int]

    relation_descendants

    source
    fn relation_descendants(model : Model, id : Int) -> Array[Int]

    relation_histogram

    source
    fn relation_histogram(model : Model) -> Map[String, Int]

    relation_index

    source
    fn relation_index(model : Model) -> RelationIndex

    fn relation_links_for_product(model : Model, product_id : Int) -> Array[RelationLink]

    remove_degenerate_triangles

    source
    fn remove_degenerate_triangles(mesh : Mesh, tolerance : Double) -> Mesh

    render_manifest

    source
    fn render_manifest(model : Model) -> RenderManifest raise ParseError

    resample_polyline

    source
    fn resample_polyline(points : Array[Point3], maximum_segment : Double) -> Array[Point3]

    reverse_patch

    source
    fn reverse_patch(before : Model, patch : ModelPatch) -> ModelPatch raise EditError

    Build a patch that reverts patch against the original model.

    revision_affected_entity_ids

    source
    fn revision_affected_entity_ids(before : Model, after : Model) -> Array[Int]

    revision_affected_products

    source
    fn revision_affected_products(before : Model, after : Model) -> Array[Int]

    revision_changed_entity_ids

    source
    fn revision_changed_entity_ids(before : Model, after : Model) -> Array[Int]

    revision_delivery

    source
    fn revision_delivery(before : Model, after : Model, options? : AssetManifestOptions) -> RevisionDelivery raise ParseError

    Compare two generated manifests and classify every cache path.

    revision_delivery_invalidated_paths

    source
    fn revision_delivery_invalidated_paths(before : Model, after : Model) -> Array[String] raise ParseError

    revision_delivery_paths

    source
    fn revision_delivery_paths(before : Model, after : Model) -> Array[String] raise ParseError

    revision_delivery_summary

    source
    fn revision_delivery_summary(before : Model, after : Model) -> Array[String] raise ParseError

    revision_impact

    source
    fn revision_impact(before : Model, after : Model) -> RevisionImpact

    Calculate dependency-aware impact for a model revision.

    revision_report

    source
    fn revision_report(before : Model, after : Model) -> RevisionReport

    Combine an entity diff with product-level and spatial dependency impact.

    revision_risk_level

    source
    fn revision_risk_level(before : Model, after : Model) -> String

    round_trip

    source
    fn round_trip(source : String) -> Model raise ParseError

    rule_names

    source
    fn rule_names(rules : Array[ModelRule]) -> Array[String]

    rule_report

    source
    fn rule_report(model : Model, rules : Array[ModelRule]) -> RuleReport raise ParseError

    rule_violation_codes

    source
    fn rule_violation_codes(report : RuleReport) -> Map[String, Int]

    run_benchmark_report

    source
    fn run_benchmark_report() -> BenchmarkReport raise ParseError

    scan_step_records

    source
    fn scan_step_records(source : String) -> Array[StepRecord]

    Scan entity records without constructing Value trees.

    scene_partition

    source
    fn scene_partition(model : Model, chunk_size? : Int) -> ScenePartition raise ParseError

    Partition the indexed product space into bounded render chunks.

    scene_partition_bounds

    source
    fn scene_partition_bounds(partition : ScenePartition, indices : Array[Int]) -> BoundingBox

    scene_partition_for_products

    source
    fn scene_partition_for_products(spatial : SpatialIndex, product_ids : Array[Int], chunk_size? : Int) -> ScenePartition

    scene_partition_product_chunk_counts

    source
    fn scene_partition_product_chunk_counts(partition : ScenePartition) -> Map[Int, Int]

    scene_pick

    source
    fn scene_pick(index : SpatialIndex, origin : Point3, direction : Vector3) -> ScenePick

    Pick the nearest indexed product along a normalized or non-normalized ray.

    scene_selection

    source
    fn scene_selection(model : Model, camera : SceneCamera, options? : SceneQueryOptions) -> SceneSelection raise ParseError

    scene_selection_distance_range

    source
    fn scene_selection_distance_range(selection : SceneSelection) -> (Double, Double)

    scene_selection_ids_json

    source
    fn scene_selection_ids_json(selection : SceneSelection) -> String

    scene_selection_lod_json

    source
    fn scene_selection_lod_json(selection : SceneSelection) -> String

    scene_selection_type_histogram

    source
    fn scene_selection_type_histogram(selection : SceneSelection) -> Map[String, Int]

    schedule_area_by_name

    source
    fn schedule_area_by_name(schedule : SpatialSchedule, name : String) -> Double

    schedule_product_count_by_type

    source
    fn schedule_product_count_by_type(schedule : SpatialSchedule, ifc_type : String) -> Int

    schema_compare_profiles

    source
    fn schema_compare_profiles(left : SchemaProfile, right : SchemaProfile) -> Array[String]

    schema_entity_is_known

    source
    fn schema_entity_is_known(profile : SchemaProfile, entity_name : String) -> Bool

    schema_family_histogram

    source
    fn schema_family_histogram(profile : SchemaProfile) -> Map[String, Int]

    schema_issues_by_code

    source
    fn schema_issues_by_code(report : SchemaReport, code : String) -> Array[SchemaIssue]

    schema_profile

    source
    fn schema_profile(version : SchemaVersion) -> SchemaProfile

    schema_profile_summary

    source
    fn schema_profile_summary(profile : SchemaProfile) -> String

    schema_required_reference_count

    source
    fn schema_required_reference_count(profile : SchemaProfile) -> Int

    schema_rule_names

    source
    fn schema_rule_names(profile : SchemaProfile) -> Array[String]

    schema_validate_entity

    source
    fn schema_validate_entity(profile : SchemaProfile, model : Model, entity_id : Int) -> Array[SchemaIssue]

    schema_version

    source
    fn schema_version(model : Model) -> SchemaVersion

    fn search(model : Model, field : SearchField, term : String) -> Array[SearchHit] raise ParseError

    search_entities

    source
    fn search_entities(index : ModelIndex, term : String) -> Array[SearchHit]

    search_first_product

    source
    fn search_first_product(index : ModelIndex, field : SearchField, term : String) -> Product?

    search_products

    source
    fn search_products(index : ModelIndex, field : SearchField, term : String) -> Array[SearchHit]

    search_properties

    source
    fn search_properties(index : ModelIndex, term : String) -> Array[SearchHit] raise ParseError

    section_mesh

    source
    fn section_mesh(product_id : Int, mesh : Mesh, plane : SectionPlane, options? : SectionOptions) -> Array[SectionSegment]

    Intersect a standalone mesh, retaining the source triangle index.

    section_model

    source
    fn section_model(model : Model, plane : SectionPlane, options? : SectionOptions) -> SectionResult raise ParseError

    Extract a section across all products with supported mesh geometry.

    section_result_bounds_for

    source
    fn section_result_bounds_for(result : SectionResult, product_id : Int) -> BoundingBox

    section_result_long_segments

    source
    fn section_result_long_segments(result : SectionResult, minimum_length : Double) -> Array[SectionSegment]

    section_result_product_histogram

    source
    fn section_result_product_histogram(result : SectionResult) -> Map[Int, Int]

    section_result_summary

    source
    fn section_result_summary(result : SectionResult) -> Array[String]

    serialize

    source
    fn serialize(model : Model) -> String

    slice_changed_entities

    source
    fn slice_changed_entities(before : Model, after : Model) -> ModelSlice

    snapshot_diff

    source
    fn snapshot_diff(left : ModelSnapshot, right : ModelSnapshot) -> Array[String]

    source_boundary_diagnostics

    source
    fn source_boundary_diagnostics(source : String) -> Array[String]

    source_entity_names

    source
    fn source_entity_names(source : String) -> Array[String]

    source_health

    source
    fn source_health(source : String) -> SourceHealth

    source_health_grade

    source
    fn source_health_grade(source : String) -> String

    source_health_score

    source
    fn source_health_score(source : String) -> Int

    source_is_safe_for_full_parse

    source
    fn source_is_safe_for_full_parse(source : String, maximum_chars : Int, maximum_records : Int) -> Bool

    source_line

    source
    fn source_line(source : String, line : Int) -> SourceWindow?

    source_line_count

    source
    fn source_line_count(source : String) -> Int

    source_range

    source
    fn source_range(source : String) -> EntityRange

    source_record_at

    source
    fn source_record_at(source : String, index : Int) -> StepRecord?

    source_records_cover_document

    source
    fn source_records_cover_document(source : String) -> Bool

    source_reference_density

    source
    fn source_reference_density(source : String) -> Double

    source_window

    source
    fn source_window(source : String, start : Int, end : Int) -> SourceWindow

    source_window_for_record

    source
    fn source_window_for_record(source : String, record : StepRecord) -> SourceWindow

    space_adjacency

    source
    fn space_adjacency(model : Model) -> SpaceAdjacencyGraph raise ParseError

    space_neighbors

    source
    fn space_neighbors(model : Model, space_id : Int) -> Array[Int] raise ParseError

    space_path

    source
    fn space_path(model : Model, start : Int, goal : Int) -> Array[Int]? raise ParseError

    spatial_depth

    source
    fn spatial_depth(root : SpatialNode) -> Int

    spatial_depth_histogram

    source
    fn spatial_depth_histogram(root : SpatialNode) -> Map[Int, Int]

    spatial_duplicate_product_ids

    source
    fn spatial_duplicate_product_ids(root : SpatialNode) -> Array[Int]

    spatial_find

    source
    fn spatial_find(root : SpatialNode, id : Int) -> SpatialNode?

    spatial_find_named

    source
    fn spatial_find_named(root : SpatialNode, fragment : String) -> Array[SpatialNode]

    spatial_find_product

    source
    fn spatial_find_product(root : SpatialNode, product_id : Int) -> SpatialNode?

    spatial_index

    source
    fn spatial_index(model : Model, options? : SpatialIndexOptions) -> SpatialIndex raise ParseError

    spatial_leaf_nodes

    source
    fn spatial_leaf_nodes(root : SpatialNode) -> Array[SpatialNode]

    spatial_metrics

    source
    fn spatial_metrics(index : ModelIndex, root : SpatialNode) -> SpatialMetrics

    spatial_model_metrics

    source
    fn spatial_model_metrics(model : Model) -> SpatialMetrics

    spatial_named_nodes

    source
    fn spatial_named_nodes(root : SpatialNode, fragment : String) -> Array[SpatialNode]

    spatial_nodes_by_type

    source
    fn spatial_nodes_by_type(root : SpatialNode, ifc_type : String) -> Array[SpatialNode]

    spatial_path

    source
    fn spatial_path(root : SpatialNode, target : Int) -> Array[Int]?

    spatial_product_containers

    source
    fn spatial_product_containers(index : ModelIndex) -> Map[Int, Int]

    spatial_product_ids

    source
    fn spatial_product_ids(root : SpatialNode) -> Array[Int]

    spatial_products_named

    source
    fn spatial_products_named(root : SpatialNode, fragment : String) -> Array[Int]

    spatial_report

    source
    fn spatial_report(index : ModelIndex, root : SpatialNode) -> String

    spatial_report_all

    source
    fn spatial_report_all(model : Model) -> Array[String]

    spatial_root

    source
    fn spatial_root(index : ModelIndex) -> SpatialNode?

    spatial_root_summary

    source
    fn spatial_root_summary(model : Model) -> String

    spatial_roots

    source
    fn spatial_roots(index : ModelIndex) -> Array[SpatialNode]

    spatial_schedule

    source
    fn spatial_schedule(model : Model) -> SpatialSchedule raise ParseError

    Produce room/storey rows for schedules, dashboards and downstream reports.

    spatial_tree_ids

    source
    fn spatial_tree_ids(root : SpatialNode) -> Array[Int]

    spatial_tree_is_acyclic

    source
    fn spatial_tree_is_acyclic(root : SpatialNode) -> Bool

    standard_model_rules

    source
    fn standard_model_rules() -> Array[ModelRule]

    step_statistics

    source
    fn step_statistics(source : String) -> StepDocumentStats

    stream_batch_count

    source
    fn stream_batch_count(source : String, batch_size : Int, filter? : StreamFilter) -> Int

    stream_batch_summary

    source
    fn stream_batch_summary(batches : Array[StreamBatch]) -> Array[String]

    stream_batches

    source
    fn stream_batches(source : String, batch_size : Int, filter? : StreamFilter) -> Array[StreamBatch]

    Partition selected raw records into deterministic source-order batches.

    stream_entities

    source
    fn stream_entities(source : String) -> Array[StepRecord]

    stream_filter_names

    source
    fn stream_filter_names(filter : StreamFilter) -> Array[String]

    stream_group_by_line

    source
    fn stream_group_by_line(source : String, line_width : Int) -> Map[Int, Int]

    stream_group_by_name

    source
    fn stream_group_by_name(source : String) -> Map[String, Int]

    stream_record_ids

    source
    fn stream_record_ids(source : String) -> Array[Int]

    stream_record_names

    source
    fn stream_record_names(source : String) -> Array[String]

    stream_records_in_batches

    source
    fn stream_records_in_batches(source : String, batch_size : Int, filter? : StreamFilter) -> Array[StepRecord]

    stream_records_longer_than

    source
    fn stream_records_longer_than(source : String, length : Int) -> Array[StepRecord]

    stream_records_with_references

    source
    fn stream_records_with_references(source : String) -> Array[StepRecord]

    stream_reference_histogram

    source
    fn stream_reference_histogram(source : String) -> Map[Int, Int]

    stream_select

    source
    fn stream_select(source : String, filter? : StreamFilter) -> StreamSelection

    Select raw records without parsing values or constructing a model.

    stream_select_geometry

    source
    fn stream_select_geometry(source : String) -> Array[StepRecord]

    stream_select_id_range

    source
    fn stream_select_id_range(source : String, first : Int, last : Int) -> StreamSelection

    stream_select_named

    source
    fn stream_select_named(source : String, name : String) -> StreamSelection

    stream_select_products

    source
    fn stream_select_products(source : String, filter? : StreamFilter) -> Array[Entity] raise ParseError

    stream_select_relationships

    source
    fn stream_select_relationships(source : String) -> Array[StepRecord]

    stream_selection_offsets

    source
    fn stream_selection_offsets(selection : StreamSelection) -> (Int, Int)

    stream_statistics

    source
    fn stream_statistics(source : String) -> StreamStats

    Calculate source and record statistics with a single record scan.

    stream_stats_for_filter

    source
    fn stream_stats_for_filter(source : String, filter? : StreamFilter) -> StreamStats

    supports_schema

    source
    fn supports_schema(model : Model, version : SchemaVersion) -> Bool

    takeoff_area_per_volume

    source
    fn takeoff_area_per_volume(report : TakeoffReport) -> Double

    takeoff_by_kind

    source
    fn takeoff_by_kind(report : TakeoffReport, kind : ProductKind) -> Array[ProductTakeoff]

    takeoff_by_type

    source
    fn takeoff_by_type(report : TakeoffReport, ifc_type : String) -> Array[ProductTakeoff]

    takeoff_for_product

    source
    fn takeoff_for_product(model : Model, product_id : Int, options? : TakeoffOptions) -> ProductTakeoff? raise ParseError

    topology_audit

    source
    fn topology_audit(mesh : Mesh) -> TopologyReport

    Analyze edge incidence, manifoldness and connected components of a mesh.

    topology_face_count

    source
    fn topology_face_count(index : ModelIndex, id : Int) -> Int raise ParseError

    topology_issue_histogram

    source
    fn topology_issue_histogram(report : TopologyReport) -> Map[String, Int]

    topology_issue_name

    source
    fn topology_issue_name(kind : TopologyIssueKind) -> String

    topology_reports_for_meshes

    source
    fn topology_reports_for_meshes(meshes : Array[Mesh]) -> Array[TopologyReport]

    topology_summary

    source
    fn topology_summary(reports : Array[TopologyReport]) -> Array[String]

    topology_total_surface_area

    source
    fn topology_total_surface_area(reports : Array[TopologyReport]) -> Double

    topology_total_volume

    source
    fn topology_total_volume(reports : Array[TopologyReport]) -> Double

    topology_unhealthy

    source
    fn topology_unhealthy(reports : Array[TopologyReport]) -> Array[TopologyReport]

    total_estimated_volume

    source
    fn total_estimated_volume(index : ModelIndex, products : Array[Product]) -> Double

    transform_bounds

    source
    fn transform_bounds(transform : Transform3, bounds : BoundingBox) -> BoundingBox

    transform_mesh

    source
    fn transform_mesh(transform : Transform3, mesh : Mesh) -> Mesh

    transform_point

    source
    fn transform_point(index : ModelIndex, product : Product, point : Point3) -> Point3

    transform_points

    source
    fn transform_points(index : ModelIndex, product : Product, points : Array[Point3]) -> Array[Point3]

    triangle_area

    source
    fn triangle_area(mesh : Mesh, triangle : (Int, Int, Int)) -> Double

    triangle_normal

    source
    fn triangle_normal(mesh : Mesh, triangle : (Int, Int, Int)) -> Vector3

    type_histogram

    source
    fn type_histogram(index : ModelIndex) -> Map[String, Int]

    unit_audit

    source
    fn unit_audit(model : Model) -> UnitAuditReport

    Audit the IFC unit assignment while retaining unknown declarations.

    unit_semantic

    source
    fn unit_semantic(label : String) -> UnitSemantic

    Resolve the common labels used by IFC exports and quantity schedules.

    unit_semantic_catalog

    source
    fn unit_semantic_catalog() -> Array[UnitSemantic]

    unit_semantic_catalog_json

    source
    fn unit_semantic_catalog_json() -> String

    unit_semantic_is_recognized

    source
    fn unit_semantic_is_recognized(label : String) -> Bool

    unit_semantic_kind

    source
    fn unit_semantic_kind(label : String) -> UnitKind

    unit_semantic_scale

    source
    fn unit_semantic_scale(label : String) -> Double?

    unit_system

    source
    fn unit_system(index : ModelIndex) -> UnitSystem

    validate

    source
    fn validate(model : Model) -> ValidationReport

    Check references and structural invariants without rejecting unknown IFC extensions.

    validate_ifc_guid

    source
    fn validate_ifc_guid(value : String) -> GuidReport

    Validate the lexical constraints of an IFC compressed GUID.

    validate_mesh

    source
    fn validate_mesh(mesh : Mesh, tolerance? : Double) -> MeshValidation

    Check index safety, duplicate vertices and geometric degeneracy before export.

    validate_rule

    source
    fn validate_rule(model : Model, rule : ModelRule) -> RuleReport raise ParseError

    validate_schema

    source
    fn validate_schema(model : Model) -> SchemaReport

    validate_with_schema

    source
    fn validate_with_schema(model : Model, profile : SchemaProfile) -> SchemaReport

    validation_summary

    source
    fn validation_summary(report : ValidationReport) -> String

    value_contains_reference

    source
    fn value_contains_reference(value : Value, target : Int) -> Bool

    value_maximum_depth

    source
    fn value_maximum_depth(value : Value) -> Int

    value_reference

    source
    fn value_reference(value : Value?) -> Int?

    value_references

    source
    fn value_references(value : Value) -> Array[Int]

    value_stats

    source
    fn value_stats(value : Value) -> ValueStats

    value_to_json

    source
    fn value_to_json(value : Value) -> String

    weld_mesh

    source
    fn weld_mesh(mesh : Mesh, tolerance : Double) -> Mesh

    Weld nearby points and rewrite triangle indices deterministically.

    workspace

    source
    fn workspace(source : String) -> ModelWorkspace raise ParseError

    workspace_export

    source
    fn workspace_export(workspace : ModelWorkspace, options? : ExportOptions) -> ExportedAsset raise ParseError

    workspace_health_score

    source
    fn workspace_health_score(workspace : ModelWorkspace) -> Int

    workspace_inspection

    source
    fn workspace_inspection(workspace : ModelWorkspace) -> Inspection

    workspace_nearest_product

    source
    fn workspace_nearest_product(workspace : ModelWorkspace, point : Point3) -> SpatialHit?

    workspace_products_at_point

    source
    fn workspace_products_at_point(workspace : ModelWorkspace, point : Point3, tolerance? : Double) -> Array[SpatialHit]

    workspace_query_by_kind

    source
    fn workspace_query_by_kind(workspace : ModelWorkspace, kind : ProductKind) -> Array[Product] raise ParseError

    workspace_query_by_type

    source
    fn workspace_query_by_type(workspace : ModelWorkspace, ifc_type : String) -> Array[Product] raise ParseError

    workspace_snapshot_diff

    source
    fn workspace_snapshot_diff(left : ModelWorkspace, right : ModelWorkspace) -> Array[String]

    world_to_local

    source
    fn world_to_local(transform : Transform3, point : Point3) -> Point3?

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io