@ifc-lite/viewer 1.14.0 → 1.14.2

package/src/components/viewer/Viewport.tsx

@@ -40,12 +40,15 @@ import { useRenderUpdates } from './useRenderUpdates.js';
 
 interface ViewportProps {
   geometry: MeshData[] | null;
+  /** Monotonic counter that increments when geometry changes — used to trigger
+   *  streaming effects even when the geometry array reference is stable. */
+  geometryVersion?: number;
   coordinateInfo?: CoordinateInfo;
   computedIsolatedIds?: Set<number> | null;
   modelIdToIndex?: Map<string, number>;
 }
 
-export function Viewport({ geometry, coordinateInfo, computedIsolatedIds, modelIdToIndex }: ViewportProps) {
+export function Viewport({ geometry, geometryVersion, coordinateInfo, computedIsolatedIds, modelIdToIndex }: ViewportProps) {
   const canvasRef = useRef<HTMLCanvasElement>(null);
   const rendererRef = useRef<Renderer | null>(null);
   const [isInitialized, setIsInitialized] = useState(false);
@@ -789,6 +792,7 @@ export function Viewport({ geometry, coordinateInfo, computedIsolatedIds, modelI
     rendererRef,
     isInitialized,
     geometry,
+    geometryVersion,
     coordinateInfo,
     isStreaming,
     geometryBoundsRef,

package/src/components/viewer/ViewportContainer.tsx

@@ -173,58 +173,79 @@ export function ViewportContainer() {
   // Check if any models are loaded (even if hidden) - used to show empty 3D vs starting UI
   const hasLoadedModels = storeModels.size > 0 || (geometryResult?.meshes && geometryResult.meshes.length > 0);
 
-  // Filter geometry based on type visibility only
-  // PERFORMANCE FIX: Don't filter by storey or hiddenEntities here
-  // Instead, let the renderer handle visibility filtering at the batch level
-  // This avoids expensive batch rebuilding when visibility changes
+  // PERF: Incremental geometry filtering using refs.
+  // Instead of creating a new 200K+ element array every batch (~200ms),
+  // we push ONLY new meshes into a cached array — O(batch_size) not O(total).
+  // A version counter triggers downstream re-renders via the Viewport prop.
+  const filteredCacheRef = useRef<MeshData[]>([]);
+  const filteredSourceLenRef = useRef(0);
+  const filteredTypeVisRef = useRef(typeVisibility);
+  const filteredVersionRef = useRef(0);
+
   const filteredGeometry = useMemo(() => {
     if (!mergedGeometryResult?.meshes) {
+      filteredCacheRef.current = [];
+      filteredSourceLenRef.current = 0;
+      filteredVersionRef.current = 0;
       return null;
     }
 
-    let meshes = mergedGeometryResult.meshes;
+    const allMeshes = mergedGeometryResult.meshes;
+    const cache = filteredCacheRef.current;
+
+    // Full rebuild if: type visibility changed, source shrunk (new file), or empty cache
+    const prevVis = filteredTypeVisRef.current;
+    const typeVisChanged =
+      prevVis.spaces !== typeVisibility.spaces ||
+      prevVis.openings !== typeVisibility.openings ||
+      prevVis.site !== typeVisibility.site;
+    if (typeVisChanged || allMeshes.length < filteredSourceLenRef.current) {
+      cache.length = 0;
+      filteredSourceLenRef.current = 0;
+      filteredTypeVisRef.current = typeVisibility;
+    }
+
+    const needsFilter = !typeVisibility.spaces || !typeVisibility.openings || !typeVisibility.site;
+    const prevCacheLen = cache.length;
 
-    // Filter by type visibility (spatial elements)
-    meshes = meshes.filter(mesh => {
+    // Only process NEW meshes since last run — O(batch_size) not O(total)
+    for (let i = filteredSourceLenRef.current; i < allMeshes.length; i++) {
+      const mesh = allMeshes[i];
       const ifcType = mesh.ifcType;
 
-      // Check type visibility
-      if (ifcType === 'IfcSpace' && !typeVisibility.spaces) {
-        return false;
+      if (needsFilter) {
+        if (ifcType === 'IfcSpace' && !typeVisibility.spaces) continue;
+        if (ifcType === 'IfcOpeningElement' && !typeVisibility.openings) continue;
+        if (ifcType === 'IfcSite' && !typeVisibility.site) continue;
       }
-      if (ifcType === 'IfcOpeningElement' && !typeVisibility.openings) {
-        return false;
-      }
-      if (ifcType === 'IfcSite' && !typeVisibility.site) {
-        return false;
-      }
-
-      return true;
-    });
 
-    // Apply transparency for spatial elements
-    meshes = meshes.map(mesh => {
-      const ifcType = mesh.ifcType;
-      const isSpace = ifcType === 'IfcSpace';
-      const isOpening = ifcType === 'IfcOpeningElement';
-
-      if (isSpace || isOpening) {
-        // Create a new color array with reduced opacity
-        const newColor: [number, number, number, number] = [
-          mesh.color[0],
-          mesh.color[1],
-          mesh.color[2],
-          Math.min(mesh.color[3] * 0.3, 0.3), // Semi-transparent (30% opacity max)
-        ];
-        return { ...mesh, color: newColor };
+      if (ifcType === 'IfcSpace' || ifcType === 'IfcOpeningElement') {
+        cache.push({
+          ...mesh,
+          color: [mesh.color[0], mesh.color[1], mesh.color[2], Math.min(mesh.color[3] * 0.3, 0.3)],
+        });
+      } else {
+        cache.push(mesh);
       }
+    }
 
-      return mesh;
-    });
+    filteredSourceLenRef.current = allMeshes.length;
 
-    return meshes;
+    // Only bump version when cache content actually changed — avoids
+    // unnecessary downstream re-renders when memo runs with same data.
+    if (cache.length !== prevCacheLen || typeVisChanged) {
+      filteredVersionRef.current++;
+    }
+
+    // Return the same array reference — downstream change detection uses
+    // geometryVersion (which increments each batch) instead of array identity.
+    return cache;
   }, [mergedGeometryResult, typeVisibility]);
 
+  // Version counter that changes every batch — triggers useGeometryStreaming
+  // without requiring a new geometry array reference.
+  const geometryVersion = filteredVersionRef.current;
+
   // Compute combined isolation set (storeys + manual isolation)
   // This is passed to the renderer for batch-level visibility filtering
   // Now supports multi-model: aggregates elements from all models for selected storeys
@@ -580,6 +601,7 @@ export function ViewportContainer() {
 
       <Viewport
         geometry={filteredGeometry}
+        geometryVersion={geometryVersion}
         coordinateInfo={mergedGeometryResult?.coordinateInfo}
         computedIsolatedIds={computedIsolatedIds}
         modelIdToIndex={modelIdToIndex}

package/src/components/viewer/ViewportOverlays.tsx

@@ -16,7 +16,7 @@ import { goHomeFromStore } from '@/store/homeView';
 import { useIfc } from '@/hooks/useIfc';
 import { cn } from '@/lib/utils';
 import { ViewCube, type ViewCubeRef } from './ViewCube';
-import { AxisHelper } from './AxisHelper';
+import { AxisHelper, type AxisHelperRef } from './AxisHelper';
 
 export function ViewportOverlays() {
   const selectedStoreys = useViewerStore((s) => s.selectedStoreys);
@@ -31,6 +31,7 @@ export function ViewportOverlays() {
   // Use refs for rotation to avoid re-renders - ViewCube updates itself directly
   const cameraRotationRef = useRef({ azimuth: 45, elevation: 25 });
   const viewCubeRef = useRef<ViewCubeRef | null>(null);
+  const axisHelperRef = useRef<AxisHelperRef | null>(null);
 
   // Local state for scale - updated via callback, no global re-renders
   const [scale, setScale] = useState(10);
@@ -41,11 +42,10 @@ export function ViewportOverlays() {
     const handleRotationChange = (rotation: { azimuth: number; elevation: number }) => {
       cameraRotationRef.current = rotation;
       // Update ViewCube directly via ref (no React re-render)
-      if (viewCubeRef.current) {
-        const viewCubeRotationX = -rotation.elevation;
-        const viewCubeRotationY = -rotation.azimuth;
-        viewCubeRef.current.updateRotation(viewCubeRotationX, viewCubeRotationY);
-      }
+      const viewCubeRotationX = -rotation.elevation;
+      const viewCubeRotationY = -rotation.azimuth;
+      viewCubeRef.current?.updateRotation(viewCubeRotationX, viewCubeRotationY);
+      axisHelperRef.current?.updateRotation(viewCubeRotationX, viewCubeRotationY);
     };
     setOnCameraRotationChange(handleRotationChange);
     return () => setOnCameraRotationChange(null);
@@ -193,6 +193,7 @@ export function ViewportOverlays() {
       {/* Axis Helper (bottom-left, above scale bar) - IFC Z-up convention */}
       <div className="absolute bottom-16 left-4">
         <AxisHelper
+          ref={axisHelperRef}
           rotationX={initialRotationX}
           rotationY={initialRotationY}
         />

package/src/components/viewer/hierarchy/HierarchyNode.tsx

@@ -24,6 +24,7 @@ import { isSpatialContainer } from './types';
 const TYPE_ICONS: Record<string, React.ElementType> = {
   'unified-storey': Layers,
   'model-header': FileBox,
+  'ifc-type': Building2,
   IfcProject: FolderKanban,
   IfcSite: MapPin,
   IfcBuilding: Building2,

package/src/components/viewer/hierarchy/treeDataBuilder.ts

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import { IfcTypeEnum, type SpatialNode } from '@ifc-lite/data';
+import { IfcTypeEnum, EntityFlags, RelationshipType, type SpatialNode } from '@ifc-lite/data';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import type { FederatedModel } from '@/store';
 import type { TreeNode, NodeType, StoreyData, UnifiedStorey } from './types';
@@ -433,6 +433,158 @@ export function buildTypeTree(
   return nodes;
 }
 
+/** Build tree data grouped by IFC type entities (IfcWallType, IfcDoorType, etc.).
+ *  Shows each type entity as a parent node with its typed instances (occurrences) as children.
+ *  Uses IfcRelDefinesByType relationships to find type→occurrence mappings.
+ *  Entities without a type are grouped under an "Untyped" section per IFC class. */
+export function buildIfcTypeTree(
+  models: Map<string, FederatedModel>,
+  ifcDataStore: IfcDataStore | null | undefined,
+  expandedNodes: Set<string>,
+  isMultiModel: boolean,
+  geometricIds?: Set<number>,
+): TreeNode[] {
+  // Collect type entities and their typed instances
+  interface TypeEntry {
+    typeExpressId: number;
+    typeName: string;      // e.g. "W01"
+    typeClassName: string;  // e.g. "IfcWallType"
+    modelId: string;
+    globalId: number;
+    instances: Array<{ expressId: number; globalId: number; name: string; modelId: string }>;
+  }
+
+  // Group by type class name (e.g. "IfcWallType") → individual types
+  const typeClassGroups = new Map<string, TypeEntry[]>();
+
+  const processDataStore = (dataStore: IfcDataStore, modelId: string, idOffset: number) => {
+    if (!dataStore.relationships) return;
+
+    // Find all type entities (entities with IS_TYPE flag)
+    for (let i = 0; i < dataStore.entities.count; i++) {
+      const flags = dataStore.entities.flags[i];
+      if (!(flags & EntityFlags.IS_TYPE)) continue;
+
+      const expressId = dataStore.entities.expressId[i];
+      const typeClassName = dataStore.entities.getTypeName(expressId);
+
+      // Skip relationship entities and non-product types
+      if (typeClassName.startsWith('IfcRel') || typeClassName === 'Unknown') continue;
+      const typeName = dataStore.entities.getName(expressId) || `#${expressId}`;
+
+      // Get instances via DefinesByType (forward: type → occurrences)
+      const instanceIds = dataStore.relationships.getRelated(expressId, RelationshipType.DefinesByType, 'forward');
+      const instances: TypeEntry['instances'] = [];
+
+      for (const instId of instanceIds) {
+        const instGlobalId = instId + idOffset;
+        if (geometricIds && geometricIds.size > 0 && !geometricIds.has(instGlobalId)) continue;
+        const instName = dataStore.entities.getName(instId) || `#${instId}`;
+        instances.push({ expressId: instId, globalId: instGlobalId, name: instName, modelId });
+      }
+
+      const entry: TypeEntry = {
+        typeExpressId: expressId,
+        typeName,
+        typeClassName,
+        modelId,
+        globalId: expressId + idOffset,
+        instances,
+      };
+
+      if (!typeClassGroups.has(typeClassName)) {
+        typeClassGroups.set(typeClassName, []);
+      }
+      typeClassGroups.get(typeClassName)!.push(entry);
+    }
+  };
+
+  if (models.size > 0) {
+    for (const [modelId, model] of models) {
+      if (model.ifcDataStore) {
+        processDataStore(model.ifcDataStore, modelId, model.idOffset ?? 0);
+      }
+    }
+  } else if (ifcDataStore) {
+    processDataStore(ifcDataStore, 'legacy', 0);
+  }
+
+  const nodes: TreeNode[] = [];
+
+  // Sort type class groups alphabetically
+  const sortedClassNames = Array.from(typeClassGroups.keys()).sort();
+
+  for (const className of sortedClassNames) {
+    const types = typeClassGroups.get(className)!;
+    const classNodeId = `typeclass-${className}`;
+    const isClassExpanded = expandedNodes.has(classNodeId);
+
+    // Total instances across all types in this class
+    const totalInstances = types.reduce((sum, t) => sum + t.instances.length, 0);
+    // Collect all instance globalIds for visibility/isolation
+    const allInstanceGlobalIds = types.flatMap(t => t.instances.map(i => i.globalId));
+
+    nodes.push({
+      id: classNodeId,
+      expressIds: allInstanceGlobalIds,
+      modelIds: [],
+      name: className,
+      type: 'type-group',
+      depth: 0,
+      hasChildren: types.length > 0,
+      isExpanded: isClassExpanded,
+      isVisible: true,
+      elementCount: totalInstances,
+    });
+
+    if (isClassExpanded) {
+      // Sort types by name
+      types.sort((a, b) => a.typeName.localeCompare(b.typeName));
+
+      for (const typeEntry of types) {
+        const typeNodeId = `ifctype-${typeEntry.modelId}-${typeEntry.typeExpressId}`;
+        const isTypeExpanded = expandedNodes.has(typeNodeId);
+        const instanceGlobalIds = typeEntry.instances.map(i => i.globalId);
+        const suffix = isMultiModel ? ` [${models.get(typeEntry.modelId)?.name || typeEntry.modelId}]` : '';
+
+        nodes.push({
+          id: typeNodeId,
+          expressIds: instanceGlobalIds,
+          entityExpressId: typeEntry.typeExpressId,
+          modelIds: [typeEntry.modelId],
+          name: `${typeEntry.typeName}${suffix}`,
+          type: 'ifc-type',
+          depth: 1,
+          hasChildren: typeEntry.instances.length > 0,
+          isExpanded: isTypeExpanded,
+          isVisible: true,
+          elementCount: typeEntry.instances.length,
+        });
+
+        if (isTypeExpanded) {
+          typeEntry.instances.sort((a, b) => a.name.localeCompare(b.name));
+          for (const inst of typeEntry.instances) {
+            const instSuffix = isMultiModel ? ` [${models.get(inst.modelId)?.name || inst.modelId}]` : '';
+            nodes.push({
+              id: `element-${inst.modelId}-${inst.expressId}`,
+              expressIds: [inst.globalId],
+              modelIds: [inst.modelId],
+              name: inst.name + instSuffix,
+              type: 'element',
+              depth: 2,
+              hasChildren: false,
+              isExpanded: false,
+              isVisible: true,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return nodes;
+}
+
 /** Filter nodes based on search query */
 export function filterNodes(nodes: TreeNode[], searchQuery: string): TreeNode[] {
   if (!searchQuery.trim()) return nodes;

package/src/components/viewer/hierarchy/types.ts

@@ -11,12 +11,15 @@ export type NodeType =
   | 'IfcBuilding'         // Building node
   | 'IfcBuildingStorey'   // Storey node
   | 'type-group'          // IFC class grouping header (e.g., "IfcWall (47)")
+  | 'ifc-type'            // IFC type entity node (e.g., "IfcWallType/W01")
   | 'element';            // Individual element
 
 export interface TreeNode {
   id: string;  // Unique ID for the node (can be composite)
   /** Express IDs this node represents (for elements/storeys) */
   expressIds: number[];
+  /** Structured entity expressId for selectable non-element nodes (for example IFC type entities) */
+  entityExpressId?: number;
   /** Model IDs this node belongs to */
   modelIds: string[];
   name: string;

package/src/components/viewer/hierarchy/useHierarchyTree.ts

@@ -12,11 +12,12 @@ import {
   getUnifiedStoreyElements as getUnifiedStoreyElementsFn,
   buildTreeData,
   buildTypeTree,
+  buildIfcTypeTree,
   filterNodes,
   splitNodes,
 } from './treeDataBuilder';
 
-export type GroupingMode = 'spatial' | 'type';
+export type GroupingMode = 'spatial' | 'type' | 'ifc-type';
 
 interface UseHierarchyTreeParams {
   models: Map<string, FederatedModel>;
@@ -164,11 +165,15 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
     return geometryResult?.meshes.length ?? 0;
   }, [models, geometryResult?.meshes.length]);
 
-  // Pre-computed set of global IDs with geometry — stable across color changes
+  // Pre-computed set of global IDs with geometry — stable across color changes.
+  // PERF: Skip when no geometry source exists (during initial streaming before
+  // any data is ready). Gate on models OR ifcDataStore so federated scenarios
+  // (models.size > 0 but ifcDataStore is null) still build the set correctly.
+  const hasGeometrySource = models.size > 0 || !!ifcDataStore;
   const geometricIds = useMemo(
-    () => buildGeometricIdSet(models, geometryResult),
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- meshCount is a stable proxy
-    [models, meshCount]
+    () => hasGeometrySource ? buildGeometricIdSet(models, geometryResult) : new Set<number>(),
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- meshCount is a stable proxy; hasGeometrySource gates streaming
+    [models, hasGeometrySource ? meshCount : 0]
   );
 
   // Build the tree data structure based on grouping mode
@@ -178,6 +183,9 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
       if (groupingMode === 'type') {
         return buildTypeTree(models, ifcDataStore, expandedNodes, isMultiModel, geometricIds);
       }
+      if (groupingMode === 'ifc-type') {
+        return buildIfcTypeTree(models, ifcDataStore, expandedNodes, isMultiModel, geometricIds);
+      }
       return buildTreeData(models, ifcDataStore, expandedNodes, isMultiModel, unifiedStoreys);
     },
     [models, ifcDataStore, expandedNodes, isMultiModel, unifiedStoreys, groupingMode, geometricIds]
@@ -207,9 +215,9 @@ export function useHierarchyTree({ models, ifcDataStore, isMultiModel, geometryR
     });
   }, []);
 
-  // Get all elements for a node (handles type groups, unified storeys, single storeys, model contributions, and elements)
+  // Get all elements for a node (handles type groups, ifc-type, unified storeys, single storeys, model contributions, and elements)
   const getNodeElements = useCallback((node: TreeNode): number[] => {
-    if (node.type === 'type-group') {
+    if (node.type === 'type-group' || node.type === 'ifc-type') {
       // GlobalIds are pre-stored on the node during tree construction — O(1)
       return node.expressIds;
     }

package/src/components/viewer/properties/BsddCard.tsx

@@ -16,7 +16,7 @@ import { Button } from '@/components/ui/button';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { Badge } from '@/components/ui/badge';
 import { useViewerStore } from '@/store';
-import { PropertyValueType, QuantityType } from '@ifc-lite/data';
+import { type PropertyValue, PropertyValueType, QuantityType } from '@ifc-lite/data';
 import {
   fetchClassInfo,
   bsddDataTypeLabel,
@@ -59,7 +59,7 @@ function toPropertyValueType(bsddType: string | null): PropertyValueType {
   return PropertyValueType.Label;
 }
 
-function defaultValue(_bsddType: string | null): unknown {
+function defaultValue(_bsddType: string | null): PropertyValue {
   // Always return empty string – user fills in values manually
   return '';
 }

package/src/components/viewer/properties/PropertySetCard.tsx

@@ -6,8 +6,8 @@
  * Property set display component with edit support.
  */
 
-import { Sparkles, PenLine } from 'lucide-react';
-import { PropertyEditor } from '../PropertyEditor';
+import { Sparkles, PenLine, Building2 } from 'lucide-react';
+import { PropertyEditor, type PropertyEditScope } from '../PropertyEditor';
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '@/components/ui/collapsible';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { Badge } from '@/components/ui/badge';
@@ -19,24 +19,31 @@ export interface PropertySetCardProps {
   modelId?: string;
   entityId?: number;
   enableEditing?: boolean;
+  /** Whether this property set is inherited from the type entity */
+  isTypeProperty?: boolean;
+  typeEditScope?: PropertyEditScope;
 }
 
-export function PropertySetCard({ pset, modelId, entityId, enableEditing }: PropertySetCardProps) {
+export function PropertySetCard({ pset, modelId, entityId, enableEditing, isTypeProperty, typeEditScope }: PropertySetCardProps) {
   // Check if any property in this set is mutated
   const hasMutations = pset.properties.some(p => p.isMutated);
   const isNewPset = pset.isNewPset;
 
-  // Dynamic styling based on mutation state
+  // Dynamic styling based on mutation state and source
   const borderClass = isNewPset
     ? 'border-2 border-amber-400/50 dark:border-amber-500/30'
     : hasMutations
     ? 'border-2 border-purple-300/50 dark:border-purple-500/30'
+    : isTypeProperty
+    ? 'border-2 border-indigo-200/60 dark:border-indigo-800/40'
     : 'border-2 border-zinc-200 dark:border-zinc-800';
 
   const bgClass = isNewPset
     ? 'bg-amber-50/30 dark:bg-amber-950/20'
     : hasMutations
     ? 'bg-purple-50/20 dark:bg-purple-950/10'
+    : isTypeProperty
+    ? 'bg-indigo-50/20 dark:bg-indigo-950/10'
     : 'bg-white dark:bg-zinc-950';
 
   return (
@@ -58,6 +65,14 @@ export function PropertySetCard({ pset, modelId, entityId, enableEditing }: Prop
             <TooltipContent>Has modified properties</TooltipContent>
           </Tooltip>
         )}
+        {isTypeProperty && !isNewPset && !hasMutations && (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <Building2 className="h-3.5 w-3.5 text-indigo-400 shrink-0" />
+            </TooltipTrigger>
+            <TooltipContent>Inherited from type — edits apply to all instances of this type</TooltipContent>
+          </Tooltip>
+        )}
         <span className="font-bold text-xs text-zinc-900 dark:text-zinc-100 truncate flex-1 min-w-0">{decodeIfcString(pset.name)}</span>
         <span className="text-[10px] font-mono bg-zinc-100 dark:bg-zinc-900 px-1.5 py-0.5 border border-zinc-200 dark:border-zinc-800 text-zinc-600 dark:text-zinc-400 shrink-0">{pset.properties.length}</span>
       </CollapsibleTrigger>
@@ -115,6 +130,7 @@ export function PropertySetCard({ pset, modelId, entityId, enableEditing }: Prop
                       psetName={pset.name}
                       propName={prop.name}
                       currentValue={prop.value}
+                      editScope={typeEditScope}
                     />
                   ) : (
                     <span className={`font-mono select-all break-words ${isMutated ? 'text-purple-900 dark:text-purple-100 font-semibold' : 'text-zinc-900 dark:text-zinc-100'}`}>

package/src/components/viewer/properties/encodingUtils.ts

@@ -21,6 +21,8 @@ export interface PropertySet {
   name: string;
   properties: Array<{ name: string; value: unknown; isMutated?: boolean }>;
   isNewPset?: boolean;
+  /** Where this property set originates from: 'instance' (occurrence) or 'type' (inherited from IfcTypeObject) */
+  source?: 'instance' | 'type';
 }
 
 export interface QuantitySet {