Merge branch 'master' into document_material_reflectivity

code/CMakeLists.txt

@@ -457,24 +457,23 @@ ADD_ASSIMP_IMPORTER( BLEND
 )
 
 ADD_ASSIMP_IMPORTER( IFC
-  IFCLoader.cpp
-  IFCLoader.h
-  IFCReaderGen1.cpp
-  IFCReaderGen2.cpp
-  IFCReaderGen.h
-  IFCUtil.h
-  IFCUtil.cpp
-  IFCGeometry.cpp
-  IFCMaterial.cpp
-  IFCProfile.cpp
-  IFCCurve.cpp
-  IFCBoolean.cpp
-  IFCOpenings.cpp
-  STEPFile.h
-  STEPFileReader.h
-  STEPFileReader.cpp
-  STEPFileEncoding.cpp
-  STEPFileEncoding.h
+  Importer/IFC/IFCLoader.cpp
+  Importer/IFC/IFCLoader.h
+  Importer/IFC/IFCReaderGen1_2x3.cpp
+  Importer/IFC/IFCReaderGen2_2x3.cpp
+  Importer/IFC/IFCReaderGen_2x3.h
+  Importer/IFC/IFCUtil.h
+  Importer/IFC/IFCUtil.cpp
+  Importer/IFC/IFCGeometry.cpp
+  Importer/IFC/IFCMaterial.cpp
+  Importer/IFC/IFCProfile.cpp
+  Importer/IFC/IFCCurve.cpp
+  Importer/IFC/IFCBoolean.cpp
+  Importer/IFC/IFCOpenings.cpp
+  Importer/IFC/STEPFileReader.h
+  Importer/IFC/STEPFileReader.cpp
+  Importer/IFC/STEPFileEncoding.cpp
+  Importer/IFC/STEPFileEncoding.h
 )
 if (ASSIMP_BUILD_IFC_IMPORTER)
   if (MSVC)
@@ -697,6 +696,7 @@ ADD_ASSIMP_IMPORTER( MMD
 )
 
 SET( Step_SRCS
+  STEPFile.h
   StepExporter.h
   StepExporter.cpp
 )

code/IFCBoolean.cpp → code/Importer/IFC/IFCBoolean.cpp

@@ -42,17 +42,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implements a subset of Ifc boolean operations
  */
 
-
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "IFCUtil.h"
-#include "PolyTools.h"
-#include "ProcessHelper.h"
+#include "code/Importer/IFC/IFCUtil.h"
+#include "code/PolyTools.h"
+#include "code/ProcessHelper.h"
 #include <assimp/Defines.h>
 
 #include <iterator>
 #include <tuple>
 
-
 namespace Assimp {
     namespace IFC {
 
@@ -61,7 +59,7 @@ namespace Assimp {
 // The function then generates a hit only if the end is beyond a certain margin in that direction, filtering out
 // "very close to plane" ghost hits as long as start and end stay directly on or within the given plane side.
 bool IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const IfcVector3& e0,
-    const IfcVector3& e1, bool assumeStartOnWhiteSide, IfcVector3& out)
+        const IfcVector3& e1, bool assumeStartOnWhiteSide, IfcVector3& out)
 {
     const IfcVector3 pdelta = e0 - p, seg = e1 - e0;
     const IfcFloat dotOne = n*seg, dotTwo = -(n*pdelta);
@@ -131,20 +129,20 @@ void WritePolygon(std::vector<IfcVector3>& resultpoly, TempMesh& result)
 
     if( resultpoly.size() > 2 )
     {
-        result.verts.insert(result.verts.end(), resultpoly.begin(), resultpoly.end());
-        result.vertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
+        result.mVerts.insert(result.mVerts.end(), resultpoly.begin(), resultpoly.end());
+        result.mVertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
     }
 }
 
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBooleanHalfSpaceDifference(const IfcHalfSpaceSolid* hs, TempMesh& result,
+void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs, TempMesh& result,
     const TempMesh& first_operand,
     ConversionData& /*conv*/)
 {
     ai_assert(hs != NULL);
 
-    const IfcPlane* const plane = hs->BaseSurface->ToPtr<IfcPlane>();
+    const Schema_2x3::IfcPlane* const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
     if(!plane) {
         IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
         return;
@@ -162,14 +160,14 @@ void ProcessBooleanHalfSpaceDifference(const IfcHalfSpaceSolid* hs, TempMesh& re
     }
 
     // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3>& in = first_operand.verts;
-    std::vector<IfcVector3>& outvert = result.verts;
+    const std::vector<IfcVector3>& in = first_operand.mVerts;
+    std::vector<IfcVector3>& outvert = result.mVerts;
 
-    std::vector<unsigned int>::const_iterator begin = first_operand.vertcnt.begin(),
-        end = first_operand.vertcnt.end(), iit;
+    std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin(),
+        end = first_operand.mVertcnt.end(), iit;
 
     outvert.reserve(in.size());
-    result.vertcnt.reserve(first_operand.vertcnt.size());
+    result.mVertcnt.reserve(first_operand.mVertcnt.size());
 
     unsigned int vidx = 0;
     for(iit = begin; iit != end; vidx += *iit++) {
@@ -229,10 +227,10 @@ void ProcessBooleanHalfSpaceDifference(const IfcHalfSpaceSolid* hs, TempMesh& re
             --newcount;
         }
         if(newcount > 2) {
-            result.vertcnt.push_back(newcount);
+            result.mVertcnt.push_back(newcount);
         }
         else while(newcount-->0) {
-            result.verts.pop_back();
+            result.mVerts.pop_back();
         }
 
     }
@@ -386,13 +384,13 @@ bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
 
 
 // ------------------------------------------------------------------------------------------------
-void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
+void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
                                                        const TempMesh& first_operand,
                                                        ConversionData& conv)
 {
     ai_assert(hs != NULL);
 
-    const IfcPlane* const plane = hs->BaseSurface->ToPtr<IfcPlane>();
+    const Schema_2x3::IfcPlane* const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
     if(!plane) {
         IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
         return;
@@ -419,7 +417,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
     }
 
     // determine winding order by calculating the normal.
-    IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(profile->verts.data(), profile->verts.size());
+    IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(profile->mVerts.data(), profile->mVerts.size());
 
     IfcMatrix4 proj_inv;
     ConvertAxisPlacement(proj_inv,hs->Position);
@@ -430,16 +428,16 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
     proj.Inverse();
 
     // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3>& in = first_operand.verts;
-    std::vector<IfcVector3>& outvert = result.verts;
-    std::vector<unsigned int>& outvertcnt = result.vertcnt;
+    const std::vector<IfcVector3>& in = first_operand.mVerts;
+    std::vector<IfcVector3>& outvert = result.mVerts;
+    std::vector<unsigned int>& outvertcnt = result.mVertcnt;
 
     outvert.reserve(in.size());
-    outvertcnt.reserve(first_operand.vertcnt.size());
+    outvertcnt.reserve(first_operand.mVertcnt.size());
 
     unsigned int vidx = 0;
-    std::vector<unsigned int>::const_iterator begin = first_operand.vertcnt.begin();
-    std::vector<unsigned int>::const_iterator end = first_operand.vertcnt.end();
+    std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin();
+    std::vector<unsigned int>::const_iterator end = first_operand.mVertcnt.end();
     std::vector<unsigned int>::const_iterator iit;
     for( iit = begin; iit != end; vidx += *iit++ )
     {
@@ -510,7 +508,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
         {
             // poly edge index, intersection point, edge index in boundary poly
             std::vector<std::tuple<size_t, IfcVector3, size_t> > intersections;
-            bool startedInside = PointInPoly(proj * blackside.front(), profile->verts);
+            bool startedInside = PointInPoly(proj * blackside.front(), profile->mVerts);
             bool isCurrentlyInside = startedInside;
 
             std::vector<std::pair<size_t, IfcVector3> > intersected_boundary;
@@ -521,7 +519,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                 const IfcVector3 e1 = proj * blackside[(a + 1) % blackside.size()];
 
                 intersected_boundary.clear();
-                IntersectsBoundaryProfile(e0, e1, profile->verts, isCurrentlyInside, intersected_boundary);
+                IntersectsBoundaryProfile(e0, e1, profile->mVerts, isCurrentlyInside, intersected_boundary);
                 // sort the hits by distance from e0 to get the correct in/out/in sequence. Manually :-( I miss you, C++11.
                 if( intersected_boundary.size() > 1 )
                 {
@@ -634,17 +632,17 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
 
                     // generate segments along the boundary polygon that lie in the poly's plane until we hit another intersection
                     IfcVector3 startingPoint = proj * std::get<1>(nextintsec);
-                    size_t currentBoundaryEdgeIdx = (std::get<2>(nextintsec) + (marchBackwardsOnBoundary ? 1 : 0)) % profile->verts.size();
+                    size_t currentBoundaryEdgeIdx = (std::get<2>(nextintsec) + (marchBackwardsOnBoundary ? 1 : 0)) % profile->mVerts.size();
                     size_t nextIntsecIdx = SIZE_MAX;
                     while( nextIntsecIdx == SIZE_MAX )
                     {
                         IfcFloat t = 1e10;
 
-                        size_t nextBoundaryEdgeIdx = marchBackwardsOnBoundary ? (currentBoundaryEdgeIdx + profile->verts.size() - 1) : currentBoundaryEdgeIdx + 1;
-                        nextBoundaryEdgeIdx %= profile->verts.size();
+                        size_t nextBoundaryEdgeIdx = marchBackwardsOnBoundary ? (currentBoundaryEdgeIdx + profile->mVerts.size() - 1) : currentBoundaryEdgeIdx + 1;
+                        nextBoundaryEdgeIdx %= profile->mVerts.size();
                         // vertices of the current boundary segments
-                        IfcVector3 currBoundaryPoint = profile->verts[currentBoundaryEdgeIdx];
-                        IfcVector3 nextBoundaryPoint = profile->verts[nextBoundaryEdgeIdx];
+                        IfcVector3 currBoundaryPoint = profile->mVerts[currentBoundaryEdgeIdx];
+                        IfcVector3 nextBoundaryPoint = profile->mVerts[nextBoundaryEdgeIdx];
                         // project the two onto the polygon
                         if( std::abs(polyNormal.z) > 1e-5 )
                         {
@@ -693,7 +691,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                         }
 
                         // quick endless loop check
-                        if( resultpoly.size() > blackside.size() + profile->verts.size() )
+                        if( resultpoly.size() > blackside.size() + profile->mVerts.size() )
                         {
                             IFCImporter::LogError("Encountered endless loop while clipping polygon against poly-bounded half space.");
                             break;
@@ -718,7 +716,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBooleanExtrudedAreaSolidDifference(const IfcExtrudedAreaSolid* as, TempMesh& result,
+void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid* as, TempMesh& result,
                                                const TempMesh& first_operand,
                                                ConversionData& conv)
 {
@@ -738,12 +736,12 @@ void ProcessBooleanExtrudedAreaSolidDifference(const IfcExtrudedAreaSolid* as, T
 
     TempMesh temp;
 
-    std::vector<IfcVector3>::const_iterator vit = first_operand.verts.begin();
-    for(unsigned int pcount : first_operand.vertcnt) {
+    std::vector<IfcVector3>::const_iterator vit = first_operand.mVerts.begin();
+    for(unsigned int pcount : first_operand.mVertcnt) {
         temp.Clear();
 
-        temp.verts.insert(temp.verts.end(), vit, vit + pcount);
-        temp.vertcnt.push_back(pcount);
+        temp.mVerts.insert(temp.mVerts.end(), vit, vit + pcount);
+        temp.mVertcnt.push_back(pcount);
 
         // The algorithms used to generate mesh geometry sometimes
         // spit out lines or other degenerates which must be
@@ -767,11 +765,11 @@ void ProcessBooleanExtrudedAreaSolidDifference(const IfcExtrudedAreaSolid* as, T
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv)
+void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv)
 {
     // supported CSG operations:
     //   DIFFERENCE
-    if(const IfcBooleanResult* const clip = boolean.ToPtr<IfcBooleanResult>()) {
+    if(const Schema_2x3::IfcBooleanResult* const clip = boolean.ToPtr<Schema_2x3::IfcBooleanResult>()) {
         if(clip->Operator != "DIFFERENCE") {
             IFCImporter::LogWarn("encountered unsupported boolean operator: " + (std::string)clip->Operator);
             return;
@@ -786,18 +784,18 @@ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, Conversio
         //  IfcExtrudedAreaSolid -- reduce to an instance of the quadrify() algorithm
 
 
-        const IfcHalfSpaceSolid* const hs = clip->SecondOperand->ResolveSelectPtr<IfcHalfSpaceSolid>(conv.db);
-        const IfcExtrudedAreaSolid* const as = clip->SecondOperand->ResolveSelectPtr<IfcExtrudedAreaSolid>(conv.db);
+        const Schema_2x3::IfcHalfSpaceSolid* const hs = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcHalfSpaceSolid>(conv.db);
+        const Schema_2x3::IfcExtrudedAreaSolid* const as = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcExtrudedAreaSolid>(conv.db);
         if(!hs && !as) {
             IFCImporter::LogError("expected IfcHalfSpaceSolid or IfcExtrudedAreaSolid as second clipping operand");
             return;
         }
 
         TempMesh first_operand;
-        if(const IfcBooleanResult* const op0 = clip->FirstOperand->ResolveSelectPtr<IfcBooleanResult>(conv.db)) {
+        if(const Schema_2x3::IfcBooleanResult* const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
             ProcessBoolean(*op0,first_operand,conv);
         }
-        else if (const IfcSweptAreaSolid* const swept = clip->FirstOperand->ResolveSelectPtr<IfcSweptAreaSolid>(conv.db)) {
+        else if (const Schema_2x3::IfcSweptAreaSolid* const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
             ProcessSweptAreaSolid(*swept,first_operand,conv);
         }
         else {
@@ -807,7 +805,7 @@ void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, Conversio
 
         if(hs) {
 
-            const IfcPolygonalBoundedHalfSpace* const hs_bounded = clip->SecondOperand->ResolveSelectPtr<IfcPolygonalBoundedHalfSpace>(conv.db);
+            const Schema_2x3::IfcPolygonalBoundedHalfSpace* const hs_bounded = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcPolygonalBoundedHalfSpace>(conv.db);
             if (hs_bounded) {
                 ProcessPolygonalBoundedBooleanHalfSpaceDifference(hs_bounded, result, first_operand, conv);
             }

code/IFCCurve.cpp → code/Importer/IFC/IFCCurve.cpp

@@ -57,7 +57,7 @@ namespace {
 class Conic : public Curve {
 public:
     // --------------------------------------------------
-    Conic(const IfcConic& entity, ConversionData& conv)
+    Conic(const Schema_2x3::IfcConic& entity, ConversionData& conv)
     : Curve(entity,conv) {
         IfcMatrix4 trafo;
         ConvertAxisPlacement(trafo,*entity.Position,conv);
@@ -103,7 +103,7 @@ protected:
 class Circle : public Conic {
 public:
     // --------------------------------------------------
-    Circle(const IfcCircle& entity, ConversionData& conv)
+    Circle(const Schema_2x3::IfcCircle& entity, ConversionData& conv)
         : Conic(entity,conv)
         , entity(entity)
     {
@@ -117,17 +117,16 @@ public:
     }
 
 private:
-    const IfcCircle& entity;
+    const Schema_2x3::IfcCircle& entity;
 };
 
-
 // --------------------------------------------------------------------------------
 // Ellipse
 // --------------------------------------------------------------------------------
 class Ellipse : public Conic {
 public:
     // --------------------------------------------------
-    Ellipse(const IfcEllipse& entity, ConversionData& conv)
+    Ellipse(const Schema_2x3::IfcEllipse& entity, ConversionData& conv)
     : Conic(entity,conv)
     , entity(entity) {
         // empty
@@ -141,7 +140,7 @@ public:
     }
 
 private:
-    const IfcEllipse& entity;
+    const Schema_2x3::IfcEllipse& entity;
 };
 
 // --------------------------------------------------------------------------------
@@ -150,7 +149,7 @@ private:
 class Line : public Curve {
 public:
     // --------------------------------------------------
-    Line(const IfcLine& entity, ConversionData& conv)
+    Line(const Schema_2x3::IfcLine& entity, ConversionData& conv)
     : Curve(entity,conv) {
         ConvertCartesianPoint(p,entity.Pnt);
         ConvertVector(v,entity.Dir);
@@ -181,12 +180,12 @@ public:
         ai_assert( InRange( b ) );
 
         if (a == b) {
-            out.verts.push_back(Eval(a));
+            out.mVerts.push_back(Eval(a));
             return;
         }
-        out.verts.reserve(out.verts.size()+2);
-        out.verts.push_back(Eval(a));
-        out.verts.push_back(Eval(b));
+        out.mVerts.reserve(out.mVerts.size()+2);
+        out.mVerts.push_back(Eval(a));
+        out.mVerts.push_back(Eval(b));
     }
 
     // --------------------------------------------------
@@ -208,11 +207,11 @@ class CompositeCurve : public BoundedCurve {
 
 public:
     // --------------------------------------------------
-    CompositeCurve(const IfcCompositeCurve& entity, ConversionData& conv)
+    CompositeCurve(const Schema_2x3::IfcCompositeCurve& entity, ConversionData& conv)
     : BoundedCurve(entity,conv)
     , total() {
         curves.reserve(entity.Segments.size());
-        for(const IfcCompositeCurveSegment& curveSegment :entity.Segments) {
+        for(const Schema_2x3::IfcCompositeCurveSegment& curveSegment :entity.Segments) {
             // according to the specification, this must be a bounded curve
             std::shared_ptr< Curve > cv(Curve::Convert(curveSegment.ParentCurve,conv));
             std::shared_ptr< BoundedCurve > bc = std::dynamic_pointer_cast<BoundedCurve>(cv);
@@ -282,14 +281,14 @@ public:
         ai_assert( InRange( b ) );
 
         const size_t cnt = EstimateSampleCount(a,b);
-        out.verts.reserve(out.verts.size() + cnt);
+        out.mVerts.reserve(out.mVerts.size() + cnt);
 
         for(const CurveEntry& entry : curves) {
-            const size_t cnt = out.verts.size();
+            const size_t cnt = out.mVerts.size();
             entry.first->SampleDiscrete(out);
 
-            if (!entry.second && cnt != out.verts.size()) {
-                std::reverse(out.verts.begin()+cnt,out.verts.end());
+            if (!entry.second && cnt != out.mVerts.size()) {
+                std::reverse(out.mVerts.begin()+cnt,out.mVerts.end());
             }
         }
     }
@@ -310,7 +309,7 @@ private:
 class TrimmedCurve : public BoundedCurve {
 public:
     // --------------------------------------------------
-    TrimmedCurve(const IfcTrimmedCurve& entity, ConversionData& conv)
+    TrimmedCurve(const Schema_2x3::IfcTrimmedCurve& entity, ConversionData& conv)
         : BoundedCurve(entity,conv)
     {
         base = std::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv));
@@ -325,12 +324,12 @@ public:
         bool have_param = false, have_point = false;
         IfcVector3 point;
         for(const Entry sel :entity.Trim1) {
-            if (const EXPRESS::REAL* const r = sel->ToPtr<EXPRESS::REAL>()) {
+            if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                 range.first = *r;
                 have_param = true;
                 break;
             }
-            else if (const IfcCartesianPoint* const r = sel->ResolveSelectPtr<IfcCartesianPoint>(conv.db)) {
+            else if (const Schema_2x3::IfcCartesianPoint* const r = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
                 ConvertCartesianPoint(point,*r);
                 have_point = true;
             }
@@ -342,12 +341,12 @@ public:
         }
         have_param = false, have_point = false;
         for(const Entry sel :entity.Trim2) {
-            if (const EXPRESS::REAL* const r = sel->ToPtr<EXPRESS::REAL>()) {
+            if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                 range.second = *r;
                 have_param = true;
                 break;
             }
-            else if (const IfcCartesianPoint* const r = sel->ResolveSelectPtr<IfcCartesianPoint>(conv.db)) {
+            else if (const Schema_2x3::IfcCartesianPoint* const r = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
                 ConvertCartesianPoint(point,*r);
                 have_point = true;
             }
@@ -420,13 +419,13 @@ private:
 class PolyLine : public BoundedCurve {
 public:
     // --------------------------------------------------
-    PolyLine(const IfcPolyline& entity, ConversionData& conv)
+    PolyLine(const Schema_2x3::IfcPolyline& entity, ConversionData& conv)
         : BoundedCurve(entity,conv)
     {
         points.reserve(entity.Points.size());
 
         IfcVector3 t;
-        for(const IfcCartesianPoint& cp : entity.Points) {
+        for(const Schema_2x3::IfcCartesianPoint& cp : entity.Points) {
             ConvertCartesianPoint(t,cp);
             points.push_back(t);
         }
@@ -463,29 +462,29 @@ private:
 } // anon
 
 // ------------------------------------------------------------------------------------------------
-Curve* Curve::Convert(const IFC::IfcCurve& curve,ConversionData& conv) {
-    if(curve.ToPtr<IfcBoundedCurve>()) {
-        if(const IfcPolyline* c = curve.ToPtr<IfcPolyline>()) {
+Curve* Curve::Convert(const IFC::Schema_2x3::IfcCurve& curve,ConversionData& conv) {
+    if(curve.ToPtr<Schema_2x3::IfcBoundedCurve>()) {
+        if(const Schema_2x3::IfcPolyline* c = curve.ToPtr<Schema_2x3::IfcPolyline>()) {
             return new PolyLine(*c,conv);
         }
-        if(const IfcTrimmedCurve* c = curve.ToPtr<IfcTrimmedCurve>()) {
+        if(const Schema_2x3::IfcTrimmedCurve* c = curve.ToPtr<Schema_2x3::IfcTrimmedCurve>()) {
             return new TrimmedCurve(*c,conv);
         }
-        if(const IfcCompositeCurve* c = curve.ToPtr<IfcCompositeCurve>()) {
+        if(const Schema_2x3::IfcCompositeCurve* c = curve.ToPtr<Schema_2x3::IfcCompositeCurve>()) {
             return new CompositeCurve(*c,conv);
         }
     }
 
-    if(curve.ToPtr<IfcConic>()) {
-        if(const IfcCircle* c = curve.ToPtr<IfcCircle>()) {
+    if(curve.ToPtr<Schema_2x3::IfcConic>()) {
+        if(const Schema_2x3::IfcCircle* c = curve.ToPtr<Schema_2x3::IfcCircle>()) {
             return new Circle(*c,conv);
         }
-        if(const IfcEllipse* c = curve.ToPtr<IfcEllipse>()) {
+        if(const Schema_2x3::IfcEllipse* c = curve.ToPtr<Schema_2x3::IfcEllipse>()) {
             return new Ellipse(*c,conv);
         }
     }
 
-    if(const IfcLine* c = curve.ToPtr<IfcLine>()) {
+    if(const Schema_2x3::IfcLine* c = curve.ToPtr<Schema_2x3::IfcLine>()) {
         return new Line(*c,conv);
     }
 
@@ -589,11 +588,11 @@ void Curve::SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
     ai_assert( InRange( b ) );
 
     const size_t cnt = std::max(static_cast<size_t>(0),EstimateSampleCount(a,b));
-    out.verts.reserve( out.verts.size() + cnt + 1);
+    out.mVerts.reserve( out.mVerts.size() + cnt + 1);
 
     IfcFloat p = a, delta = (b-a)/cnt;
     for(size_t i = 0; i <= cnt; ++i, p += delta) {
-        out.verts.push_back(Eval(p));
+        out.mVerts.push_back(Eval(p));
     }
 }
 

code/IFCGeometry.cpp → code/Importer/IFC/IFCGeometry.cpp

@@ -46,8 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 #include "IFCUtil.h"
-#include "PolyTools.h"
-#include "ProcessHelper.h"
+#include "code/PolyTools.h"
+#include "code/ProcessHelper.h"
 
 #include "../contrib/poly2tri/poly2tri/poly2tri.h"
 #include "../contrib/clipper/clipper.hpp"
@@ -59,27 +59,27 @@ namespace Assimp {
     namespace IFC {
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/)
+bool ProcessPolyloop(const Schema_2x3::IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/)
 {
     size_t cnt = 0;
-    for(const IfcCartesianPoint& c : loop.Polygon) {
+    for(const Schema_2x3::IfcCartesianPoint& c : loop.Polygon) {
         IfcVector3 tmp;
         ConvertCartesianPoint(tmp,c);
 
-        meshout.verts.push_back(tmp);
+        meshout.mVerts.push_back(tmp);
         ++cnt;
     }
 
-    meshout.vertcnt.push_back(static_cast<unsigned int>(cnt));
+    meshout.mVertcnt.push_back(static_cast<unsigned int>(cnt));
 
     // zero- or one- vertex polyloops simply ignored
-    if (meshout.vertcnt.back() > 1) {
+    if (meshout.mVertcnt.back() > 1) {
         return true;
     }
 
-    if (meshout.vertcnt.back()==1) {
-        meshout.vertcnt.pop_back();
-        meshout.verts.pop_back();
+    if (meshout.mVertcnt.back()==1) {
+        meshout.mVertcnt.pop_back();
+        meshout.mVerts.pop_back();
     }
     return false;
 }
@@ -88,19 +88,19 @@ bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData&
 void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t master_bounds = (size_t)-1)
 {
     // handle all trivial cases
-    if(inmesh.vertcnt.empty()) {
+    if(inmesh.mVertcnt.empty()) {
         return;
     }
-    if(inmesh.vertcnt.size() == 1) {
+    if(inmesh.mVertcnt.size() == 1) {
         result.Append(inmesh);
         return;
     }
 
-    ai_assert(std::count(inmesh.vertcnt.begin(), inmesh.vertcnt.end(), 0) == 0);
+    ai_assert(std::count(inmesh.mVertcnt.begin(), inmesh.mVertcnt.end(), 0) == 0);
 
     typedef std::vector<unsigned int>::const_iterator face_iter;
 
-    face_iter begin = inmesh.vertcnt.begin(), end = inmesh.vertcnt.end(), iit;
+    face_iter begin = inmesh.mVertcnt.begin(), end = inmesh.mVertcnt.end(), iit;
     std::vector<unsigned int>::const_iterator outer_polygon_it = end;
 
     // major task here: given a list of nested polygon boundaries (one of which
@@ -119,7 +119,7 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
     // shall be of the type IfcFaceOuterBound'
     IfcFloat area_outer_polygon = 1e-10f;
     if (master_bounds != (size_t)-1) {
-        ai_assert(master_bounds < inmesh.vertcnt.size());
+        ai_assert(master_bounds < inmesh.mVertcnt.size());
         outer_polygon_it = begin + master_bounds;
     }
     else {
@@ -146,9 +146,9 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
     // this is the plane onto which the quadrulate algorithm will
     // project the entire mesh.
     std::vector<TempOpening> fake_openings;
-    fake_openings.reserve(inmesh.vertcnt.size()-1);
+    fake_openings.reserve(inmesh.mVertcnt.size()-1);
 
-    std::vector<IfcVector3>::const_iterator vit = inmesh.verts.begin(), outer_vit;
+    std::vector<IfcVector3>::const_iterator vit = inmesh.mVerts.begin(), outer_vit;
 
     for(iit = begin; iit != end; vit += *iit++) {
         if (iit == outer_polygon_it) {
@@ -171,32 +171,32 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
         opening.solid = NULL;
 
         opening.profileMesh = std::make_shared<TempMesh>();
-        opening.profileMesh->verts.reserve(*iit);
-        opening.profileMesh->vertcnt.push_back(*iit);
+        opening.profileMesh->mVerts.reserve(*iit);
+        opening.profileMesh->mVertcnt.push_back(*iit);
 
-        std::copy(vit, vit + *iit, std::back_inserter(opening.profileMesh->verts));
+        std::copy(vit, vit + *iit, std::back_inserter(opening.profileMesh->mVerts));
     }
 
     // fill a mesh with ONLY the main polygon
     TempMesh temp;
-    temp.verts.reserve(outer_polygon_size);
-    temp.vertcnt.push_back(static_cast<unsigned int>(outer_polygon_size));
+    temp.mVerts.reserve(outer_polygon_size);
+    temp.mVertcnt.push_back(static_cast<unsigned int>(outer_polygon_size));
     std::copy(outer_vit, outer_vit+outer_polygon_size,
-        std::back_inserter(temp.verts));
+        std::back_inserter(temp.mVerts));
 
     GenerateOpenings(fake_openings, normals, temp, false, false);
     result.Append(temp);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result, ConversionData& conv)
+void ProcessConnectedFaceSet(const Schema_2x3::IfcConnectedFaceSet& fset, TempMesh& result, ConversionData& conv)
 {
-    for(const IfcFace& face : fset.CfsFaces) {
+    for(const Schema_2x3::IfcFace& face : fset.CfsFaces) {
         // size_t ob = -1, cnt = 0;
         TempMesh meshout;
-        for(const IfcFaceBound& bound : face.Bounds) {
+        for(const Schema_2x3::IfcFaceBound& bound : face.Bounds) {
 
-            if(const IfcPolyLoop* const polyloop = bound.Bound->ToPtr<IfcPolyLoop>()) {
+            if(const Schema_2x3::IfcPolyLoop* const polyloop = bound.Bound->ToPtr<Schema_2x3::IfcPolyLoop>()) {
                 if(ProcessPolyloop(*polyloop, meshout,conv)) {
 
                     // The outer boundary is better determined by checking which
@@ -230,12 +230,12 @@ void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result,
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& result, ConversionData& conv)
+void ProcessRevolvedAreaSolid(const Schema_2x3::IfcRevolvedAreaSolid& solid, TempMesh& result, ConversionData& conv)
 {
     TempMesh meshout;
 
     // first read the profile description
-    if(!ProcessProfile(*solid.SweptArea,meshout,conv) || meshout.verts.size()<=1) {
+    if(!ProcessProfile(*solid.SweptArea,meshout,conv) || meshout.mVerts.size()<=1) {
         return;
     }
 
@@ -246,7 +246,7 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
     IfcMatrix4::Translation(pos,tb0);
     IfcMatrix4::Translation(-pos,tb1);
 
-    const std::vector<IfcVector3>& in = meshout.verts;
+    const std::vector<IfcVector3>& in = meshout.mVerts;
     const size_t size=in.size();
 
     bool has_area = solid.SweptArea->ProfileType == "AREA" && size>2;
@@ -263,14 +263,14 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
 
     has_area = has_area && std::fabs(max_angle) < AI_MATH_TWO_PI_F*0.99;
 
-    result.verts.reserve(size*((cnt_segments+1)*4+(has_area?2:0)));
-    result.vertcnt.reserve(size*cnt_segments+2);
+    result.mVerts.reserve(size*((cnt_segments+1)*4+(has_area?2:0)));
+    result.mVertcnt.reserve(size*cnt_segments+2);
 
     IfcMatrix4 rot;
     rot = tb0 * IfcMatrix4::Rotation(delta,axis,rot) * tb1;
 
     size_t base = 0;
-    std::vector<IfcVector3>& out = result.verts;
+    std::vector<IfcVector3>& out = result.mVerts;
 
     // dummy data to simplify later processing
     for(size_t i = 0; i < size; ++i) {
@@ -281,7 +281,7 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
         for(size_t i = 0; i < size; ++i) {
             const size_t next = (i+1)%size;
 
-            result.vertcnt.push_back(4);
+            result.mVertcnt.push_back(4);
             const IfcVector3 base_0 = out[base+i*4+3],base_1 = out[base+next*4+3];
 
             out.push_back(base_0);
@@ -305,8 +305,8 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
         for(size_t i = 0; i < size; ++i ) {
             out.push_back(out[i*4]);
         }
-        result.vertcnt.push_back(static_cast<unsigned int>(size));
-        result.vertcnt.push_back(static_cast<unsigned int>(size));
+        result.mVertcnt.push_back(static_cast<unsigned int>(size));
+        result.mVertcnt.push_back(static_cast<unsigned int>(size));
     }
 
     IfcMatrix4 trafo;
@@ -316,10 +316,8 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
     IFCImporter::LogDebug("generate mesh procedurally by radial extrusion (IfcRevolvedAreaSolid)");
 }
 
-
-
 // ------------------------------------------------------------------------------------------------
-void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, ConversionData& conv)
+void ProcessSweptDiskSolid(const Schema_2x3::IfcSweptDiskSolid solid, TempMesh& result, ConversionData& conv)
 {
     const Curve* const curve = Curve::Convert(*solid.Directrix, conv);
     if(!curve) {
@@ -332,12 +330,12 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv
 
 	TempMesh temp;
 	curve->SampleDiscrete(temp, solid.StartParam, solid.EndParam);
-	const std::vector<IfcVector3>& curve_points = temp.verts;
+	const std::vector<IfcVector3>& curve_points = temp.mVerts;
 
     const size_t samples = curve_points.size();
 
-    result.verts.reserve(cnt_segments * samples * 4);
-    result.vertcnt.reserve((cnt_segments - 1) * samples);
+    result.mVerts.reserve(cnt_segments * samples * 4);
+    result.mVertcnt.reserve((cnt_segments - 1) * samples);
 
     std::vector<IfcVector3> points;
     points.reserve(cnt_segments * samples);
@@ -434,22 +432,22 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv
 
         for (unsigned int seg = 0; seg < cnt_segments; ++seg) {
 
-            result.verts.push_back(points[ i * cnt_segments + (seg % cnt_segments)]);
-            result.verts.push_back(points[ i * cnt_segments + (seg + 1) % cnt_segments]);
-            result.verts.push_back(points[ (i+1) * cnt_segments + ((seg + 1 + best_pair_offset) % cnt_segments)]);
-            result.verts.push_back(points[ (i+1) * cnt_segments + ((seg + best_pair_offset) % cnt_segments)]);
+            result.mVerts.push_back(points[ i * cnt_segments + (seg % cnt_segments)]);
+            result.mVerts.push_back(points[ i * cnt_segments + (seg + 1) % cnt_segments]);
+            result.mVerts.push_back(points[ (i+1) * cnt_segments + ((seg + 1 + best_pair_offset) % cnt_segments)]);
+            result.mVerts.push_back(points[ (i+1) * cnt_segments + ((seg + best_pair_offset) % cnt_segments)]);
 
-            IfcVector3& v1 = *(result.verts.end()-1);
-            IfcVector3& v2 = *(result.verts.end()-2);
-            IfcVector3& v3 = *(result.verts.end()-3);
-            IfcVector3& v4 = *(result.verts.end()-4);
+            IfcVector3& v1 = *(result.mVerts.end()-1);
+            IfcVector3& v2 = *(result.mVerts.end()-2);
+            IfcVector3& v3 = *(result.mVerts.end()-3);
+            IfcVector3& v4 = *(result.mVerts.end()-4);
 
             if (((v4-v3) ^ (v4-v1)) * (v4 - curve_points[i]) < 0.0f) {
                 std::swap(v4, v1);
                 std::swap(v3, v2);
             }
 
-            result.vertcnt.push_back(4);
+            result.mVertcnt.push_back(4);
         }
     }
 
@@ -459,14 +457,15 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv
 // ------------------------------------------------------------------------------------------------
 IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVector3& norOut)
 {
-    const std::vector<IfcVector3>& out = curmesh.verts;
+    const std::vector<IfcVector3>& out = curmesh.mVerts;
     IfcMatrix3 m;
 
     ok = true;
 
     // The input "mesh" must be a single polygon
     const size_t s = out.size();
-    assert(curmesh.vertcnt.size() == 1 && curmesh.vertcnt.back() == s);
+    ai_assert( curmesh.mVertcnt.size() == 1 );
+    ai_assert( curmesh.mVertcnt.back() == s);
 
     const IfcVector3 any_point = out[s-1];
     IfcVector3 nor;
@@ -477,9 +476,10 @@ IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVect
     // axis for the 2D coordinate space on the polygon plane, exploiting the
     // fact that the input polygon is nearly always a quad.
     bool done = false;
-    size_t i, j;
-    for (i = 0; !done && i < s-2; done || ++i) {
-        for (j = i+1; j < s-1; ++j) {
+    size_t idx( 0 );
+    for (size_t i = 0; !done && i < s-2; done || ++i) {
+        idx = i;
+        for (size_t j = i+1; j < s-1; ++j) {
             nor = -((out[i]-any_point)^(out[j]-any_point));
             if(std::fabs(nor.Length()) > 1e-8f) {
                 done = true;
@@ -496,7 +496,7 @@ IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVect
     nor.Normalize();
     norOut = nor;
 
-    IfcVector3 r = (out[i]-any_point);
+    IfcVector3 r = (out[idx]-any_point);
     r.Normalize();
 
     //if(d) {
@@ -524,12 +524,12 @@ IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVect
 }
 
 // Extrudes the given polygon along the direction, converts it into an opening or applies all openings as necessary.
-void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curve,
+void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const TempMesh& curve,
     const IfcVector3& extrusionDir, TempMesh& result, ConversionData &conv, bool collect_openings)
 {
     // Outline: 'curve' is now a list of vertex points forming the underlying profile, extrude along the given axis,
     // forming new triangles.
-    const bool has_area = solid.SweptArea->ProfileType == "AREA" && curve.verts.size() > 2;
+    const bool has_area = solid.SweptArea->ProfileType == "AREA" && curve.mVerts.size() > 2;
     if( solid.Depth < 1e-6 ) {
         if( has_area ) {
             result.Append(curve);
@@ -537,9 +537,9 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
         return;
     }
 
-    result.verts.reserve(curve.verts.size()*(has_area ? 4 : 2));
-    result.vertcnt.reserve(curve.verts.size() + 2);
-    std::vector<IfcVector3> in = curve.verts;
+    result.mVerts.reserve(curve.mVerts.size()*(has_area ? 4 : 2));
+    result.mVertcnt.reserve(curve.mVerts.size() + 2);
+    std::vector<IfcVector3> in = curve.mVerts;
 
     // First step: transform all vertices into the target coordinate space
     IfcMatrix4 trafo;
@@ -582,24 +582,24 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
         for(TempOpening& t : *conv.apply_openings) {
             TempMesh& bounds = *t.profileMesh.get();
 
-            if( bounds.verts.size() <= 2 ) {
+            if( bounds.mVerts.size() <= 2 ) {
                 nors.push_back(IfcVector3());
                 continue;
             }
-            nors.push_back(((bounds.verts[2] - bounds.verts[0]) ^ (bounds.verts[1] - bounds.verts[0])).Normalize());
+            nors.push_back(((bounds.mVerts[2] - bounds.mVerts[0]) ^ (bounds.mVerts[1] - bounds.mVerts[0])).Normalize());
         }
     }
 
 
     TempMesh temp;
     TempMesh& curmesh = openings ? temp : result;
-    std::vector<IfcVector3>& out = curmesh.verts;
+    std::vector<IfcVector3>& out = curmesh.mVerts;
 
     size_t sides_with_openings = 0;
     for( size_t i = 0; i < in.size(); ++i ) {
         const size_t next = (i + 1) % in.size();
 
-        curmesh.vertcnt.push_back(4);
+        curmesh.mVertcnt.push_back(4);
 
         out.push_back(in[i]);
         out.push_back(in[next]);
@@ -638,7 +638,7 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
                     out.push_back(in[i]);
             }
 
-            curmesh.vertcnt.push_back(static_cast<unsigned int>(in.size()));
+            curmesh.mVertcnt.push_back(static_cast<unsigned int>(in.size()));
             if( openings && in.size() > 2 ) {
                 if( GenerateOpenings(*conv.apply_openings, nors, temp, true, true, dir) ) {
                     ++sides_with_v_openings;
@@ -664,8 +664,8 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
         profile->Swap(result);
 
         std::shared_ptr<TempMesh> profile2D = std::shared_ptr<TempMesh>(new TempMesh());
-        profile2D->verts.insert(profile2D->verts.end(), in.begin(), in.end());
-        profile2D->vertcnt.push_back(static_cast<unsigned int>(in.size()));
+        profile2D->mVerts.insert(profile2D->mVerts.end(), in.begin(), in.end());
+        profile2D->mVertcnt.push_back(static_cast<unsigned int>(in.size()));
         conv.collect_openings->push_back(TempOpening(&solid, dir, profile, profile2D));
 
         ai_assert(result.IsEmpty());
@@ -673,13 +673,13 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& result,
+void ProcessExtrudedAreaSolid(const Schema_2x3::IfcExtrudedAreaSolid& solid, TempMesh& result,
     ConversionData& conv, bool collect_openings)
 {
     TempMesh meshout;
 
     // First read the profile description.
-    if(!ProcessProfile(*solid.SweptArea,meshout,conv) || meshout.verts.size()<=1) {
+    if(!ProcessProfile(*solid.SweptArea,meshout,conv) || meshout.mVerts.size()<=1) {
         return;
     }
 
@@ -691,13 +691,13 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul
     // and there's still so many corner cases uncovered - we really need a generic solution to all of this hole carving.
     std::vector<TempOpening> fisherPriceMyFirstOpenings;
     std::vector<TempOpening>* oldApplyOpenings = conv.apply_openings;
-    if( const IfcArbitraryProfileDefWithVoids* const cprofile = solid.SweptArea->ToPtr<IfcArbitraryProfileDefWithVoids>() ) {
+    if( const Schema_2x3::IfcArbitraryProfileDefWithVoids* const cprofile = solid.SweptArea->ToPtr<Schema_2x3::IfcArbitraryProfileDefWithVoids>() ) {
         if( !cprofile->InnerCurves.empty() ) {
             // read all inner curves and extrude them to form proper openings.
             std::vector<TempOpening>* oldCollectOpenings = conv.collect_openings;
             conv.collect_openings = &fisherPriceMyFirstOpenings;
 
-            for(const IfcCurve* curve : cprofile->InnerCurves) {
+            for (const Schema_2x3::IfcCurve* curve : cprofile->InnerCurves) {
                 TempMesh curveMesh, tempMesh;
                 ProcessCurve(*curve, curveMesh, conv);
                 ProcessExtrudedArea(solid, curveMesh, dir, tempMesh, conv, true);
@@ -713,13 +713,13 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout,
+void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh& meshout,
     ConversionData& conv)
 {
-    if(const IfcExtrudedAreaSolid* const solid = swept.ToPtr<IfcExtrudedAreaSolid>()) {
+    if(const Schema_2x3::IfcExtrudedAreaSolid* const solid = swept.ToPtr<Schema_2x3::IfcExtrudedAreaSolid>()) {
         ProcessExtrudedAreaSolid(*solid,meshout,conv, !!conv.collect_openings);
     }
-    else if(const IfcRevolvedAreaSolid* const rev = swept.ToPtr<IfcRevolvedAreaSolid>()) {
+    else if(const Schema_2x3::IfcRevolvedAreaSolid* const rev = swept.ToPtr<Schema_2x3::IfcRevolvedAreaSolid>()) {
         ProcessRevolvedAreaSolid(*rev,meshout,conv);
     }
     else {
@@ -728,16 +728,16 @@ void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout,
 }
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid, std::vector<unsigned int>& mesh_indices,
+bool ProcessGeometricItem(const Schema_2x3::IfcRepresentationItem& geo, unsigned int matid, std::vector<unsigned int>& mesh_indices,
     ConversionData& conv)
 {
     bool fix_orientation = false;
     std::shared_ptr< TempMesh > meshtmp = std::make_shared<TempMesh>();
-    if(const IfcShellBasedSurfaceModel* shellmod = geo.ToPtr<IfcShellBasedSurfaceModel>()) {
-        for(std::shared_ptr<const IfcShell> shell :shellmod->SbsmBoundary) {
+    if(const Schema_2x3::IfcShellBasedSurfaceModel* shellmod = geo.ToPtr<Schema_2x3::IfcShellBasedSurfaceModel>()) {
+        for(std::shared_ptr<const Schema_2x3::IfcShell> shell :shellmod->SbsmBoundary) {
             try {
-                const EXPRESS::ENTITY& e = shell->To<ENTITY>();
-                const IfcConnectedFaceSet& fs = conv.db.MustGetObject(e).To<IfcConnectedFaceSet>();
+                const ::Assimp::STEP::EXPRESS::ENTITY& e = shell->To<::Assimp::STEP::EXPRESS::ENTITY>();
+                const Schema_2x3::IfcConnectedFaceSet& fs = conv.db.MustGetObject(e).To<Schema_2x3::IfcConnectedFaceSet>();
 
                 ProcessConnectedFaceSet(fs,*meshtmp.get(),conv);
             }
@@ -747,30 +747,30 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid,
         }
         fix_orientation = true;
     }
-    else  if(const IfcConnectedFaceSet* fset = geo.ToPtr<IfcConnectedFaceSet>()) {
+    else  if(const Schema_2x3::IfcConnectedFaceSet* fset = geo.ToPtr<Schema_2x3::IfcConnectedFaceSet>()) {
         ProcessConnectedFaceSet(*fset,*meshtmp.get(),conv);
         fix_orientation = true;
     }
-    else  if(const IfcSweptAreaSolid* swept = geo.ToPtr<IfcSweptAreaSolid>()) {
+    else  if(const Schema_2x3::IfcSweptAreaSolid* swept = geo.ToPtr<Schema_2x3::IfcSweptAreaSolid>()) {
         ProcessSweptAreaSolid(*swept,*meshtmp.get(),conv);
     }
-    else  if(const IfcSweptDiskSolid* disk = geo.ToPtr<IfcSweptDiskSolid>()) {
+    else  if(const Schema_2x3::IfcSweptDiskSolid* disk = geo.ToPtr<Schema_2x3::IfcSweptDiskSolid>()) {
         ProcessSweptDiskSolid(*disk,*meshtmp.get(),conv);
     }
-    else if(const IfcManifoldSolidBrep* brep = geo.ToPtr<IfcManifoldSolidBrep>()) {
+    else if(const Schema_2x3::IfcManifoldSolidBrep* brep = geo.ToPtr<Schema_2x3::IfcManifoldSolidBrep>()) {
         ProcessConnectedFaceSet(brep->Outer,*meshtmp.get(),conv);
         fix_orientation = true;
     }
-    else if(const IfcFaceBasedSurfaceModel* surf = geo.ToPtr<IfcFaceBasedSurfaceModel>()) {
-        for(const IfcConnectedFaceSet& fc : surf->FbsmFaces) {
+    else if(const Schema_2x3::IfcFaceBasedSurfaceModel* surf = geo.ToPtr<Schema_2x3::IfcFaceBasedSurfaceModel>()) {
+        for(const Schema_2x3::IfcConnectedFaceSet& fc : surf->FbsmFaces) {
             ProcessConnectedFaceSet(fc,*meshtmp.get(),conv);
         }
         fix_orientation = true;
     }
-    else  if(const IfcBooleanResult* boolean = geo.ToPtr<IfcBooleanResult>()) {
+    else  if(const Schema_2x3::IfcBooleanResult* boolean = geo.ToPtr<Schema_2x3::IfcBooleanResult>()) {
         ProcessBoolean(*boolean,*meshtmp.get(),conv);
     }
-    else if(geo.ToPtr<IfcBoundingBox>()) {
+    else if(geo.ToPtr<Schema_2x3::IfcBoundingBox>()) {
         // silently skip over bounding boxes
         return false;
     }
@@ -788,7 +788,7 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid,
     // which returns an empty mesh.
     if(conv.collect_openings) {
         if (!meshtmp->IsEmpty()) {
-            conv.collect_openings->push_back(TempOpening(geo.ToPtr<IfcSolidModel>(),
+            conv.collect_openings->push_back(TempOpening(geo.ToPtr<Schema_2x3::IfcSolidModel>(),
                 IfcVector3(0,0,0),
                 meshtmp,
                 std::shared_ptr<TempMesh>()));
@@ -837,7 +837,7 @@ void AssignAddedMeshes(std::vector<unsigned int>& mesh_indices,aiNode* nd,
 }
 
 // ------------------------------------------------------------------------------------------------
-bool TryQueryMeshCache(const IfcRepresentationItem& item,
+bool TryQueryMeshCache(const Schema_2x3::IfcRepresentationItem& item,
     std::vector<unsigned int>& mesh_indices, unsigned int mat_index,
     ConversionData& conv)
 {
@@ -851,7 +851,7 @@ bool TryQueryMeshCache(const IfcRepresentationItem& item,
 }
 
 // ------------------------------------------------------------------------------------------------
-void PopulateMeshCache(const IfcRepresentationItem& item,
+void PopulateMeshCache(const Schema_2x3::IfcRepresentationItem& item,
     const std::vector<unsigned int>& mesh_indices, unsigned int mat_index,
     ConversionData& conv)
 {
@@ -860,7 +860,7 @@ void PopulateMeshCache(const IfcRepresentationItem& item,
 }
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessRepresentationItem(const IfcRepresentationItem& item, unsigned int matid,
+bool ProcessRepresentationItem(const Schema_2x3::IfcRepresentationItem& item, unsigned int matid,
     std::vector<unsigned int>& mesh_indices,
     ConversionData& conv)
 {

code/IFCLoader.cpp → code/Importer/IFC/IFCLoader.cpp

@@ -59,7 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "IFCUtil.h"
 
-#include "MemoryIOWrapper.h"
+#include "code/MemoryIOWrapper.h"
 #include <assimp/scene.h>
 #include <assimp/Importer.hpp>
 #include <assimp/importerdesc.h>
@@ -99,7 +99,7 @@ void SetUnits(ConversionData& conv);
 void SetCoordinateSpace(ConversionData& conv);
 void ProcessSpatialStructures(ConversionData& conv);
 void MakeTreeRelative(ConversionData& conv);
-void ConvertUnit(const EXPRESS::DataType& dt,ConversionData& conv);
+void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType& dt,ConversionData& conv);
 
 } // anon
 
@@ -152,7 +152,6 @@ const aiImporterDesc* IFCImporter::GetInfo () const
     return &desc;
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
 void IFCImporter::SetupProperties(const Importer* pImp)
@@ -167,8 +166,7 @@ void IFCImporter::SetupProperties(const Importer* pImp)
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void IFCImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
+void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
 {
     std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
     if (!stream) {
@@ -253,8 +251,8 @@ void IFCImporter::InternReadFile( const std::string& pFile,
     }
 
     // obtain a copy of the machine-generated IFC scheme
-    EXPRESS::ConversionSchema schema;
-    GetSchema(schema);
+    ::Assimp::STEP::EXPRESS::ConversionSchema schema;
+    Schema_2x3::GetSchema(schema);
 
     // tell the reader which entity types to track with special care
     static const char* const types_to_track[] = {
@@ -273,7 +271,7 @@ void IFCImporter::InternReadFile( const std::string& pFile,
         ThrowException("missing IfcProject entity");
     }
 
-    ConversionData conv(*db,proj->To<IfcProject>(),pScene,settings);
+    ConversionData conv(*db,proj->To<Schema_2x3::IfcProject>(),pScene,settings);
     SetUnits(conv);
     SetCoordinateSpace(conv);
     ProcessSpatialStructures(conv);
@@ -323,10 +321,9 @@ namespace {
 
 
 // ------------------------------------------------------------------------------------------------
-void ConvertUnit(const IfcNamedUnit& unit,ConversionData& conv)
+void ConvertUnit(const Schema_2x3::IfcNamedUnit& unit,ConversionData& conv)
 {
-    if(const IfcSIUnit* const si = unit.ToPtr<IfcSIUnit>()) {
-
+    if(const Schema_2x3::IfcSIUnit* const si = unit.ToPtr<Schema_2x3::IfcSIUnit>()) {
         if(si->UnitType == "LENGTHUNIT") {
             conv.len_scale = si->Prefix ? ConvertSIPrefix(si->Prefix) : 1.f;
             IFCImporter::LogDebug("got units used for lengths");
@@ -337,11 +334,10 @@ void ConvertUnit(const IfcNamedUnit& unit,ConversionData& conv)
             }
         }
     }
-    else if(const IfcConversionBasedUnit* const convu = unit.ToPtr<IfcConversionBasedUnit>()) {
-
+    else if(const Schema_2x3::IfcConversionBasedUnit* const convu = unit.ToPtr<Schema_2x3::IfcConversionBasedUnit>()) {
         if(convu->UnitType == "PLANEANGLEUNIT") {
             try {
-                conv.angle_scale = convu->ConversionFactor->ValueComponent->To<EXPRESS::REAL>();
+                conv.angle_scale = convu->ConversionFactor->ValueComponent->To<::Assimp::STEP::EXPRESS::REAL>();
                 ConvertUnit(*convu->ConversionFactor->UnitComponent,conv);
                 IFCImporter::LogDebug("got units used for angles");
             }
@@ -353,12 +349,12 @@ void ConvertUnit(const IfcNamedUnit& unit,ConversionData& conv)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertUnit(const EXPRESS::DataType& dt,ConversionData& conv)
+void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType& dt,ConversionData& conv)
 {
     try {
-        const EXPRESS::ENTITY& e = dt.To<ENTITY>();
+        const ::Assimp::STEP::EXPRESS::ENTITY& e = dt.To<::Assimp::STEP::EXPRESS::ENTITY>();
 
-        const IfcNamedUnit& unit = e.ResolveSelect<IfcNamedUnit>(conv.db);
+        const Schema_2x3::IfcNamedUnit& unit = e.ResolveSelect<Schema_2x3::IfcNamedUnit>(conv.db);
         if(unit.UnitType != "LENGTHUNIT" && unit.UnitType != "PLANEANGLEUNIT") {
             return;
         }
@@ -384,8 +380,8 @@ void SetUnits(ConversionData& conv)
 // ------------------------------------------------------------------------------------------------
 void SetCoordinateSpace(ConversionData& conv)
 {
-    const IfcRepresentationContext* fav = NULL;
-    for(const IfcRepresentationContext& v : conv.proj.RepresentationContexts) {
+    const Schema_2x3::IfcRepresentationContext* fav = NULL;
+    for(const Schema_2x3::IfcRepresentationContext& v : conv.proj.RepresentationContexts) {
         fav = &v;
         // Model should be the most suitable type of context, hence ignore the others
         if (v.ContextType && v.ContextType.Get() == "Model") {
@@ -393,7 +389,7 @@ void SetCoordinateSpace(ConversionData& conv)
         }
     }
     if (fav) {
-        if(const IfcGeometricRepresentationContext* const geo = fav->ToPtr<IfcGeometricRepresentationContext>()) {
+        if(const Schema_2x3::IfcGeometricRepresentationContext* const geo = fav->ToPtr<Schema_2x3::IfcGeometricRepresentationContext>()) {
             ConvertAxisPlacement(conv.wcs, *geo->WorldCoordinateSystem, conv);
             IFCImporter::LogDebug("got world coordinate system");
         }
@@ -402,9 +398,9 @@ void SetCoordinateSpace(ConversionData& conv)
 
 
 // ------------------------------------------------------------------------------------------------
-void ResolveObjectPlacement(aiMatrix4x4& m, const IfcObjectPlacement& place, ConversionData& conv)
+void ResolveObjectPlacement(aiMatrix4x4& m, const Schema_2x3::IfcObjectPlacement& place, ConversionData& conv)
 {
-    if (const IfcLocalPlacement* const local = place.ToPtr<IfcLocalPlacement>()){
+    if (const Schema_2x3::IfcLocalPlacement* const local = place.ToPtr<Schema_2x3::IfcLocalPlacement>()){
         IfcMatrix4 tmp;
         ConvertAxisPlacement(tmp, *local->RelativePlacement, conv);
 
@@ -422,9 +418,9 @@ void ResolveObjectPlacement(aiMatrix4x4& m, const IfcObjectPlacement& place, Con
 }
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< aiNode* >& subnodes_src, unsigned int matid, ConversionData& conv)
+bool ProcessMappedItem(const Schema_2x3::IfcMappedItem& mapped, aiNode* nd_src, std::vector< aiNode* >& subnodes_src, unsigned int matid, ConversionData& conv)
 {
-    // insert a custom node here, the cartesian transform operator is simply a conventional transformation matrix
+    // insert a custom node here, the carthesian transform operator is simply a conventional transformation matrix
     std::unique_ptr<aiNode> nd(new aiNode());
     nd->mName.Set("IfcMappedItem");
 
@@ -448,10 +444,10 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector<
     }
 
     unsigned int localmatid = ProcessMaterials(mapped.GetID(),matid,conv,false);
-    const IfcRepresentation& repr = mapped.MappingSource->MappedRepresentation;
+    const Schema_2x3::IfcRepresentation& repr = mapped.MappingSource->MappedRepresentation;
 
     bool got = false;
-    for(const IfcRepresentationItem& item : repr.Items) {
+    for(const Schema_2x3::IfcRepresentationItem& item : repr.Items) {
         if(!ProcessRepresentationItem(item,localmatid,meshes,conv)) {
             IFCImporter::LogWarn("skipping mapped entity of type " + item.GetClassName() + ", no representations could be generated");
         }
@@ -483,8 +479,7 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector<
 
 // ------------------------------------------------------------------------------------------------
 struct RateRepresentationPredicate {
-
-    int Rate(const IfcRepresentation* r) const {
+    int Rate(const Schema_2x3::IfcRepresentation* r) const {
         // the smaller, the better
 
         if (! r->RepresentationIdentifier) {
@@ -497,7 +492,7 @@ struct RateRepresentationPredicate {
         if (name == "MappedRepresentation") {
             if (!r->Items.empty()) {
                 // take the first item and base our choice on it
-                const IfcMappedItem* const m = r->Items.front()->ToPtr<IfcMappedItem>();
+                const Schema_2x3::IfcMappedItem* const m = r->Items.front()->ToPtr<Schema_2x3::IfcMappedItem>();
                 if (m) {
                     return Rate(m->MappingSource->MappedRepresentation);
                 }
@@ -509,8 +504,6 @@ struct RateRepresentationPredicate {
     }
 
     int Rate(const std::string& r) const {
-
-
         if (r == "SolidModel") {
             return -3;
         }
@@ -541,13 +534,13 @@ struct RateRepresentationPredicate {
         return 0;
     }
 
-    bool operator() (const IfcRepresentation* a, const IfcRepresentation* b) const {
+    bool operator() (const Schema_2x3::IfcRepresentation* a, const Schema_2x3::IfcRepresentation* b) const {
         return Rate(a) < Rate(b);
     }
 };
 
 // ------------------------------------------------------------------------------------------------
-void ProcessProductRepresentation(const IfcProduct& el, aiNode* nd, std::vector< aiNode* >& subnodes, ConversionData& conv)
+void ProcessProductRepresentation(const Schema_2x3::IfcProduct& el, aiNode* nd, std::vector< aiNode* >& subnodes, ConversionData& conv)
 {
     if(!el.Representation) {
         return;
@@ -562,14 +555,14 @@ void ProcessProductRepresentation(const IfcProduct& el, aiNode* nd, std::vector<
     // representation is relatively generic and allows the concrete implementations
     // for the different representation types to make some sensible choices what
     // to load and what not to load.
-    const STEP::ListOf< STEP::Lazy< IfcRepresentation >, 1, 0 >& src = el.Representation.Get()->Representations;
-    std::vector<const IfcRepresentation*> repr_ordered(src.size());
+    const STEP::ListOf< STEP::Lazy< Schema_2x3::IfcRepresentation >, 1, 0 >& src = el.Representation.Get()->Representations;
+    std::vector<const Schema_2x3::IfcRepresentation*> repr_ordered(src.size());
     std::copy(src.begin(),src.end(),repr_ordered.begin());
     std::sort(repr_ordered.begin(),repr_ordered.end(),RateRepresentationPredicate());
-    for(const IfcRepresentation* repr : repr_ordered) {
+    for(const Schema_2x3::IfcRepresentation* repr : repr_ordered) {
         bool res = false;
-        for(const IfcRepresentationItem& item : repr->Items) {
-            if(const IfcMappedItem* const geo = item.ToPtr<IfcMappedItem>()) {
+        for(const Schema_2x3::IfcRepresentationItem& item : repr->Items) {
+            if(const Schema_2x3::IfcMappedItem* const geo = item.ToPtr<Schema_2x3::IfcMappedItem>()) {
                 res = ProcessMappedItem(*geo,nd,subnodes,matid,conv) || res;
             }
             else {
@@ -587,25 +580,25 @@ void ProcessProductRepresentation(const IfcProduct& el, aiNode* nd, std::vector<
 typedef std::map<std::string, std::string> Metadata;
 
 // ------------------------------------------------------------------------------------------------
-void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionData& conv, Metadata& properties,
+void ProcessMetadata(const Schema_2x3::ListOf< Schema_2x3::Lazy< Schema_2x3::IfcProperty >, 1, 0 >& set, ConversionData& conv, Metadata& properties,
     const std::string& prefix = "",
     unsigned int nest = 0)
 {
-    for(const IfcProperty& property : set) {
+    for(const Schema_2x3::IfcProperty& property : set) {
         const std::string& key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
-        if (const IfcPropertySingleValue* const singleValue = property.ToPtr<IfcPropertySingleValue>()) {
+        if (const Schema_2x3::IfcPropertySingleValue* const singleValue = property.ToPtr<Schema_2x3::IfcPropertySingleValue>()) {
             if (singleValue->NominalValue) {
-                if (const EXPRESS::STRING* str = singleValue->NominalValue.Get()->ToPtr<EXPRESS::STRING>()) {
+                if (const ::Assimp::STEP::EXPRESS::STRING* str = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
                     std::string value = static_cast<std::string>(*str);
                     properties[key]=value;
                 }
-                else if (const EXPRESS::REAL* val = singleValue->NominalValue.Get()->ToPtr<EXPRESS::REAL>()) {
+                else if (const ::Assimp::STEP::EXPRESS::REAL* val = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                     float value = static_cast<float>(*val);
                     std::stringstream s;
                     s << value;
                     properties[key]=s.str();
                 }
-                else if (const EXPRESS::INTEGER* val = singleValue->NominalValue.Get()->ToPtr<EXPRESS::INTEGER>()) {
+                else if (const ::Assimp::STEP::EXPRESS::INTEGER* val = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
                     int64_t value = static_cast<int64_t>(*val);
                     std::stringstream s;
                     s << value;
@@ -613,21 +606,21 @@ void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionD
                 }
             }
         }
-        else if (const IfcPropertyListValue* const listValue = property.ToPtr<IfcPropertyListValue>()) {
+        else if (const Schema_2x3::IfcPropertyListValue* const listValue = property.ToPtr<Schema_2x3::IfcPropertyListValue>()) {
             std::stringstream ss;
             ss << "[";
             unsigned index=0;
-            for(const IfcValue::Out& v : listValue->ListValues) {
+            for(const Schema_2x3::IfcValue::Out& v : listValue->ListValues) {
                 if (!v) continue;
-                if (const EXPRESS::STRING* str = v->ToPtr<EXPRESS::STRING>()) {
+                if (const ::Assimp::STEP::EXPRESS::STRING* str = v->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
                     std::string value = static_cast<std::string>(*str);
                     ss << "'" << value << "'";
                 }
-                else if (const EXPRESS::REAL* val = v->ToPtr<EXPRESS::REAL>()) {
+                else if (const ::Assimp::STEP::EXPRESS::REAL* val = v->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                     float value = static_cast<float>(*val);
                     ss << value;
                 }
-                else if (const EXPRESS::INTEGER* val = v->ToPtr<EXPRESS::INTEGER>()) {
+                else if (const ::Assimp::STEP::EXPRESS::INTEGER* val = v->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
                     int64_t value = static_cast<int64_t>(*val);
                     ss << value;
                 }
@@ -639,7 +632,7 @@ void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionD
             ss << "]";
             properties[key]=ss.str();
         }
-        else if (const IfcComplexProperty* const complexProp = property.ToPtr<IfcComplexProperty>()) {
+        else if (const Schema_2x3::IfcComplexProperty* const complexProp = property.ToPtr<Schema_2x3::IfcComplexProperty>()) {
             if(nest > 2) { // mostly arbitrary limit to prevent stack overflow vulnerabilities
                 IFCImporter::LogError("maximum nesting level for IfcComplexProperty reached, skipping this property.");
             }
@@ -657,29 +650,29 @@ void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionD
 // ------------------------------------------------------------------------------------------------
 void ProcessMetadata(uint64_t relDefinesByPropertiesID, ConversionData& conv, Metadata& properties)
 {
-    if (const IfcRelDefinesByProperties* const pset = conv.db.GetObject(relDefinesByPropertiesID)->ToPtr<IfcRelDefinesByProperties>()) {
-        if (const IfcPropertySet* const set = conv.db.GetObject(pset->RelatingPropertyDefinition->GetID())->ToPtr<IfcPropertySet>()) {
+    if (const Schema_2x3::IfcRelDefinesByProperties* const pset = conv.db.GetObject(relDefinesByPropertiesID)->ToPtr<Schema_2x3::IfcRelDefinesByProperties>()) {
+        if (const Schema_2x3::IfcPropertySet* const set = conv.db.GetObject(pset->RelatingPropertyDefinition->GetID())->ToPtr<Schema_2x3::IfcPropertySet>()) {
             ProcessMetadata(set->HasProperties, conv, properties);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, ConversionData& conv, std::vector<TempOpening>* collect_openings = NULL)
+aiNode* ProcessSpatialStructure(aiNode* parent, const Schema_2x3::IfcProduct& el, ConversionData& conv, std::vector<TempOpening>* collect_openings = NULL)
 {
     const STEP::DB::RefMap& refs = conv.db.GetRefs();
 
     // skip over space and annotation nodes - usually, these have no meaning in Assimp's context
     bool skipGeometry = false;
     if(conv.settings.skipSpaceRepresentations) {
-        if(el.ToPtr<IfcSpace>()) {
+        if(el.ToPtr<Schema_2x3::IfcSpace>()) {
             IFCImporter::LogDebug("skipping IfcSpace entity due to importer settings");
             skipGeometry = true;
         }
     }
 
     if(conv.settings.skipAnnotations) {
-        if(el.ToPtr<IfcAnnotation>()) {
+        if(el.ToPtr<Schema_2x3::IfcAnnotation>()) {
             IFCImporter::LogDebug("skipping IfcAnnotation entity due to importer settings");
             return NULL;
         }
@@ -745,12 +738,12 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
             const STEP::LazyObject& obj = conv.db.MustGetObject((*range2.first).second);
 
             // handle regularly-contained elements
-            if(const IfcRelContainedInSpatialStructure* const cont = obj->ToPtr<IfcRelContainedInSpatialStructure>()) {
+            if(const Schema_2x3::IfcRelContainedInSpatialStructure* const cont = obj->ToPtr<Schema_2x3::IfcRelContainedInSpatialStructure>()) {
                 if(cont->RelatingStructure->GetID() != el.GetID()) {
                     continue;
                 }
-                for(const IfcProduct& pro : cont->RelatedElements) {
-                    if(pro.ToPtr<IfcOpeningElement>()) {
+                for(const Schema_2x3::IfcProduct& pro : cont->RelatedElements) {
+                    if(pro.ToPtr<Schema_2x3::IfcOpeningElement>()) {
                         // IfcOpeningElement is handled below. Sadly we can't use it here as is:
                         // The docs say that opening elements are USUALLY attached to building storey,
                         // but we want them for the building elements to which they belong.
@@ -764,9 +757,9 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
                 }
             }
             // handle openings, which we collect in a list rather than adding them to the node graph
-            else if(const IfcRelVoidsElement* const fills = obj->ToPtr<IfcRelVoidsElement>()) {
+            else if(const Schema_2x3::IfcRelVoidsElement* const fills = obj->ToPtr<Schema_2x3::IfcRelVoidsElement>()) {
                 if(fills->RelatingBuildingElement->GetID() == el.GetID()) {
-                    const IfcFeatureElementSubtraction& open = fills->RelatedOpeningElement;
+                    const Schema_2x3::IfcFeatureElementSubtraction& open = fills->RelatedOpeningElement;
 
                     // move opening elements to a separate node since they are semantically different than elements that are just 'contained'
                     std::unique_ptr<aiNode> nd_aggr(new aiNode());
@@ -808,7 +801,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
             if (conv.already_processed.find((*range.first).second) != conv.already_processed.end()) {
                 continue;
             }
-            if(const IfcRelAggregates* const aggr = conv.db.GetObject((*range.first).second)->ToPtr<IfcRelAggregates>()) {
+            if(const Schema_2x3::IfcRelAggregates* const aggr = conv.db.GetObject((*range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
                 if(aggr->RelatingObject->GetID() != el.GetID()) {
                     continue;
                 }
@@ -821,8 +814,8 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
                 nd_aggr->mTransformation = nd->mTransformation;
 
                 nd_aggr->mChildren = new aiNode*[aggr->RelatedObjects.size()]();
-                for(const IfcObjectDefinition& def : aggr->RelatedObjects) {
-                    if(const IfcProduct* const prod = def.ToPtr<IfcProduct>()) {
+                for(const Schema_2x3::IfcObjectDefinition& def : aggr->RelatedObjects) {
+                    if(const Schema_2x3::IfcProduct* const prod = def.ToPtr<Schema_2x3::IfcProduct>()) {
 
                         aiNode* const ndnew = ProcessSpatialStructure(nd_aggr.get(),*prod,conv,NULL);
                         if(ndnew) {
@@ -889,7 +882,7 @@ void ProcessSpatialStructures(ConversionData& conv)
 	std::vector<aiNode*> nodes;
 
     for(const STEP::LazyObject* lz : *range) {
-        const IfcSpatialStructureElement* const prod = lz->ToPtr<IfcSpatialStructureElement>();
+        const Schema_2x3::IfcSpatialStructureElement* const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
         if(!prod) {
             continue;
         }
@@ -899,9 +892,9 @@ void ProcessSpatialStructures(ConversionData& conv)
         const STEP::DB::RefMap& refs = conv.db.GetRefs();
         STEP::DB::RefMapRange ref_range = refs.equal_range(conv.proj.GetID());
         for(; ref_range.first != ref_range.second; ++ref_range.first) {
-            if(const IfcRelAggregates* const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<IfcRelAggregates>()) {
+            if(const Schema_2x3::IfcRelAggregates* const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
 
-                for(const IfcObjectDefinition& def : aggr->RelatedObjects) {
+                for(const Schema_2x3::IfcObjectDefinition& def : aggr->RelatedObjects) {
                     // comparing pointer values is not sufficient, we would need to cast them to the same type first
                     // as there is multiple inheritance in the game.
                     if (def.GetID() == prod->GetID()) {
@@ -910,7 +903,6 @@ void ProcessSpatialStructures(ConversionData& conv)
 						nodes.push_back(ProcessSpatialStructure(NULL, *prod, conv, NULL));
                     }
                 }
-
             }
         }
     }
@@ -920,7 +912,7 @@ void ProcessSpatialStructures(ConversionData& conv)
 	if (nb_nodes == 0) {
 		IFCImporter::LogWarn("failed to determine primary site element, taking all the IfcSite");
 		for (const STEP::LazyObject* lz : *range) {
-			const IfcSpatialStructureElement* const prod = lz->ToPtr<IfcSpatialStructureElement>();
+			const Schema_2x3::IfcSpatialStructureElement* const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
 			if (!prod) {
 				continue;
 			}

code/IFCLoader.h → code/Importer/IFC/IFCLoader.h

@@ -45,8 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_IFC_LOADER_H
 #define INCLUDED_AI_IFC_LOADER_H
 
-#include "BaseImporter.h"
-#include "LogAux.h"
+#include "code/BaseImporter.h"
+#include "code/LogAux.h"
 
 namespace Assimp    {
 

code/IFCMaterial.cpp → code/Importer/IFC/IFCMaterial.cpp

@@ -68,20 +68,20 @@ static int ConvertShadingMode(const std::string& name) {
 }
 
 // ------------------------------------------------------------------------------------------------
-static void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,ConversionData& conv) {
+static void FillMaterial(aiMaterial* mat,const IFC::Schema_2x3::IfcSurfaceStyle* surf,ConversionData& conv) {
     aiString name;
     name.Set((surf->Name? surf->Name.Get() : "IfcSurfaceStyle_Unnamed"));
     mat->AddProperty(&name,AI_MATKEY_NAME);
 
     // now see which kinds of surface information are present
-    for(std::shared_ptr< const IFC::IfcSurfaceStyleElementSelect > sel2 : surf->Styles) {
-        if (const IFC::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr<IFC::IfcSurfaceStyleShading>(conv.db)) {
+    for(std::shared_ptr< const IFC::Schema_2x3::IfcSurfaceStyleElementSelect > sel2 : surf->Styles) {
+        if (const IFC::Schema_2x3::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyleShading>(conv.db)) {
             aiColor4D col_base,col;
 
             ConvertColor(col_base, shade->SurfaceColour);
             mat->AddProperty(&col_base,1, AI_MATKEY_COLOR_DIFFUSE);
 
-            if (const IFC::IfcSurfaceStyleRendering* ren = shade->ToPtr<IFC::IfcSurfaceStyleRendering>()) {
+            if (const IFC::Schema_2x3::IfcSurfaceStyleRendering* ren = shade->ToPtr<IFC::Schema_2x3::IfcSurfaceStyleRendering>()) {
 
                 if (ren->Transparency) {
                     const float t = 1.f-static_cast<float>(ren->Transparency.Get());
@@ -112,7 +112,7 @@ static void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,Conver
                 mat->AddProperty(&shading,1, AI_MATKEY_SHADING_MODEL);
 
                 if (ren->SpecularHighlight) {
-                    if(const EXPRESS::REAL* rt = ren->SpecularHighlight.Get()->ToPtr<EXPRESS::REAL>()) {
+                    if(const ::Assimp::STEP::EXPRESS::REAL* rt = ren->SpecularHighlight.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
                         // at this point we don't distinguish between the two distinct ways of
                         // specifying highlight intensities. leave this to the user.
                         const float e = static_cast<float>(*rt);
@@ -123,23 +123,19 @@ static void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,Conver
                     }
                 }
             }
-        } /*
-        else if (const IFC::IfcSurfaceStyleWithTextures* tex = sel2->ResolveSelectPtr<IFC::IfcSurfaceStyleWithTextures>(conv.db)) {
-            // XXX
-        } */
+        } 
     }
-
 }
 
 // ------------------------------------------------------------------------------------------------
 unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionData& conv, bool forceDefaultMat) {
     STEP::DB::RefMapRange range = conv.db.GetRefs().equal_range(id);
     for(;range.first != range.second; ++range.first) {
-        if(const IFC::IfcStyledItem* const styled = conv.db.GetObject((*range.first).second)->ToPtr<IFC::IfcStyledItem>()) {
-            for(const IFC::IfcPresentationStyleAssignment& as : styled->Styles) {
-                for(std::shared_ptr<const IFC::IfcPresentationStyleSelect> sel : as.Styles) {
+        if(const IFC::Schema_2x3::IfcStyledItem* const styled = conv.db.GetObject((*range.first).second)->ToPtr<IFC::Schema_2x3::IfcStyledItem>()) {
+            for(const IFC::Schema_2x3::IfcPresentationStyleAssignment& as : styled->Styles) {
+                for(std::shared_ptr<const IFC::Schema_2x3::IfcPresentationStyleSelect> sel : as.Styles) {
 
-                    if( const IFC::IfcSurfaceStyle* const surf = sel->ResolveSelectPtr<IFC::IfcSurfaceStyle>(conv.db) ) {
+                    if( const IFC::Schema_2x3::IfcSurfaceStyle* const surf = sel->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyle>(conv.db) ) {
                         // try to satisfy from cache
                         ConversionData::MaterialCache::iterator mit = conv.cached_materials.find(surf);
                         if( mit != conv.cached_materials.end() )

code/IFCOpenings.cpp → code/Importer/IFC/IFCOpenings.cpp

@@ -46,8 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 #include "IFCUtil.h"
-#include "PolyTools.h"
-#include "ProcessHelper.h"
+#include "code/PolyTools.h"
+#include "code/ProcessHelper.h"
 
 #include "../contrib/poly2tri/poly2tri/poly2tri.h"
 #include "../contrib/clipper/clipper.hpp"
@@ -323,7 +323,7 @@ void InsertWindowContours(const ContourVector& contours,
             if (hit) {
                 if (last_hit != (size_t)-1) {
 
-                    const size_t old = curmesh.verts.size();
+                    const size_t old = curmesh.mVerts.size();
                     size_t cnt = last_hit > n ? size-(last_hit-n) : n-last_hit;
                     for(size_t a = last_hit, e = 0; e <= cnt; a=(a+1)%size, ++e) {
                         // hack: this is to fix cases where opening contours are self-intersecting.
@@ -335,7 +335,7 @@ void InsertWindowContours(const ContourVector& contours,
                         if ((contour[a] - edge).SquareLength() > diag*diag*0.7) {
                             continue;
                         }
-                        curmesh.verts.push_back(IfcVector3(contour[a].x, contour[a].y, 0.0f));
+                        curmesh.mVerts.push_back(IfcVector3(contour[a].x, contour[a].y, 0.0f));
                     }
 
                     if (edge != contour[last_hit]) {
@@ -356,16 +356,16 @@ void InsertWindowContours(const ContourVector& contours,
                             corner.y = bb.second.y;
                         }
 
-                        curmesh.verts.push_back(IfcVector3(corner.x, corner.y, 0.0f));
+                        curmesh.mVerts.push_back(IfcVector3(corner.x, corner.y, 0.0f));
                     }
                     else if (cnt == 1) {
                         // avoid degenerate polygons (also known as lines or points)
-                        curmesh.verts.erase(curmesh.verts.begin()+old,curmesh.verts.end());
+                        curmesh.mVerts.erase(curmesh.mVerts.begin()+old,curmesh.mVerts.end());
                     }
 
-                    if (const size_t d = curmesh.verts.size()-old) {
-                        curmesh.vertcnt.push_back(static_cast<unsigned int>(d));
-                        std::reverse(curmesh.verts.rbegin(),curmesh.verts.rbegin()+d);
+                    if (const size_t d = curmesh.mVerts.size()-old) {
+                        curmesh.mVertcnt.push_back(static_cast<unsigned int>(d));
+                        std::reverse(curmesh.mVerts.rbegin(),curmesh.mVerts.rbegin()+d);
                     }
                     if (n == very_first_hit) {
                         break;
@@ -504,8 +504,8 @@ void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh&
     std::vector<IfcVector3> vold;
     std::vector<unsigned int> iold;
 
-    vold.reserve(curmesh.verts.size());
-    iold.reserve(curmesh.vertcnt.size());
+    vold.reserve(curmesh.mVerts.size());
+    iold.reserve(curmesh.mVertcnt.size());
 
     // Fix the outer contour using polyclipper
     try {
@@ -530,9 +530,9 @@ void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh&
         subject.reserve(4);
         size_t index = 0;
         size_t countdown = 0;
-        for(const IfcVector3& pip : curmesh.verts) {
+        for(const IfcVector3& pip : curmesh.mVerts) {
             if (!countdown) {
-                countdown = curmesh.vertcnt[index++];
+                countdown = curmesh.mVertcnt[index++];
                 if (!countdown) {
                     continue;
                 }
@@ -572,8 +572,8 @@ void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh&
     }
 
     // swap data arrays
-    std::swap(vold,curmesh.verts);
-    std::swap(iold,curmesh.vertcnt);
+    std::swap(vold,curmesh.mVerts);
+    std::swap(iold,curmesh.mVertcnt);
 }
 
 typedef std::vector<TempOpening*> OpeningRefs;
@@ -898,14 +898,14 @@ size_t CloseWindows(ContourVector& contours,
 
             SkipList::const_iterator skipbegin = (*it).skiplist.begin();
 
-            curmesh.verts.reserve(curmesh.verts.size() + (*it).contour.size() * 4);
-            curmesh.vertcnt.reserve(curmesh.vertcnt.size() + (*it).contour.size());
+            curmesh.mVerts.reserve(curmesh.mVerts.size() + (*it).contour.size() * 4);
+            curmesh.mVertcnt.reserve(curmesh.mVertcnt.size() + (*it).contour.size());
 
 			bool reverseCountourFaces = false;
 
             // compare base poly normal and contour normal to detect if we need to reverse the face winding
-			if(curmesh.vertcnt.size() > 0) {
-				IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.verts.data(), curmesh.vertcnt.front());
+			if(curmesh.mVertcnt.size() > 0) {
+				IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front());
 				
 				std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
 				
@@ -954,14 +954,14 @@ size_t CloseWindows(ContourVector& contours,
                 }
 
                 if (drop_this_edge) {
-                    curmesh.verts.pop_back();
-                    curmesh.verts.pop_back();
+                    curmesh.mVerts.pop_back();
+                    curmesh.mVerts.pop_back();
                 }
                 else {
-                    curmesh.verts.push_back(((cit == cbegin) != reverseCountourFaces) ? world_point : bestv);
-                    curmesh.verts.push_back(((cit == cbegin) != reverseCountourFaces) ? bestv : world_point);
+                    curmesh.mVerts.push_back(((cit == cbegin) != reverseCountourFaces) ? world_point : bestv);
+                    curmesh.mVerts.push_back(((cit == cbegin) != reverseCountourFaces) ? bestv : world_point);
 
-                    curmesh.vertcnt.push_back(4);
+                    curmesh.mVertcnt.push_back(4);
                     ++closed;
                 }
 
@@ -971,8 +971,8 @@ size_t CloseWindows(ContourVector& contours,
                     continue;
                 }
 
-                curmesh.verts.push_back(reverseCountourFaces ? bestv : world_point);
-                curmesh.verts.push_back(reverseCountourFaces ? world_point : bestv);
+                curmesh.mVerts.push_back(reverseCountourFaces ? bestv : world_point);
+                curmesh.mVerts.push_back(reverseCountourFaces ? world_point : bestv);
 
                 if (cit == cend - 1) {
                     drop_this_edge = *skipit;
@@ -981,13 +981,13 @@ size_t CloseWindows(ContourVector& contours,
                     // a border edge that needs to be dropped.
                     if (drop_this_edge) {
                         --closed;
-                        curmesh.vertcnt.pop_back();
-                        curmesh.verts.pop_back();
-                        curmesh.verts.pop_back();
+                        curmesh.mVertcnt.pop_back();
+                        curmesh.mVerts.pop_back();
+                        curmesh.mVerts.pop_back();
                     }
                     else {
-                        curmesh.verts.push_back(reverseCountourFaces ? start0 : start1);
-                        curmesh.verts.push_back(reverseCountourFaces ? start1 : start0);
+                        curmesh.mVerts.push_back(reverseCountourFaces ? start0 : start1);
+                        curmesh.mVerts.push_back(reverseCountourFaces ? start1 : start0);
                     }
                 }
             }
@@ -1029,10 +1029,10 @@ void Quadrify(const std::vector< BoundingBox >& bbs, TempMesh& curmesh)
     QuadrifyPart(IfcVector2(),one_vec,field,bbs,quads);
     ai_assert(!(quads.size() % 4));
 
-    curmesh.vertcnt.resize(quads.size()/4,4);
-    curmesh.verts.reserve(quads.size());
+    curmesh.mVertcnt.resize(quads.size()/4,4);
+    curmesh.mVerts.reserve(quads.size());
     for(const IfcVector2& v2 : quads) {
-        curmesh.verts.push_back(IfcVector3(v2.x, v2.y, static_cast<IfcFloat>(0.0)));
+        curmesh.mVerts.push_back(IfcVector3(v2.x, v2.y, static_cast<IfcFloat>(0.0)));
     }
 }
 
@@ -1053,7 +1053,7 @@ void Quadrify(const ContourVector& contours, TempMesh& curmesh)
 IfcMatrix4 ProjectOntoPlane(std::vector<IfcVector2>& out_contour, const TempMesh& in_mesh,
     bool &ok, IfcVector3& nor_out)
 {
-    const std::vector<IfcVector3>& in_verts = in_mesh.verts;
+    const std::vector<IfcVector3>& in_verts = in_mesh.mVerts;
     ok = true;
 
     IfcMatrix4 m = IfcMatrix4(DerivePlaneCoordinateSpace(in_mesh, ok, nor_out));
@@ -1200,8 +1200,8 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
                 }
             }
         }
-        std::vector<IfcVector3> profile_verts = profile_data->verts;
-        std::vector<unsigned int> profile_vertcnts = profile_data->vertcnt;
+        std::vector<IfcVector3> profile_verts = profile_data->mVerts;
+        std::vector<unsigned int> profile_vertcnts = profile_data->mVertcnt;
         if(profile_verts.size() <= 2) {
             continue;
         }
@@ -1421,7 +1421,7 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
     CleanupOuterContour(contour_flat, curmesh);
 
     // Undo the projection and get back to world (or local object) space
-    for(IfcVector3& v3 : curmesh.verts) {
+    for(IfcVector3& v3 : curmesh.mVerts) {
         v3 = minv * v3;
     }
 
@@ -1438,7 +1438,7 @@ bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std:
     TempMesh& curmesh)
 {
     IFCImporter::LogWarn("forced to use poly2tri fallback method to generate wall openings");
-    std::vector<IfcVector3>& out = curmesh.verts;
+    std::vector<IfcVector3>& out = curmesh.mVerts;
 
     bool result = false;
 
@@ -1513,14 +1513,14 @@ bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std:
                 continue;
             }
 
-            const std::vector<IfcVector3>& va = t.profileMesh->verts;
+            const std::vector<IfcVector3>& va = t.profileMesh->mVerts;
             if(va.size() <= 2) {
                 continue;
             }
 
             std::vector<IfcVector2> contour;
 
-            for(const IfcVector3& xx : t.profileMesh->verts) {
+            for(const IfcVector3& xx : t.profileMesh->mVerts) {
                 IfcVector3 vv = m *  xx, vv_extr = m * (xx + t.extrusionDir);
 
                 const bool is_extruded_side = std::fabs(vv.z - coord) > std::fabs(vv_extr.z - coord);
@@ -1603,8 +1603,8 @@ bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std:
     std::vector<IfcVector3> old_verts;
     std::vector<unsigned int> old_vertcnt;
 
-    old_verts.swap(curmesh.verts);
-    old_vertcnt.swap(curmesh.vertcnt);
+    old_verts.swap(curmesh.mVerts);
+    old_vertcnt.swap(curmesh.mVertcnt);
 
     std::vector< std::vector<p2t::Point*> > contours;
     for(ClipperLib::ExPolygon& clip : clipped) {
@@ -1669,9 +1669,9 @@ bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std:
                 ai_assert(v.x <= 1.0 && v.x >= 0.0 && v.y <= 1.0 && v.y >= 0.0);
                 const IfcVector3 v3 = minv * IfcVector3(vmin.x + v.x * vmax.x, vmin.y + v.y * vmax.y,coord) ;
 
-                curmesh.verts.push_back(v3);
+                curmesh.mVerts.push_back(v3);
             }
-            curmesh.vertcnt.push_back(3);
+            curmesh.mVertcnt.push_back(3);
         }
 
         result = true;
@@ -1679,8 +1679,8 @@ bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,const std:
 
     if (!result) {
         // revert -- it's a shame, but better than nothing
-        curmesh.verts.insert(curmesh.verts.end(),old_verts.begin(), old_verts.end());
-        curmesh.vertcnt.insert(curmesh.vertcnt.end(),old_vertcnt.begin(), old_vertcnt.end());
+        curmesh.mVerts.insert(curmesh.mVerts.end(),old_verts.begin(), old_verts.end());
+        curmesh.mVertcnt.insert(curmesh.mVertcnt.end(),old_vertcnt.begin(), old_vertcnt.end());
 
         IFCImporter::LogError("Ifc: revert, could not generate openings for this wall");
     }

code/IFCProfile.cpp → code/Importer/IFC/IFCProfile.cpp

@@ -43,28 +43,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Read profile and curves entities from IFC files
  */
 
-
-
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
 #include "IFCUtil.h"
 
 namespace Assimp {
-    namespace IFC {
+namespace IFC {
 
 // ------------------------------------------------------------------------------------------------
-void ProcessPolyLine(const IfcPolyline& def, TempMesh& meshout, ConversionData& /*conv*/)
+void ProcessPolyLine(const Schema_2x3::IfcPolyline& def, TempMesh& meshout, ConversionData& /*conv*/)
 {
     // this won't produce a valid mesh, it just spits out a list of vertices
     IfcVector3 t;
-    for(const IfcCartesianPoint& cp : def.Points) {
+    for(const Schema_2x3::IfcCartesianPoint& cp : def.Points) {
         ConvertCartesianPoint(t,cp);
-        meshout.verts.push_back(t);
+        meshout.mVerts.push_back(t);
     }
-    meshout.vertcnt.push_back(static_cast<unsigned int>(meshout.verts.size()));
+    meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
 }
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessCurve(const IfcCurve& curve,  TempMesh& meshout, ConversionData& conv)
+bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv)
 {
     std::unique_ptr<const Curve> cv(Curve::Convert(curve,conv));
     if (!cv) {
@@ -78,10 +77,10 @@ bool ProcessCurve(const IfcCurve& curve,  TempMesh& meshout, ConversionData& con
             bc->SampleDiscrete(meshout);
         }
         catch(const  CurveError& cv) {
-            IFCImporter::LogError(cv.s+ " (error occurred while processing curve)");
+            IFCImporter::LogError(cv.mStr + " (error occurred while processing curve)");
             return false;
         }
-        meshout.vertcnt.push_back(static_cast<unsigned int>(meshout.verts.size()));
+        meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
         return true;
     }
 
@@ -90,66 +89,66 @@ bool ProcessCurve(const IfcCurve& curve,  TempMesh& meshout, ConversionData& con
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessClosedProfile(const IfcArbitraryClosedProfileDef& def, TempMesh& meshout, ConversionData& conv)
+void ProcessClosedProfile(const Schema_2x3::IfcArbitraryClosedProfileDef& def, TempMesh& meshout, ConversionData& conv)
 {
     ProcessCurve(def.OuterCurve,meshout,conv);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessOpenProfile(const IfcArbitraryOpenProfileDef& def, TempMesh& meshout, ConversionData& conv)
+void ProcessOpenProfile(const Schema_2x3::IfcArbitraryOpenProfileDef& def, TempMesh& meshout, ConversionData& conv)
 {
     ProcessCurve(def.Curve,meshout,conv);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& conv)
+void ProcessParametrizedProfile(const Schema_2x3::IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& conv)
 {
-    if(const IfcRectangleProfileDef* const cprofile = def.ToPtr<IfcRectangleProfileDef>()) {
+    if(const Schema_2x3::IfcRectangleProfileDef* const cprofile = def.ToPtr<Schema_2x3::IfcRectangleProfileDef>()) {
         const IfcFloat x = cprofile->XDim*0.5f, y = cprofile->YDim*0.5f;
 
-        meshout.verts.reserve(meshout.verts.size()+4);
-        meshout.verts.push_back( IfcVector3( x, y, 0.f ));
-        meshout.verts.push_back( IfcVector3(-x, y, 0.f ));
-        meshout.verts.push_back( IfcVector3(-x,-y, 0.f ));
-        meshout.verts.push_back( IfcVector3( x,-y, 0.f ));
-        meshout.vertcnt.push_back(4);
+        meshout.mVerts.reserve(meshout.mVerts.size()+4);
+        meshout.mVerts.push_back( IfcVector3( x, y, 0.f ));
+        meshout.mVerts.push_back( IfcVector3(-x, y, 0.f ));
+        meshout.mVerts.push_back( IfcVector3(-x,-y, 0.f ));
+        meshout.mVerts.push_back( IfcVector3( x,-y, 0.f ));
+        meshout.mVertcnt.push_back(4);
     }
-    else if( const IfcCircleProfileDef* const circle = def.ToPtr<IfcCircleProfileDef>()) {
-        if(def.ToPtr<IfcCircleHollowProfileDef>()) {
+    else if( const Schema_2x3::IfcCircleProfileDef* const circle = def.ToPtr<Schema_2x3::IfcCircleProfileDef>()) {
+        if(def.ToPtr<Schema_2x3::IfcCircleHollowProfileDef>()) {
             // TODO
         }
         const size_t segments = conv.settings.cylindricalTessellation;
         const IfcFloat delta = AI_MATH_TWO_PI_F/segments, radius = circle->Radius;
 
-        meshout.verts.reserve(segments);
+        meshout.mVerts.reserve(segments);
 
         IfcFloat angle = 0.f;
         for(size_t i = 0; i < segments; ++i, angle += delta) {
-            meshout.verts.push_back( IfcVector3( std::cos(angle)*radius, std::sin(angle)*radius, 0.f ));
+            meshout.mVerts.push_back( IfcVector3( std::cos(angle)*radius, std::sin(angle)*radius, 0.f ));
         }
 
-        meshout.vertcnt.push_back(static_cast<unsigned int>(segments));
+        meshout.mVertcnt.push_back(static_cast<unsigned int>(segments));
     }
-    else if( const IfcIShapeProfileDef* const ishape = def.ToPtr<IfcIShapeProfileDef>()) {
+    else if( const Schema_2x3::IfcIShapeProfileDef* const ishape = def.ToPtr<Schema_2x3::IfcIShapeProfileDef>()) {
         // construct simplified IBeam shape
         const IfcFloat offset = (ishape->OverallWidth - ishape->WebThickness) / 2;
         const IfcFloat inner_height = ishape->OverallDepth - ishape->FlangeThickness * 2;
 
-        meshout.verts.reserve(12);
-        meshout.verts.push_back(IfcVector3(0,0,0));
-        meshout.verts.push_back(IfcVector3(0,ishape->FlangeThickness,0));
-        meshout.verts.push_back(IfcVector3(offset,ishape->FlangeThickness,0));
-        meshout.verts.push_back(IfcVector3(offset,ishape->FlangeThickness + inner_height,0));
-        meshout.verts.push_back(IfcVector3(0,ishape->FlangeThickness + inner_height,0));
-        meshout.verts.push_back(IfcVector3(0,ishape->OverallDepth,0));
-        meshout.verts.push_back(IfcVector3(ishape->OverallWidth,ishape->OverallDepth,0));
-        meshout.verts.push_back(IfcVector3(ishape->OverallWidth,ishape->FlangeThickness + inner_height,0));
-        meshout.verts.push_back(IfcVector3(offset+ishape->WebThickness,ishape->FlangeThickness + inner_height,0));
-        meshout.verts.push_back(IfcVector3(offset+ishape->WebThickness,ishape->FlangeThickness,0));
-        meshout.verts.push_back(IfcVector3(ishape->OverallWidth,ishape->FlangeThickness,0));
-        meshout.verts.push_back(IfcVector3(ishape->OverallWidth,0,0));
-
-        meshout.vertcnt.push_back(12);
+        meshout.mVerts.reserve(12);
+        meshout.mVerts.push_back(IfcVector3(0,0,0));
+        meshout.mVerts.push_back(IfcVector3(0,ishape->FlangeThickness,0));
+        meshout.mVerts.push_back(IfcVector3(offset,ishape->FlangeThickness,0));
+        meshout.mVerts.push_back(IfcVector3(offset,ishape->FlangeThickness + inner_height,0));
+        meshout.mVerts.push_back(IfcVector3(0,ishape->FlangeThickness + inner_height,0));
+        meshout.mVerts.push_back(IfcVector3(0,ishape->OverallDepth,0));
+        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,ishape->OverallDepth,0));
+        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,ishape->FlangeThickness + inner_height,0));
+        meshout.mVerts.push_back(IfcVector3(offset+ishape->WebThickness,ishape->FlangeThickness + inner_height,0));
+        meshout.mVerts.push_back(IfcVector3(offset+ishape->WebThickness,ishape->FlangeThickness,0));
+        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,ishape->FlangeThickness,0));
+        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,0,0));
+
+        meshout.mVertcnt.push_back(12);
     }
     else {
         IFCImporter::LogWarn("skipping unknown IfcParameterizedProfileDef entity, type is " + def.GetClassName());
@@ -162,15 +161,15 @@ void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh&
 }
 
 // ------------------------------------------------------------------------------------------------
-bool ProcessProfile(const IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv)
+bool ProcessProfile(const Schema_2x3::IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv)
 {
-    if(const IfcArbitraryClosedProfileDef* const cprofile = prof.ToPtr<IfcArbitraryClosedProfileDef>()) {
+    if(const Schema_2x3::IfcArbitraryClosedProfileDef* const cprofile = prof.ToPtr<Schema_2x3::IfcArbitraryClosedProfileDef>()) {
         ProcessClosedProfile(*cprofile,meshout,conv);
     }
-    else if(const IfcArbitraryOpenProfileDef* const copen = prof.ToPtr<IfcArbitraryOpenProfileDef>()) {
+    else if(const Schema_2x3::IfcArbitraryOpenProfileDef* const copen = prof.ToPtr<Schema_2x3::IfcArbitraryOpenProfileDef>()) {
         ProcessOpenProfile(*copen,meshout,conv);
     }
-    else if(const IfcParameterizedProfileDef* const cparam = prof.ToPtr<IfcParameterizedProfileDef>()) {
+    else if(const Schema_2x3::IfcParameterizedProfileDef* const cparam = prof.ToPtr<Schema_2x3::IfcParameterizedProfileDef>()) {
         ProcessParametrizedProfile(*cparam,meshout,conv);
     }
     else {
@@ -178,7 +177,7 @@ bool ProcessProfile(const IfcProfileDef& prof, TempMesh& meshout, ConversionData
         return false;
     }
     meshout.RemoveAdjacentDuplicates();
-    if (!meshout.vertcnt.size() || meshout.vertcnt.front() <= 1) {
+    if (!meshout.mVertcnt.size() || meshout.mVertcnt.front() <= 1) {
         return false;
     }
     return true;
@@ -187,4 +186,4 @@ bool ProcessProfile(const IfcProfileDef& prof, TempMesh& meshout, ConversionData
 } // ! IFC
 } // ! Assimp
 
-#endif
+#endif // ASSIMP_BUILD_NO_IFC_IMPORTER

code/IFCReaderGen1.cpp → code/Importer/IFC/IFCReaderGen1_2x3.cpp

@@ -43,15 +43,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //#include "AssimpPCH.h"
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
-#include "IFCReaderGen.h"
+#include "IFCReaderGen_2x3.h"
 
 namespace Assimp {
-using namespace IFC;
 
-namespace {
+using namespace ::Assimp::IFC;
+using namespace ::Assimp::IFC::Schema_2x3;
 
+namespace {
 	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
-	const SchemaEntry schema_raw[] =  {
+
+    static const SchemaEntry schema_raw_2x3[] =  {
 		SchemaEntry("ifcstairtypeenum",NULL )
 ,		SchemaEntry("ifcspacetypeenum",NULL )
 ,		SchemaEntry("ifcwalltypeenum",NULL )
@@ -1037,9 +1039,8 @@ namespace {
 }
 
 // -----------------------------------------------------------------------------------------------------------
-void IFC::GetSchema(EXPRESS::ConversionSchema& out)
-{
-	out = EXPRESS::ConversionSchema(schema_raw);
+void IFC::Schema_2x3::GetSchema(EXPRESS::ConversionSchema& out) {
+	out = EXPRESS::ConversionSchema(schema_raw_2x3);
 }
 
 namespace STEP {
@@ -1050,34 +1051,32 @@ template <> size_t GenericFill<NotImplemented>(const STEP::DB& /*db*/, const LIS
 	return 0;
 }
 
-
-
 // -----------------------------------------------------------------------------------------------------------
 template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoot* in)
 {
 	size_t base = 0;
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); }    do { // convert the 'GlobalId' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->GlobalId, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
     } while(0);
     do { // convert the 'OwnerHistory' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->OwnerHistory, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
     } while(0);
     do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Name, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Description' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Description, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
@@ -1145,27 +1144,27 @@ template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& para
 	size_t base = 0;
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); }    do { // convert the 'ContextOfItems' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->ContextOfItems, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
     } while(0);
     do { // convert the 'RepresentationIdentifier' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'RepresentationType' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->RepresentationType, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Items' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
         try { GenericConvert( in->Items, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
     } while(0);
@@ -1231,7 +1230,7 @@ template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcO
 	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcObject"); }    do { // convert the 'ObjectType' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcObject,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcObject,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->ObjectType, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
@@ -1284,21 +1283,21 @@ template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIS
 	size_t base = 0;
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcProductRepresentation"); }    do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Name, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'Description' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Description, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
     } while(0);
     do { // convert the 'Representations' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
         try { GenericConvert( in->Representations, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
     } while(0);
@@ -1310,14 +1309,14 @@ template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, Ifc
 	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
 	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcProduct"); }    do { // convert the 'ObjectPlacement' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->ObjectPlacement, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
     } while(0);
     do { // convert the 'Representation' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Representation, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
@@ -1330,7 +1329,7 @@ template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, Ifc
 	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
 	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcElement"); }    do { // convert the 'Tag' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElement,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElement,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Tag, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
@@ -1369,13 +1368,13 @@ template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& para
 	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); }    do { // convert the 'Segments' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Segments, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
     } while(0);
     do { // convert the 'SelfIntersect' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `LOGICAL`")); }
     } while(0);
@@ -1394,27 +1393,27 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db,
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCartesianTransformationOperator"); }    do { // convert the 'Axis1' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Axis1, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'Axis2' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Axis2, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
     } while(0);
     do { // convert the 'LocalOrigin' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
         try { GenericConvert( in->LocalOrigin, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'Scale' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Scale, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `REAL`")); }
@@ -1427,7 +1426,7 @@ template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& d
 	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCartesianTransformationOperator3D"); }    do { // convert the 'Axis3' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Axis3, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
@@ -1440,13 +1439,13 @@ template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, If
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); }    do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Name, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
     } while(0);
     do { // convert the 'Description' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Description, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
@@ -1492,7 +1491,7 @@ template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& p
 	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Position, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
     } while(0);
@@ -1510,19 +1509,19 @@ template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& param
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); }    do { // convert the 'Operator' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Operator, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
     } while(0);
     do { // convert the 'FirstOperand' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->FirstOperand, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
     } while(0);
     do { // convert the 'SecondOperand' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
         try { GenericConvert( in->SecondOperand, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
     } while(0);
@@ -1546,7 +1545,7 @@ template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& p
 	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); }    do { // convert the 'Outer' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Outer, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
     } while(0);
@@ -1779,13 +1778,13 @@ template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params,
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); }    do { // convert the 'ProfileType' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->ProfileType, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
     } while(0);
     do { // convert the 'ProfileName' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->ProfileName, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
@@ -1798,7 +1797,7 @@ template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const L
 	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Position, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
     } while(0);
@@ -1905,7 +1904,7 @@ template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& pa
 	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
 	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); }    do { // convert the 'Radius' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Radius, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
@@ -1928,7 +1927,7 @@ template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, I
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); }    do { // convert the 'Location' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPlacement,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPlacement,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Location, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
     } while(0);
@@ -1958,7 +1957,7 @@ template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& p
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyle"); }    do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Name, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
@@ -1999,13 +1998,13 @@ template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST&
 	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); }    do { // convert the 'XDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->XDim, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'YDim' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->YDim, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
@@ -2118,13 +2117,13 @@ template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& para
 	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); }    do { // convert the 'SweptArea' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->SweptArea, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
     } while(0);
     do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->Position, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
     } while(0);
@@ -2198,13 +2197,13 @@ template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& para
 	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); }    do { // convert the 'BaseSurface' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->BaseSurface, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
     } while(0);
     do { // convert the 'AgreementFlag' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->AgreementFlag, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `BOOLEAN`")); }
     } while(0);
@@ -2354,7 +2353,7 @@ template <> size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRelDefines"); }    do { // convert the 'RelatedObjects' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRelDefines,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefines,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefines to be a `SET [1:?] OF IfcObject`")); }
     } while(0);
@@ -2366,7 +2365,7 @@ template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LI
 	size_t base = GenericFill(db,params,static_cast<IfcRelDefines*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); }    do { // convert the 'RelatingPropertyDefinition' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRelDefinesByProperties,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefinesByProperties,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinition`")); }
     } while(0);
@@ -2399,7 +2398,7 @@ template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const L
 	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); }    do { // convert the 'Curve' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Curve, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
     } while(0);
@@ -2565,13 +2564,13 @@ template <> size_t GenericFill<IfcRelDecomposes>(const DB& db, const LIST& param
 	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDecomposes"); }    do { // convert the 'RelatingObject' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRelDecomposes,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->RelatingObject, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDecomposes to be a `IfcObjectDefinition`")); }
     } while(0);
     do { // convert the 'RelatedObjects' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRelDecomposes,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDecomposes to be a `SET [1:?] OF IfcObjectDefinition`")); }
     } while(0);
@@ -2653,13 +2652,13 @@ template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, I
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcNamedUnit"); }    do { // convert the 'Dimensions' argument
         std::shared_ptr<const DataType> arg = params[base++];
 		if (dynamic_cast<const UNSET*>(&*arg)) break;
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Dimensions, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
     } while(0);
     do { // convert the 'UnitType' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->UnitType, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
     } while(0);
@@ -2713,14 +2712,14 @@ template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const L
 	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
 	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSpatialStructureElement"); }    do { // convert the 'LongName' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialStructureElement,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->LongName, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialStructureElement to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'CompositionType' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialStructureElement,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->CompositionType, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
     } while(0);
@@ -2756,7 +2755,7 @@ template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& pa
 	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); }    do { // convert the 'CfsFaces' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->CfsFaces, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
     } while(0);
@@ -2782,7 +2781,7 @@ template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcCo
 	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); }    do { // convert the 'Position' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConic,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConic,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Position, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
     } while(0);
@@ -2829,31 +2828,31 @@ template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& pa
 	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
 	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcIShapeProfileDef"); }    do { // convert the 'OverallWidth' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcIShapeProfileDef,5>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->OverallWidth, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'OverallDepth' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcIShapeProfileDef,5>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->OverallDepth, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'WebThickness' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcIShapeProfileDef,5>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[2]=true; break; }
         try { GenericConvert( in->WebThickness, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'FlangeThickness' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcIShapeProfileDef,5>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[3]=true; break; }
         try { GenericConvert( in->FlangeThickness, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
     } while(0);
     do { // convert the 'FilletRadius' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcIShapeProfileDef,5>::aux_is_derived[4]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[4]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->FilletRadius, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
@@ -2978,20 +2977,20 @@ template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params,
 	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcStyledItem"); }    do { // convert the 'Item' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcStyledItem,3>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Item, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
     } while(0);
     do { // convert the 'Styles' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcStyledItem,3>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->Styles, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcPresentationStyleAssignment`")); }
     } while(0);
     do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcStyledItem,3>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[2]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Name, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
@@ -3018,7 +3017,7 @@ template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const
 	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
 	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); }    do { // convert the 'OuterCurve' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->OuterCurve, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
     } while(0);
@@ -3106,7 +3105,7 @@ template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST&
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleShading"); }    do { // convert the 'SurfaceColour' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurfaceStyleShading,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->SurfaceColour, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
     } while(0);

code/IFCReaderGen2.cpp → code/Importer/IFC/IFCReaderGen2_2x3.cpp

@@ -41,10 +41,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //#include "AssimpPCH.h"
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
-#include "IFCReaderGen.h"
+#include "IFCReaderGen_2x3.h"
 
 namespace Assimp {
 using namespace IFC;
+using namespace ::Assimp::IFC::Schema_2x3;
 
 namespace STEP {
 
@@ -111,7 +112,7 @@ template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFac
 	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); }    do { // convert the 'Bounds' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFace,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFace,1>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Bounds, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
     } while(0);
@@ -165,7 +166,7 @@ template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST&
 	size_t base = 0;
 	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcColourSpecification"); }    do { // convert the 'Name' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Name, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
@@ -405,31 +406,31 @@ template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params
 	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
 	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); }    do { // convert the 'Degree' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Degree, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `INTEGER`")); }
     } while(0);
     do { // convert the 'ControlPointsList' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->ControlPointsList, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
     } while(0);
     do { // convert the 'CurveForm' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
         try { GenericConvert( in->CurveForm, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
     } while(0);
     do { // convert the 'ClosedCurve' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
         try { GenericConvert( in->ClosedCurve, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `LOGICAL`")); }
     } while(0);
     do { // convert the 'SelfIntersect' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
         try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `LOGICAL`")); }
     } while(0);
@@ -708,14 +709,14 @@ template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIS
 	size_t base = 0;
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationContext"); }    do { // convert the 'ContextIdentifier' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->ContextIdentifier, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
     } while(0);
     do { // convert the 'ContextType' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->ContextType, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
@@ -728,26 +729,26 @@ template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db,
 	size_t base = GenericFill(db,params,static_cast<IfcRepresentationContext*>(in));
 	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); }    do { // convert the 'CoordinateSpaceDimension' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
     } while(0);
     do { // convert the 'Precision' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->Precision, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `REAL`")); }
     } while(0);
     do { // convert the 'WorldCoordinateSystem' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
         try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
     } while(0);
     do { // convert the 'TrueNorth' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
         if (dynamic_cast<const UNSET*>(&*arg)) break;
         try { GenericConvert( in->TrueNorth, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
@@ -1165,13 +1166,13 @@ template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, I
 	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
 	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); }    do { // convert the 'Bound' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
         try { GenericConvert( in->Bound, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
     } while(0);
     do { // convert the 'Orientation' argument
         std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
         try { GenericConvert( in->Orientation, arg, db ); break; } 
         catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `BOOLEAN`")); }
     } while(0);

code/IFCReaderGen.h → code/Importer/IFC/IFCReaderGen_2x3.h

@@ -43,10 +43,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IFC_READER_GEN_H
 #define INCLUDED_IFC_READER_GEN_H
 
-#include "STEPFile.h"
+#include "code/STEPFile.h"
 
 namespace Assimp {
 namespace IFC {
+    namespace Schema_2x3 {
+
     using namespace STEP;
     using namespace STEP::EXPRESS;
 
@@ -3912,15 +3914,16 @@ namespace IFC {
     };
 
     void GetSchema(EXPRESS::ConversionSchema& out);
-
+    } //! Schema_2x3
 } //! IFC
+
 namespace STEP {
 
     // ******************************************************************************
     // Converter stubs
     // ******************************************************************************
 
-#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::type* in)
+#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::Schema_2x3::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::Schema_2x3::type* in)
 
     DECL_CONV_STUB(IfcRepresentationItem);
     DECL_CONV_STUB(IfcGeometricRepresentationItem);

code/Importer/IFC/IFCReaderGen_4.cpp

@@ -0,0 +1,6206 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2010, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
+
+#include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "IFCReaderGen.h"
+
+namespace Assimp {
+using namespace IFC;
+
+namespace {
+
+	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
+	const SchemaEntry schema_raw[] =  {
+		SchemaEntry("ifcstrippedoptional",NULL )
+,		SchemaEntry("ifcabsorbeddosemeasure",NULL )
+,		SchemaEntry("ifcaccelerationmeasure",NULL )
+,		SchemaEntry("ifcamountofsubstancemeasure",NULL )
+,		SchemaEntry("ifcangularvelocitymeasure",NULL )
+,		SchemaEntry("ifcarcindex",NULL )
+,		SchemaEntry("ifcareadensitymeasure",NULL )
+,		SchemaEntry("ifcareameasure",NULL )
+,		SchemaEntry("ifcbinary",NULL )
+,		SchemaEntry("ifcboolean",NULL )
+,		SchemaEntry("ifcboxalignment",NULL )
+,		SchemaEntry("ifccardinalpointreference",NULL )
+,		SchemaEntry("ifccomplexnumber",NULL )
+,		SchemaEntry("ifccompoundplaneanglemeasure",NULL )
+,		SchemaEntry("ifccontextdependentmeasure",NULL )
+,		SchemaEntry("ifccountmeasure",NULL )
+,		SchemaEntry("ifccurvaturemeasure",NULL )
+,		SchemaEntry("ifcdate",NULL )
+,		SchemaEntry("ifcdatetime",NULL )
+,		SchemaEntry("ifcdayinmonthnumber",NULL )
+,		SchemaEntry("ifcdayinweeknumber",NULL )
+,		SchemaEntry("ifcdescriptivemeasure",NULL )
+,		SchemaEntry("ifcdimensioncount",NULL )
+,		SchemaEntry("ifcdoseequivalentmeasure",NULL )
+,		SchemaEntry("ifcduration",NULL )
+,		SchemaEntry("ifcdynamicviscositymeasure",NULL )
+,		SchemaEntry("ifcelectriccapacitancemeasure",NULL )
+,		SchemaEntry("ifcelectricchargemeasure",NULL )
+,		SchemaEntry("ifcelectricconductancemeasure",NULL )
+,		SchemaEntry("ifcelectriccurrentmeasure",NULL )
+,		SchemaEntry("ifcelectricresistancemeasure",NULL )
+,		SchemaEntry("ifcelectricvoltagemeasure",NULL )
+,		SchemaEntry("ifcenergymeasure",NULL )
+,		SchemaEntry("ifcfontstyle",NULL )
+,		SchemaEntry("ifcfontvariant",NULL )
+,		SchemaEntry("ifcfontweight",NULL )
+,		SchemaEntry("ifcforcemeasure",NULL )
+,		SchemaEntry("ifcfrequencymeasure",NULL )
+,		SchemaEntry("ifcgloballyuniqueid",NULL )
+,		SchemaEntry("ifcheatfluxdensitymeasure",NULL )
+,		SchemaEntry("ifcheatingvaluemeasure",NULL )
+,		SchemaEntry("ifcidentifier",NULL )
+,		SchemaEntry("ifcilluminancemeasure",NULL )
+,		SchemaEntry("ifcinductancemeasure",NULL )
+,		SchemaEntry("ifcinteger",NULL )
+,		SchemaEntry("ifcintegercountratemeasure",NULL )
+,		SchemaEntry("ifcionconcentrationmeasure",NULL )
+,		SchemaEntry("ifcisothermalmoisturecapacitymeasure",NULL )
+,		SchemaEntry("ifckinematicviscositymeasure",NULL )
+,		SchemaEntry("ifclabel",NULL )
+,		SchemaEntry("ifclanguageid",NULL )
+,		SchemaEntry("ifclengthmeasure",NULL )
+,		SchemaEntry("ifclineindex",NULL )
+,		SchemaEntry("ifclinearforcemeasure",NULL )
+,		SchemaEntry("ifclinearmomentmeasure",NULL )
+,		SchemaEntry("ifclinearstiffnessmeasure",NULL )
+,		SchemaEntry("ifclinearvelocitymeasure",NULL )
+,		SchemaEntry("ifclogical",NULL )
+,		SchemaEntry("ifcluminousfluxmeasure",NULL )
+,		SchemaEntry("ifcluminousintensitydistributionmeasure",NULL )
+,		SchemaEntry("ifcluminousintensitymeasure",NULL )
+,		SchemaEntry("ifcmagneticfluxdensitymeasure",NULL )
+,		SchemaEntry("ifcmagneticfluxmeasure",NULL )
+,		SchemaEntry("ifcmassdensitymeasure",NULL )
+,		SchemaEntry("ifcmassflowratemeasure",NULL )
+,		SchemaEntry("ifcmassmeasure",NULL )
+,		SchemaEntry("ifcmassperlengthmeasure",NULL )
+,		SchemaEntry("ifcmodulusofelasticitymeasure",NULL )
+,		SchemaEntry("ifcmodulusoflinearsubgradereactionmeasure",NULL )
+,		SchemaEntry("ifcmodulusofrotationalsubgradereactionmeasure",NULL )
+,		SchemaEntry("ifcmodulusofsubgradereactionmeasure",NULL )
+,		SchemaEntry("ifcmoisturediffusivitymeasure",NULL )
+,		SchemaEntry("ifcmolecularweightmeasure",NULL )
+,		SchemaEntry("ifcmomentofinertiameasure",NULL )
+,		SchemaEntry("ifcmonetarymeasure",NULL )
+,		SchemaEntry("ifcmonthinyearnumber",NULL )
+,		SchemaEntry("ifcnonnegativelengthmeasure",NULL )
+,		SchemaEntry("ifcnormalisedratiomeasure",NULL )
+,		SchemaEntry("ifcnumericmeasure",NULL )
+,		SchemaEntry("ifcphmeasure",NULL )
+,		SchemaEntry("ifcparametervalue",NULL )
+,		SchemaEntry("ifcplanarforcemeasure",NULL )
+,		SchemaEntry("ifcplaneanglemeasure",NULL )
+,		SchemaEntry("ifcpositiveinteger",NULL )
+,		SchemaEntry("ifcpositivelengthmeasure",NULL )
+,		SchemaEntry("ifcpositiveplaneanglemeasure",NULL )
+,		SchemaEntry("ifcpositiveratiomeasure",NULL )
+,		SchemaEntry("ifcpowermeasure",NULL )
+,		SchemaEntry("ifcpresentabletext",NULL )
+,		SchemaEntry("ifcpressuremeasure",NULL )
+,		SchemaEntry("ifcpropertysetdefinitionset",NULL )
+,		SchemaEntry("ifcradioactivitymeasure",NULL )
+,		SchemaEntry("ifcratiomeasure",NULL )
+,		SchemaEntry("ifcreal",NULL )
+,		SchemaEntry("ifcrotationalfrequencymeasure",NULL )
+,		SchemaEntry("ifcrotationalmassmeasure",NULL )
+,		SchemaEntry("ifcrotationalstiffnessmeasure",NULL )
+,		SchemaEntry("ifcsectionmodulusmeasure",NULL )
+,		SchemaEntry("ifcsectionalareaintegralmeasure",NULL )
+,		SchemaEntry("ifcshearmodulusmeasure",NULL )
+,		SchemaEntry("ifcsolidanglemeasure",NULL )
+,		SchemaEntry("ifcsoundpowerlevelmeasure",NULL )
+,		SchemaEntry("ifcsoundpowermeasure",NULL )
+,		SchemaEntry("ifcsoundpressurelevelmeasure",NULL )
+,		SchemaEntry("ifcsoundpressuremeasure",NULL )
+,		SchemaEntry("ifcspecificheatcapacitymeasure",NULL )
+,		SchemaEntry("ifcspecularexponent",NULL )
+,		SchemaEntry("ifcspecularroughness",NULL )
+,		SchemaEntry("ifctemperaturegradientmeasure",NULL )
+,		SchemaEntry("ifctemperaturerateofchangemeasure",NULL )
+,		SchemaEntry("ifctext",NULL )
+,		SchemaEntry("ifctextalignment",NULL )
+,		SchemaEntry("ifctextdecoration",NULL )
+,		SchemaEntry("ifctextfontname",NULL )
+,		SchemaEntry("ifctexttransformation",NULL )
+,		SchemaEntry("ifcthermaladmittancemeasure",NULL )
+,		SchemaEntry("ifcthermalconductivitymeasure",NULL )
+,		SchemaEntry("ifcthermalexpansioncoefficientmeasure",NULL )
+,		SchemaEntry("ifcthermalresistancemeasure",NULL )
+,		SchemaEntry("ifcthermaltransmittancemeasure",NULL )
+,		SchemaEntry("ifcthermodynamictemperaturemeasure",NULL )
+,		SchemaEntry("ifctime",NULL )
+,		SchemaEntry("ifctimemeasure",NULL )
+,		SchemaEntry("ifctimestamp",NULL )
+,		SchemaEntry("ifctorquemeasure",NULL )
+,		SchemaEntry("ifcurireference",NULL )
+,		SchemaEntry("ifcvaporpermeabilitymeasure",NULL )
+,		SchemaEntry("ifcvolumemeasure",NULL )
+,		SchemaEntry("ifcvolumetricflowratemeasure",NULL )
+,		SchemaEntry("ifcwarpingconstantmeasure",NULL )
+,		SchemaEntry("ifcwarpingmomentmeasure",NULL )
+,		SchemaEntry("ifcactionrequesttypeenum",NULL )
+,		SchemaEntry("ifcactionsourcetypeenum",NULL )
+,		SchemaEntry("ifcactiontypeenum",NULL )
+,		SchemaEntry("ifcactuatortypeenum",NULL )
+,		SchemaEntry("ifcaddresstypeenum",NULL )
+,		SchemaEntry("ifcairterminalboxtypeenum",NULL )
+,		SchemaEntry("ifcairterminaltypeenum",NULL )
+,		SchemaEntry("ifcairtoairheatrecoverytypeenum",NULL )
+,		SchemaEntry("ifcalarmtypeenum",NULL )
+,		SchemaEntry("ifcanalysismodeltypeenum",NULL )
+,		SchemaEntry("ifcanalysistheorytypeenum",NULL )
+,		SchemaEntry("ifcarithmeticoperatorenum",NULL )
+,		SchemaEntry("ifcassemblyplaceenum",NULL )
+,		SchemaEntry("ifcaudiovisualappliancetypeenum",NULL )
+,		SchemaEntry("ifcbsplinecurveform",NULL )
+,		SchemaEntry("ifcbsplinesurfaceform",NULL )
+,		SchemaEntry("ifcbeamtypeenum",NULL )
+,		SchemaEntry("ifcbenchmarkenum",NULL )
+,		SchemaEntry("ifcboilertypeenum",NULL )
+,		SchemaEntry("ifcbooleanoperator",NULL )
+,		SchemaEntry("ifcbuildingelementparttypeenum",NULL )
+,		SchemaEntry("ifcbuildingelementproxytypeenum",NULL )
+,		SchemaEntry("ifcbuildingsystemtypeenum",NULL )
+,		SchemaEntry("ifcburnertypeenum",NULL )
+,		SchemaEntry("ifccablecarrierfittingtypeenum",NULL )
+,		SchemaEntry("ifccablecarriersegmenttypeenum",NULL )
+,		SchemaEntry("ifccablefittingtypeenum",NULL )
+,		SchemaEntry("ifccablesegmenttypeenum",NULL )
+,		SchemaEntry("ifcchangeactionenum",NULL )
+,		SchemaEntry("ifcchillertypeenum",NULL )
+,		SchemaEntry("ifcchimneytypeenum",NULL )
+,		SchemaEntry("ifccoiltypeenum",NULL )
+,		SchemaEntry("ifccolumntypeenum",NULL )
+,		SchemaEntry("ifccommunicationsappliancetypeenum",NULL )
+,		SchemaEntry("ifccomplexpropertytemplatetypeenum",NULL )
+,		SchemaEntry("ifccompressortypeenum",NULL )
+,		SchemaEntry("ifccondensertypeenum",NULL )
+,		SchemaEntry("ifcconnectiontypeenum",NULL )
+,		SchemaEntry("ifcconstraintenum",NULL )
+,		SchemaEntry("ifcconstructionequipmentresourcetypeenum",NULL )
+,		SchemaEntry("ifcconstructionmaterialresourcetypeenum",NULL )
+,		SchemaEntry("ifcconstructionproductresourcetypeenum",NULL )
+,		SchemaEntry("ifccontrollertypeenum",NULL )
+,		SchemaEntry("ifccooledbeamtypeenum",NULL )
+,		SchemaEntry("ifccoolingtowertypeenum",NULL )
+,		SchemaEntry("ifccostitemtypeenum",NULL )
+,		SchemaEntry("ifccostscheduletypeenum",NULL )
+,		SchemaEntry("ifccoveringtypeenum",NULL )
+,		SchemaEntry("ifccrewresourcetypeenum",NULL )
+,		SchemaEntry("ifccurtainwalltypeenum",NULL )
+,		SchemaEntry("ifccurveinterpolationenum",NULL )
+,		SchemaEntry("ifcdampertypeenum",NULL )
+,		SchemaEntry("ifcdataoriginenum",NULL )
+,		SchemaEntry("ifcderivedunitenum",NULL )
+,		SchemaEntry("ifcdirectionsenseenum",NULL )
+,		SchemaEntry("ifcdiscreteaccessorytypeenum",NULL )
+,		SchemaEntry("ifcdistributionchamberelementtypeenum",NULL )
+,		SchemaEntry("ifcdistributionporttypeenum",NULL )
+,		SchemaEntry("ifcdistributionsystemenum",NULL )
+,		SchemaEntry("ifcdocumentconfidentialityenum",NULL )
+,		SchemaEntry("ifcdocumentstatusenum",NULL )
+,		SchemaEntry("ifcdoorpaneloperationenum",NULL )
+,		SchemaEntry("ifcdoorpanelpositionenum",NULL )
+,		SchemaEntry("ifcdoorstyleconstructionenum",NULL )
+,		SchemaEntry("ifcdoorstyleoperationenum",NULL )
+,		SchemaEntry("ifcdoortypeenum",NULL )
+,		SchemaEntry("ifcdoortypeoperationenum",NULL )
+,		SchemaEntry("ifcductfittingtypeenum",NULL )
+,		SchemaEntry("ifcductsegmenttypeenum",NULL )
+,		SchemaEntry("ifcductsilencertypeenum",NULL )
+,		SchemaEntry("ifcelectricappliancetypeenum",NULL )
+,		SchemaEntry("ifcelectricdistributionboardtypeenum",NULL )
+,		SchemaEntry("ifcelectricflowstoragedevicetypeenum",NULL )
+,		SchemaEntry("ifcelectricgeneratortypeenum",NULL )
+,		SchemaEntry("ifcelectricmotortypeenum",NULL )
+,		SchemaEntry("ifcelectrictimecontroltypeenum",NULL )
+,		SchemaEntry("ifcelementassemblytypeenum",NULL )
+,		SchemaEntry("ifcelementcompositionenum",NULL )
+,		SchemaEntry("ifcenginetypeenum",NULL )
+,		SchemaEntry("ifcevaporativecoolertypeenum",NULL )
+,		SchemaEntry("ifcevaporatortypeenum",NULL )
+,		SchemaEntry("ifceventtriggertypeenum",NULL )
+,		SchemaEntry("ifceventtypeenum",NULL )
+,		SchemaEntry("ifcexternalspatialelementtypeenum",NULL )
+,		SchemaEntry("ifcfantypeenum",NULL )
+,		SchemaEntry("ifcfastenertypeenum",NULL )
+,		SchemaEntry("ifcfiltertypeenum",NULL )
+,		SchemaEntry("ifcfiresuppressionterminaltypeenum",NULL )
+,		SchemaEntry("ifcflowdirectionenum",NULL )
+,		SchemaEntry("ifcflowinstrumenttypeenum",NULL )
+,		SchemaEntry("ifcflowmetertypeenum",NULL )
+,		SchemaEntry("ifcfootingtypeenum",NULL )
+,		SchemaEntry("ifcfurnituretypeenum",NULL )
+,		SchemaEntry("ifcgeographicelementtypeenum",NULL )
+,		SchemaEntry("ifcgeometricprojectionenum",NULL )
+,		SchemaEntry("ifcglobalorlocalenum",NULL )
+,		SchemaEntry("ifcgridtypeenum",NULL )
+,		SchemaEntry("ifcheatexchangertypeenum",NULL )
+,		SchemaEntry("ifchumidifiertypeenum",NULL )
+,		SchemaEntry("ifcinterceptortypeenum",NULL )
+,		SchemaEntry("ifcinternalorexternalenum",NULL )
+,		SchemaEntry("ifcinventorytypeenum",NULL )
+,		SchemaEntry("ifcjunctionboxtypeenum",NULL )
+,		SchemaEntry("ifcknottype",NULL )
+,		SchemaEntry("ifclaborresourcetypeenum",NULL )
+,		SchemaEntry("ifclamptypeenum",NULL )
+,		SchemaEntry("ifclayersetdirectionenum",NULL )
+,		SchemaEntry("ifclightdistributioncurveenum",NULL )
+,		SchemaEntry("ifclightemissionsourceenum",NULL )
+,		SchemaEntry("ifclightfixturetypeenum",NULL )
+,		SchemaEntry("ifcloadgrouptypeenum",NULL )
+,		SchemaEntry("ifclogicaloperatorenum",NULL )
+,		SchemaEntry("ifcmechanicalfastenertypeenum",NULL )
+,		SchemaEntry("ifcmedicaldevicetypeenum",NULL )
+,		SchemaEntry("ifcmembertypeenum",NULL )
+,		SchemaEntry("ifcmotorconnectiontypeenum",NULL )
+,		SchemaEntry("ifcnullstyle",NULL )
+,		SchemaEntry("ifcobjecttypeenum",NULL )
+,		SchemaEntry("ifcobjectiveenum",NULL )
+,		SchemaEntry("ifcoccupanttypeenum",NULL )
+,		SchemaEntry("ifcopeningelementtypeenum",NULL )
+,		SchemaEntry("ifcoutlettypeenum",NULL )
+,		SchemaEntry("ifcperformancehistorytypeenum",NULL )
+,		SchemaEntry("ifcpermeablecoveringoperationenum",NULL )
+,		SchemaEntry("ifcpermittypeenum",NULL )
+,		SchemaEntry("ifcphysicalorvirtualenum",NULL )
+,		SchemaEntry("ifcpileconstructionenum",NULL )
+,		SchemaEntry("ifcpiletypeenum",NULL )
+,		SchemaEntry("ifcpipefittingtypeenum",NULL )
+,		SchemaEntry("ifcpipesegmenttypeenum",NULL )
+,		SchemaEntry("ifcplatetypeenum",NULL )
+,		SchemaEntry("ifcpreferredsurfacecurverepresentation",NULL )
+,		SchemaEntry("ifcproceduretypeenum",NULL )
+,		SchemaEntry("ifcprofiletypeenum",NULL )
+,		SchemaEntry("ifcprojectordertypeenum",NULL )
+,		SchemaEntry("ifcprojectedortruelengthenum",NULL )
+,		SchemaEntry("ifcprojectionelementtypeenum",NULL )
+,		SchemaEntry("ifcpropertysettemplatetypeenum",NULL )
+,		SchemaEntry("ifcprotectivedevicetrippingunittypeenum",NULL )
+,		SchemaEntry("ifcprotectivedevicetypeenum",NULL )
+,		SchemaEntry("ifcpumptypeenum",NULL )
+,		SchemaEntry("ifcrailingtypeenum",NULL )
+,		SchemaEntry("ifcrampflighttypeenum",NULL )
+,		SchemaEntry("ifcramptypeenum",NULL )
+,		SchemaEntry("ifcrecurrencetypeenum",NULL )
+,		SchemaEntry("ifcreflectancemethodenum",NULL )
+,		SchemaEntry("ifcreinforcingbarroleenum",NULL )
+,		SchemaEntry("ifcreinforcingbarsurfaceenum",NULL )
+,		SchemaEntry("ifcreinforcingbartypeenum",NULL )
+,		SchemaEntry("ifcreinforcingmeshtypeenum",NULL )
+,		SchemaEntry("ifcroleenum",NULL )
+,		SchemaEntry("ifcrooftypeenum",NULL )
+,		SchemaEntry("ifcsiprefix",NULL )
+,		SchemaEntry("ifcsiunitname",NULL )
+,		SchemaEntry("ifcsanitaryterminaltypeenum",NULL )
+,		SchemaEntry("ifcsectiontypeenum",NULL )
+,		SchemaEntry("ifcsensortypeenum",NULL )
+,		SchemaEntry("ifcsequenceenum",NULL )
+,		SchemaEntry("ifcshadingdevicetypeenum",NULL )
+,		SchemaEntry("ifcsimplepropertytemplatetypeenum",NULL )
+,		SchemaEntry("ifcslabtypeenum",NULL )
+,		SchemaEntry("ifcsolardevicetypeenum",NULL )
+,		SchemaEntry("ifcspaceheatertypeenum",NULL )
+,		SchemaEntry("ifcspacetypeenum",NULL )
+,		SchemaEntry("ifcspatialzonetypeenum",NULL )
+,		SchemaEntry("ifcstackterminaltypeenum",NULL )
+,		SchemaEntry("ifcstairflighttypeenum",NULL )
+,		SchemaEntry("ifcstairtypeenum",NULL )
+,		SchemaEntry("ifcstateenum",NULL )
+,		SchemaEntry("ifcstructuralcurveactivitytypeenum",NULL )
+,		SchemaEntry("ifcstructuralcurvemembertypeenum",NULL )
+,		SchemaEntry("ifcstructuralsurfaceactivitytypeenum",NULL )
+,		SchemaEntry("ifcstructuralsurfacemembertypeenum",NULL )
+,		SchemaEntry("ifcsubcontractresourcetypeenum",NULL )
+,		SchemaEntry("ifcsurfacefeaturetypeenum",NULL )
+,		SchemaEntry("ifcsurfaceside",NULL )
+,		SchemaEntry("ifcswitchingdevicetypeenum",NULL )
+,		SchemaEntry("ifcsystemfurnitureelementtypeenum",NULL )
+,		SchemaEntry("ifctanktypeenum",NULL )
+,		SchemaEntry("ifctaskdurationenum",NULL )
+,		SchemaEntry("ifctasktypeenum",NULL )
+,		SchemaEntry("ifctendonanchortypeenum",NULL )
+,		SchemaEntry("ifctendontypeenum",NULL )
+,		SchemaEntry("ifctextpath",NULL )
+,		SchemaEntry("ifctimeseriesdatatypeenum",NULL )
+,		SchemaEntry("ifctransformertypeenum",NULL )
+,		SchemaEntry("ifctransitioncode",NULL )
+,		SchemaEntry("ifctransportelementtypeenum",NULL )
+,		SchemaEntry("ifctrimmingpreference",NULL )
+,		SchemaEntry("ifctubebundletypeenum",NULL )
+,		SchemaEntry("ifcunitenum",NULL )
+,		SchemaEntry("ifcunitarycontrolelementtypeenum",NULL )
+,		SchemaEntry("ifcunitaryequipmenttypeenum",NULL )
+,		SchemaEntry("ifcvalvetypeenum",NULL )
+,		SchemaEntry("ifcvibrationisolatortypeenum",NULL )
+,		SchemaEntry("ifcvoidingfeaturetypeenum",NULL )
+,		SchemaEntry("ifcwalltypeenum",NULL )
+,		SchemaEntry("ifcwasteterminaltypeenum",NULL )
+,		SchemaEntry("ifcwindowpaneloperationenum",NULL )
+,		SchemaEntry("ifcwindowpanelpositionenum",NULL )
+,		SchemaEntry("ifcwindowstyleconstructionenum",NULL )
+,		SchemaEntry("ifcwindowstyleoperationenum",NULL )
+,		SchemaEntry("ifcwindowtypeenum",NULL )
+,		SchemaEntry("ifcwindowtypepartitioningenum",NULL )
+,		SchemaEntry("ifcworkcalendartypeenum",NULL )
+,		SchemaEntry("ifcworkplantypeenum",NULL )
+,		SchemaEntry("ifcworkscheduletypeenum",NULL )
+,		SchemaEntry("ifcactorselect",NULL )
+,		SchemaEntry("ifcappliedvalueselect",NULL )
+,		SchemaEntry("ifcaxis2placement",NULL )
+,		SchemaEntry("ifcbendingparameterselect",NULL )
+,		SchemaEntry("ifcbooleanoperand",NULL )
+,		SchemaEntry("ifcclassificationreferenceselect",NULL )
+,		SchemaEntry("ifcclassificationselect",NULL )
+,		SchemaEntry("ifccolour",NULL )
+,		SchemaEntry("ifccolourorfactor",NULL )
+,		SchemaEntry("ifccoordinatereferencesystemselect",NULL )
+,		SchemaEntry("ifccsgselect",NULL )
+,		SchemaEntry("ifccurvefontorscaledcurvefontselect",NULL )
+,		SchemaEntry("ifccurveonsurface",NULL )
+,		SchemaEntry("ifccurveoredgecurve",NULL )
+,		SchemaEntry("ifccurvestylefontselect",NULL )
+,		SchemaEntry("ifcdefinitionselect",NULL )
+,		SchemaEntry("ifcderivedmeasurevalue",NULL )
+,		SchemaEntry("ifcdocumentselect",NULL )
+,		SchemaEntry("ifcfillstyleselect",NULL )
+,		SchemaEntry("ifcgeometricsetselect",NULL )
+,		SchemaEntry("ifcgridplacementdirectionselect",NULL )
+,		SchemaEntry("ifchatchlinedistanceselect",NULL )
+,		SchemaEntry("ifclayereditem",NULL )
+,		SchemaEntry("ifclibraryselect",NULL )
+,		SchemaEntry("ifclightdistributiondatasourceselect",NULL )
+,		SchemaEntry("ifcmaterialselect",NULL )
+,		SchemaEntry("ifcmeasurevalue",NULL )
+,		SchemaEntry("ifcmetricvalueselect",NULL )
+,		SchemaEntry("ifcmodulusofrotationalsubgradereactionselect",NULL )
+,		SchemaEntry("ifcmodulusofsubgradereactionselect",NULL )
+,		SchemaEntry("ifcmodulusoftranslationalsubgradereactionselect",NULL )
+,		SchemaEntry("ifcobjectreferenceselect",NULL )
+,		SchemaEntry("ifcpointorvertexpoint",NULL )
+,		SchemaEntry("ifcpresentationstyleselect",NULL )
+,		SchemaEntry("ifcprocessselect",NULL )
+,		SchemaEntry("ifcproductrepresentationselect",NULL )
+,		SchemaEntry("ifcproductselect",NULL )
+,		SchemaEntry("ifcpropertysetdefinitionselect",NULL )
+,		SchemaEntry("ifcresourceobjectselect",NULL )
+,		SchemaEntry("ifcresourceselect",NULL )
+,		SchemaEntry("ifcrotationalstiffnessselect",NULL )
+,		SchemaEntry("ifcsegmentindexselect",NULL )
+,		SchemaEntry("ifcshell",NULL )
+,		SchemaEntry("ifcsimplevalue",NULL )
+,		SchemaEntry("ifcsizeselect",NULL )
+,		SchemaEntry("ifcsolidorshell",NULL )
+,		SchemaEntry("ifcspaceboundaryselect",NULL )
+,		SchemaEntry("ifcspecularhighlightselect",NULL )
+,		SchemaEntry("ifcstructuralactivityassignmentselect",NULL )
+,		SchemaEntry("ifcstyleassignmentselect",NULL )
+,		SchemaEntry("ifcsurfaceorfacesurface",NULL )
+,		SchemaEntry("ifcsurfacestyleelementselect",NULL )
+,		SchemaEntry("ifctextfontselect",NULL )
+,		SchemaEntry("ifctimeorratioselect",NULL )
+,		SchemaEntry("ifctranslationalstiffnessselect",NULL )
+,		SchemaEntry("ifctrimmingselect",NULL )
+,		SchemaEntry("ifcunit",NULL )
+,		SchemaEntry("ifcvalue",NULL )
+,		SchemaEntry("ifcvectorordirection",NULL )
+,		SchemaEntry("ifcwarpingstiffnessselect",NULL )
+,		SchemaEntry("ifcroot",&STEP::ObjectHelper<IfcRoot,4>::Construct )
+,		SchemaEntry("ifcobjectdefinition",&STEP::ObjectHelper<IfcObjectDefinition,0>::Construct )
+,		SchemaEntry("ifcobject",&STEP::ObjectHelper<IfcObject,1>::Construct )
+,		SchemaEntry("ifccontrol",&STEP::ObjectHelper<IfcControl,1>::Construct )
+,		SchemaEntry("ifcactionrequest",&STEP::ObjectHelper<IfcActionRequest,3>::Construct )
+,		SchemaEntry("ifcactor",&STEP::ObjectHelper<IfcActor,1>::Construct )
+,		SchemaEntry("ifcactorrole",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcproduct",&STEP::ObjectHelper<IfcProduct,2>::Construct )
+,		SchemaEntry("ifcelement",&STEP::ObjectHelper<IfcElement,1>::Construct )
+,		SchemaEntry("ifcdistributionelement",&STEP::ObjectHelper<IfcDistributionElement,0>::Construct )
+,		SchemaEntry("ifcdistributioncontrolelement",&STEP::ObjectHelper<IfcDistributionControlElement,0>::Construct )
+,		SchemaEntry("ifcactuator",&STEP::ObjectHelper<IfcActuator,1>::Construct )
+,		SchemaEntry("ifctypeobject",&STEP::ObjectHelper<IfcTypeObject,2>::Construct )
+,		SchemaEntry("ifctypeproduct",&STEP::ObjectHelper<IfcTypeProduct,2>::Construct )
+,		SchemaEntry("ifcelementtype",&STEP::ObjectHelper<IfcElementType,1>::Construct )
+,		SchemaEntry("ifcdistributionelementtype",&STEP::ObjectHelper<IfcDistributionElementType,0>::Construct )
+,		SchemaEntry("ifcdistributioncontrolelementtype",&STEP::ObjectHelper<IfcDistributionControlElementType,0>::Construct )
+,		SchemaEntry("ifcactuatortype",&STEP::ObjectHelper<IfcActuatorType,1>::Construct )
+,		SchemaEntry("ifcaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrepresentationitem",&STEP::ObjectHelper<IfcRepresentationItem,0>::Construct )
+,		SchemaEntry("ifcgeometricrepresentationitem",&STEP::ObjectHelper<IfcGeometricRepresentationItem,0>::Construct )
+,		SchemaEntry("ifcsolidmodel",&STEP::ObjectHelper<IfcSolidModel,0>::Construct )
+,		SchemaEntry("ifcmanifoldsolidbrep",&STEP::ObjectHelper<IfcManifoldSolidBrep,1>::Construct )
+,		SchemaEntry("ifcadvancedbrep",&STEP::ObjectHelper<IfcAdvancedBrep,0>::Construct )
+,		SchemaEntry("ifcadvancedbrepwithvoids",&STEP::ObjectHelper<IfcAdvancedBrepWithVoids,1>::Construct )
+,		SchemaEntry("ifctopologicalrepresentationitem",&STEP::ObjectHelper<IfcTopologicalRepresentationItem,0>::Construct )
+,		SchemaEntry("ifcface",&STEP::ObjectHelper<IfcFace,1>::Construct )
+,		SchemaEntry("ifcfacesurface",&STEP::ObjectHelper<IfcFaceSurface,2>::Construct )
+,		SchemaEntry("ifcadvancedface",&STEP::ObjectHelper<IfcAdvancedFace,0>::Construct )
+,		SchemaEntry("ifcdistributionflowelement",&STEP::ObjectHelper<IfcDistributionFlowElement,0>::Construct )
+,		SchemaEntry("ifcflowterminal",&STEP::ObjectHelper<IfcFlowTerminal,0>::Construct )
+,		SchemaEntry("ifcairterminal",&STEP::ObjectHelper<IfcAirTerminal,1>::Construct )
+,		SchemaEntry("ifcflowcontroller",&STEP::ObjectHelper<IfcFlowController,0>::Construct )
+,		SchemaEntry("ifcairterminalbox",&STEP::ObjectHelper<IfcAirTerminalBox,1>::Construct )
+,		SchemaEntry("ifcdistributionflowelementtype",&STEP::ObjectHelper<IfcDistributionFlowElementType,0>::Construct )
+,		SchemaEntry("ifcflowcontrollertype",&STEP::ObjectHelper<IfcFlowControllerType,0>::Construct )
+,		SchemaEntry("ifcairterminalboxtype",&STEP::ObjectHelper<IfcAirTerminalBoxType,1>::Construct )
+,		SchemaEntry("ifcflowterminaltype",&STEP::ObjectHelper<IfcFlowTerminalType,0>::Construct )
+,		SchemaEntry("ifcairterminaltype",&STEP::ObjectHelper<IfcAirTerminalType,1>::Construct )
+,		SchemaEntry("ifcenergyconversiondevice",&STEP::ObjectHelper<IfcEnergyConversionDevice,0>::Construct )
+,		SchemaEntry("ifcairtoairheatrecovery",&STEP::ObjectHelper<IfcAirToAirHeatRecovery,1>::Construct )
+,		SchemaEntry("ifcenergyconversiondevicetype",&STEP::ObjectHelper<IfcEnergyConversionDeviceType,0>::Construct )
+,		SchemaEntry("ifcairtoairheatrecoverytype",&STEP::ObjectHelper<IfcAirToAirHeatRecoveryType,1>::Construct )
+,		SchemaEntry("ifcalarm",&STEP::ObjectHelper<IfcAlarm,1>::Construct )
+,		SchemaEntry("ifcalarmtype",&STEP::ObjectHelper<IfcAlarmType,1>::Construct )
+,		SchemaEntry("ifcannotation",&STEP::ObjectHelper<IfcAnnotation,0>::Construct )
+,		SchemaEntry("ifcannotationfillarea",&STEP::ObjectHelper<IfcAnnotationFillArea,2>::Construct )
+,		SchemaEntry("ifcapplication",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcappliedvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcresourcelevelrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcapprovalrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcprofiledef",&STEP::ObjectHelper<IfcProfileDef,2>::Construct )
+,		SchemaEntry("ifcarbitraryclosedprofiledef",&STEP::ObjectHelper<IfcArbitraryClosedProfileDef,1>::Construct )
+,		SchemaEntry("ifcarbitraryopenprofiledef",&STEP::ObjectHelper<IfcArbitraryOpenProfileDef,1>::Construct )
+,		SchemaEntry("ifcarbitraryprofiledefwithvoids",&STEP::ObjectHelper<IfcArbitraryProfileDefWithVoids,1>::Construct )
+,		SchemaEntry("ifcgroup",&STEP::ObjectHelper<IfcGroup,0>::Construct )
+,		SchemaEntry("ifcasset",&STEP::ObjectHelper<IfcAsset,9>::Construct )
+,		SchemaEntry("ifcparameterizedprofiledef",&STEP::ObjectHelper<IfcParameterizedProfileDef,1>::Construct )
+,		SchemaEntry("ifcasymmetricishapeprofiledef",&STEP::ObjectHelper<IfcAsymmetricIShapeProfileDef,12>::Construct )
+,		SchemaEntry("ifcaudiovisualappliance",&STEP::ObjectHelper<IfcAudioVisualAppliance,1>::Construct )
+,		SchemaEntry("ifcaudiovisualappliancetype",&STEP::ObjectHelper<IfcAudioVisualApplianceType,1>::Construct )
+,		SchemaEntry("ifcplacement",&STEP::ObjectHelper<IfcPlacement,1>::Construct )
+,		SchemaEntry("ifcaxis1placement",&STEP::ObjectHelper<IfcAxis1Placement,1>::Construct )
+,		SchemaEntry("ifcaxis2placement2d",&STEP::ObjectHelper<IfcAxis2Placement2D,1>::Construct )
+,		SchemaEntry("ifcaxis2placement3d",&STEP::ObjectHelper<IfcAxis2Placement3D,2>::Construct )
+,		SchemaEntry("ifccurve",&STEP::ObjectHelper<IfcCurve,0>::Construct )
+,		SchemaEntry("ifcboundedcurve",&STEP::ObjectHelper<IfcBoundedCurve,0>::Construct )
+,		SchemaEntry("ifcbsplinecurve",&STEP::ObjectHelper<IfcBSplineCurve,5>::Construct )
+,		SchemaEntry("ifcbsplinecurvewithknots",&STEP::ObjectHelper<IfcBSplineCurveWithKnots,3>::Construct )
+,		SchemaEntry("ifcsurface",&STEP::ObjectHelper<IfcSurface,0>::Construct )
+,		SchemaEntry("ifcboundedsurface",&STEP::ObjectHelper<IfcBoundedSurface,0>::Construct )
+,		SchemaEntry("ifcbsplinesurface",&STEP::ObjectHelper<IfcBSplineSurface,6>::Construct )
+,		SchemaEntry("ifcbsplinesurfacewithknots",&STEP::ObjectHelper<IfcBSplineSurfaceWithKnots,5>::Construct )
+,		SchemaEntry("ifcbuildingelement",&STEP::ObjectHelper<IfcBuildingElement,0>::Construct )
+,		SchemaEntry("ifcbeam",&STEP::ObjectHelper<IfcBeam,1>::Construct )
+,		SchemaEntry("ifcbeamstandardcase",&STEP::ObjectHelper<IfcBeamStandardCase,0>::Construct )
+,		SchemaEntry("ifcbuildingelementtype",&STEP::ObjectHelper<IfcBuildingElementType,0>::Construct )
+,		SchemaEntry("ifcbeamtype",&STEP::ObjectHelper<IfcBeamType,1>::Construct )
+,		SchemaEntry("ifcpresentationitem",&STEP::ObjectHelper<IfcPresentationItem,0>::Construct )
+,		SchemaEntry("ifcsurfacetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcblobtexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccsgprimitive3d",&STEP::ObjectHelper<IfcCsgPrimitive3D,1>::Construct )
+,		SchemaEntry("ifcblock",&STEP::ObjectHelper<IfcBlock,3>::Construct )
+,		SchemaEntry("ifcboiler",&STEP::ObjectHelper<IfcBoiler,1>::Construct )
+,		SchemaEntry("ifcboilertype",&STEP::ObjectHelper<IfcBoilerType,1>::Construct )
+,		SchemaEntry("ifcbooleanresult",&STEP::ObjectHelper<IfcBooleanResult,3>::Construct )
+,		SchemaEntry("ifcbooleanclippingresult",&STEP::ObjectHelper<IfcBooleanClippingResult,0>::Construct )
+,		SchemaEntry("ifcboundarycondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccompositecurve",&STEP::ObjectHelper<IfcCompositeCurve,2>::Construct )
+,		SchemaEntry("ifccompositecurveonsurface",&STEP::ObjectHelper<IfcCompositeCurveOnSurface,0>::Construct )
+,		SchemaEntry("ifcboundarycurve",&STEP::ObjectHelper<IfcBoundaryCurve,0>::Construct )
+,		SchemaEntry("ifcboundaryedgecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboundaryfacecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboundarynodecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboundarynodeconditionwarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboundingbox",&STEP::ObjectHelper<IfcBoundingBox,4>::Construct )
+,		SchemaEntry("ifchalfspacesolid",&STEP::ObjectHelper<IfcHalfSpaceSolid,2>::Construct )
+,		SchemaEntry("ifcboxedhalfspace",&STEP::ObjectHelper<IfcBoxedHalfSpace,1>::Construct )
+,		SchemaEntry("ifcspatialelement",&STEP::ObjectHelper<IfcSpatialElement,1>::Construct )
+,		SchemaEntry("ifcspatialstructureelement",&STEP::ObjectHelper<IfcSpatialStructureElement,1>::Construct )
+,		SchemaEntry("ifcbuilding",&STEP::ObjectHelper<IfcBuilding,3>::Construct )
+,		SchemaEntry("ifcelementcomponent",&STEP::ObjectHelper<IfcElementComponent,0>::Construct )
+,		SchemaEntry("ifcbuildingelementpart",&STEP::ObjectHelper<IfcBuildingElementPart,1>::Construct )
+,		SchemaEntry("ifcelementcomponenttype",&STEP::ObjectHelper<IfcElementComponentType,0>::Construct )
+,		SchemaEntry("ifcbuildingelementparttype",&STEP::ObjectHelper<IfcBuildingElementPartType,1>::Construct )
+,		SchemaEntry("ifcbuildingelementproxy",&STEP::ObjectHelper<IfcBuildingElementProxy,1>::Construct )
+,		SchemaEntry("ifcbuildingelementproxytype",&STEP::ObjectHelper<IfcBuildingElementProxyType,1>::Construct )
+,		SchemaEntry("ifcbuildingstorey",&STEP::ObjectHelper<IfcBuildingStorey,1>::Construct )
+,		SchemaEntry("ifcsystem",&STEP::ObjectHelper<IfcSystem,0>::Construct )
+,		SchemaEntry("ifcbuildingsystem",&STEP::ObjectHelper<IfcBuildingSystem,2>::Construct )
+,		SchemaEntry("ifcburner",&STEP::ObjectHelper<IfcBurner,1>::Construct )
+,		SchemaEntry("ifcburnertype",&STEP::ObjectHelper<IfcBurnerType,1>::Construct )
+,		SchemaEntry("ifccshapeprofiledef",&STEP::ObjectHelper<IfcCShapeProfileDef,5>::Construct )
+,		SchemaEntry("ifcflowfitting",&STEP::ObjectHelper<IfcFlowFitting,0>::Construct )
+,		SchemaEntry("ifccablecarrierfitting",&STEP::ObjectHelper<IfcCableCarrierFitting,1>::Construct )
+,		SchemaEntry("ifcflowfittingtype",&STEP::ObjectHelper<IfcFlowFittingType,0>::Construct )
+,		SchemaEntry("ifccablecarrierfittingtype",&STEP::ObjectHelper<IfcCableCarrierFittingType,1>::Construct )
+,		SchemaEntry("ifcflowsegment",&STEP::ObjectHelper<IfcFlowSegment,0>::Construct )
+,		SchemaEntry("ifccablecarriersegment",&STEP::ObjectHelper<IfcCableCarrierSegment,1>::Construct )
+,		SchemaEntry("ifcflowsegmenttype",&STEP::ObjectHelper<IfcFlowSegmentType,0>::Construct )
+,		SchemaEntry("ifccablecarriersegmenttype",&STEP::ObjectHelper<IfcCableCarrierSegmentType,1>::Construct )
+,		SchemaEntry("ifccablefitting",&STEP::ObjectHelper<IfcCableFitting,1>::Construct )
+,		SchemaEntry("ifccablefittingtype",&STEP::ObjectHelper<IfcCableFittingType,1>::Construct )
+,		SchemaEntry("ifccablesegment",&STEP::ObjectHelper<IfcCableSegment,1>::Construct )
+,		SchemaEntry("ifccablesegmenttype",&STEP::ObjectHelper<IfcCableSegmentType,1>::Construct )
+,		SchemaEntry("ifcpoint",&STEP::ObjectHelper<IfcPoint,0>::Construct )
+,		SchemaEntry("ifccartesianpoint",&STEP::ObjectHelper<IfcCartesianPoint,1>::Construct )
+,		SchemaEntry("ifccartesianpointlist",&STEP::ObjectHelper<IfcCartesianPointList,0>::Construct )
+,		SchemaEntry("ifccartesianpointlist2d",&STEP::ObjectHelper<IfcCartesianPointList2D,0>::Construct )
+,		SchemaEntry("ifccartesianpointlist3d",&STEP::ObjectHelper<IfcCartesianPointList3D,0>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator",&STEP::ObjectHelper<IfcCartesianTransformationOperator,4>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator2d",&STEP::ObjectHelper<IfcCartesianTransformationOperator2D,0>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator2dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator3d",&STEP::ObjectHelper<IfcCartesianTransformationOperator3D,1>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator3dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2>::Construct )
+,		SchemaEntry("ifccenterlineprofiledef",&STEP::ObjectHelper<IfcCenterLineProfileDef,1>::Construct )
+,		SchemaEntry("ifcchiller",&STEP::ObjectHelper<IfcChiller,1>::Construct )
+,		SchemaEntry("ifcchillertype",&STEP::ObjectHelper<IfcChillerType,1>::Construct )
+,		SchemaEntry("ifcchimney",&STEP::ObjectHelper<IfcChimney,1>::Construct )
+,		SchemaEntry("ifcchimneytype",&STEP::ObjectHelper<IfcChimneyType,1>::Construct )
+,		SchemaEntry("ifcconic",&STEP::ObjectHelper<IfcConic,1>::Construct )
+,		SchemaEntry("ifccircle",&STEP::ObjectHelper<IfcCircle,1>::Construct )
+,		SchemaEntry("ifccircleprofiledef",&STEP::ObjectHelper<IfcCircleProfileDef,1>::Construct )
+,		SchemaEntry("ifccirclehollowprofiledef",&STEP::ObjectHelper<IfcCircleHollowProfileDef,1>::Construct )
+,		SchemaEntry("ifccivilelement",&STEP::ObjectHelper<IfcCivilElement,0>::Construct )
+,		SchemaEntry("ifccivilelementtype",&STEP::ObjectHelper<IfcCivilElementType,0>::Construct )
+,		SchemaEntry("ifcexternalinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcexternalreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcclassificationreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectedfaceset",&STEP::ObjectHelper<IfcConnectedFaceSet,1>::Construct )
+,		SchemaEntry("ifcclosedshell",&STEP::ObjectHelper<IfcClosedShell,0>::Construct )
+,		SchemaEntry("ifccoil",&STEP::ObjectHelper<IfcCoil,1>::Construct )
+,		SchemaEntry("ifccoiltype",&STEP::ObjectHelper<IfcCoilType,1>::Construct )
+,		SchemaEntry("ifccolourspecification",&STEP::ObjectHelper<IfcColourSpecification,1>::Construct )
+,		SchemaEntry("ifccolourrgb",&STEP::ObjectHelper<IfcColourRgb,3>::Construct )
+,		SchemaEntry("ifccolourrgblist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccolumn",&STEP::ObjectHelper<IfcColumn,1>::Construct )
+,		SchemaEntry("ifccolumnstandardcase",&STEP::ObjectHelper<IfcColumnStandardCase,0>::Construct )
+,		SchemaEntry("ifccolumntype",&STEP::ObjectHelper<IfcColumnType,1>::Construct )
+,		SchemaEntry("ifccommunicationsappliance",&STEP::ObjectHelper<IfcCommunicationsAppliance,1>::Construct )
+,		SchemaEntry("ifccommunicationsappliancetype",&STEP::ObjectHelper<IfcCommunicationsApplianceType,1>::Construct )
+,		SchemaEntry("ifcpropertyabstraction",&STEP::ObjectHelper<IfcPropertyAbstraction,0>::Construct )
+,		SchemaEntry("ifcproperty",&STEP::ObjectHelper<IfcProperty,2>::Construct )
+,		SchemaEntry("ifccomplexproperty",&STEP::ObjectHelper<IfcComplexProperty,2>::Construct )
+,		SchemaEntry("ifcpropertydefinition",&STEP::ObjectHelper<IfcPropertyDefinition,0>::Construct )
+,		SchemaEntry("ifcpropertytemplatedefinition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccomplexpropertytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccompositecurvesegment",&STEP::ObjectHelper<IfcCompositeCurveSegment,3>::Construct )
+,		SchemaEntry("ifccompositeprofiledef",&STEP::ObjectHelper<IfcCompositeProfileDef,2>::Construct )
+,		SchemaEntry("ifcflowmovingdevice",&STEP::ObjectHelper<IfcFlowMovingDevice,0>::Construct )
+,		SchemaEntry("ifccompressor",&STEP::ObjectHelper<IfcCompressor,1>::Construct )
+,		SchemaEntry("ifcflowmovingdevicetype",&STEP::ObjectHelper<IfcFlowMovingDeviceType,0>::Construct )
+,		SchemaEntry("ifccompressortype",&STEP::ObjectHelper<IfcCompressorType,1>::Construct )
+,		SchemaEntry("ifccondenser",&STEP::ObjectHelper<IfcCondenser,1>::Construct )
+,		SchemaEntry("ifccondensertype",&STEP::ObjectHelper<IfcCondenserType,1>::Construct )
+,		SchemaEntry("ifcconnectiongeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectioncurvegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectionpointgeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectionpointeccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectionsurfacegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectionvolumegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcresource",&STEP::ObjectHelper<IfcResource,2>::Construct )
+,		SchemaEntry("ifcconstructionresource",&STEP::ObjectHelper<IfcConstructionResource,3>::Construct )
+,		SchemaEntry("ifcconstructionequipmentresource",&STEP::ObjectHelper<IfcConstructionEquipmentResource,1>::Construct )
+,		SchemaEntry("ifctyperesource",&STEP::ObjectHelper<IfcTypeResource,3>::Construct )
+,		SchemaEntry("ifcconstructionresourcetype",&STEP::ObjectHelper<IfcConstructionResourceType,2>::Construct )
+,		SchemaEntry("ifcconstructionequipmentresourcetype",&STEP::ObjectHelper<IfcConstructionEquipmentResourceType,1>::Construct )
+,		SchemaEntry("ifcconstructionmaterialresource",&STEP::ObjectHelper<IfcConstructionMaterialResource,1>::Construct )
+,		SchemaEntry("ifcconstructionmaterialresourcetype",&STEP::ObjectHelper<IfcConstructionMaterialResourceType,1>::Construct )
+,		SchemaEntry("ifcconstructionproductresource",&STEP::ObjectHelper<IfcConstructionProductResource,1>::Construct )
+,		SchemaEntry("ifcconstructionproductresourcetype",&STEP::ObjectHelper<IfcConstructionProductResourceType,1>::Construct )
+,		SchemaEntry("ifccontext",&STEP::ObjectHelper<IfcContext,5>::Construct )
+,		SchemaEntry("ifcnamedunit",&STEP::ObjectHelper<IfcNamedUnit,2>::Construct )
+,		SchemaEntry("ifccontextdependentunit",&STEP::ObjectHelper<IfcContextDependentUnit,1>::Construct )
+,		SchemaEntry("ifccontroller",&STEP::ObjectHelper<IfcController,1>::Construct )
+,		SchemaEntry("ifccontrollertype",&STEP::ObjectHelper<IfcControllerType,1>::Construct )
+,		SchemaEntry("ifcconversionbasedunit",&STEP::ObjectHelper<IfcConversionBasedUnit,2>::Construct )
+,		SchemaEntry("ifcconversionbasedunitwithoffset",&STEP::ObjectHelper<IfcConversionBasedUnitWithOffset,1>::Construct )
+,		SchemaEntry("ifccooledbeam",&STEP::ObjectHelper<IfcCooledBeam,1>::Construct )
+,		SchemaEntry("ifccooledbeamtype",&STEP::ObjectHelper<IfcCooledBeamType,1>::Construct )
+,		SchemaEntry("ifccoolingtower",&STEP::ObjectHelper<IfcCoolingTower,1>::Construct )
+,		SchemaEntry("ifccoolingtowertype",&STEP::ObjectHelper<IfcCoolingTowerType,1>::Construct )
+,		SchemaEntry("ifccoordinateoperation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccoordinatereferencesystem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccostitem",&STEP::ObjectHelper<IfcCostItem,3>::Construct )
+,		SchemaEntry("ifccostschedule",&STEP::ObjectHelper<IfcCostSchedule,4>::Construct )
+,		SchemaEntry("ifccostvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccovering",&STEP::ObjectHelper<IfcCovering,1>::Construct )
+,		SchemaEntry("ifccoveringtype",&STEP::ObjectHelper<IfcCoveringType,1>::Construct )
+,		SchemaEntry("ifccrewresource",&STEP::ObjectHelper<IfcCrewResource,1>::Construct )
+,		SchemaEntry("ifccrewresourcetype",&STEP::ObjectHelper<IfcCrewResourceType,1>::Construct )
+,		SchemaEntry("ifccsgsolid",&STEP::ObjectHelper<IfcCsgSolid,1>::Construct )
+,		SchemaEntry("ifccurrencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurtainwall",&STEP::ObjectHelper<IfcCurtainWall,1>::Construct )
+,		SchemaEntry("ifccurtainwalltype",&STEP::ObjectHelper<IfcCurtainWallType,1>::Construct )
+,		SchemaEntry("ifccurveboundedplane",&STEP::ObjectHelper<IfcCurveBoundedPlane,3>::Construct )
+,		SchemaEntry("ifccurveboundedsurface",&STEP::ObjectHelper<IfcCurveBoundedSurface,3>::Construct )
+,		SchemaEntry("ifcpresentationstyle",&STEP::ObjectHelper<IfcPresentationStyle,1>::Construct )
+,		SchemaEntry("ifccurvestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurvestylefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurvestylefontandscaling",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurvestylefontpattern",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelementarysurface",&STEP::ObjectHelper<IfcElementarySurface,1>::Construct )
+,		SchemaEntry("ifccylindricalsurface",&STEP::ObjectHelper<IfcCylindricalSurface,1>::Construct )
+,		SchemaEntry("ifcdamper",&STEP::ObjectHelper<IfcDamper,1>::Construct )
+,		SchemaEntry("ifcdampertype",&STEP::ObjectHelper<IfcDamperType,1>::Construct )
+,		SchemaEntry("ifcderivedprofiledef",&STEP::ObjectHelper<IfcDerivedProfileDef,3>::Construct )
+,		SchemaEntry("ifcderivedunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcderivedunitelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdimensionalexponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdirection",&STEP::ObjectHelper<IfcDirection,1>::Construct )
+,		SchemaEntry("ifcdiscreteaccessory",&STEP::ObjectHelper<IfcDiscreteAccessory,1>::Construct )
+,		SchemaEntry("ifcdiscreteaccessorytype",&STEP::ObjectHelper<IfcDiscreteAccessoryType,1>::Construct )
+,		SchemaEntry("ifcdistributionchamberelement",&STEP::ObjectHelper<IfcDistributionChamberElement,1>::Construct )
+,		SchemaEntry("ifcdistributionchamberelementtype",&STEP::ObjectHelper<IfcDistributionChamberElementType,1>::Construct )
+,		SchemaEntry("ifcdistributionsystem",&STEP::ObjectHelper<IfcDistributionSystem,2>::Construct )
+,		SchemaEntry("ifcdistributioncircuit",&STEP::ObjectHelper<IfcDistributionCircuit,0>::Construct )
+,		SchemaEntry("ifcport",&STEP::ObjectHelper<IfcPort,0>::Construct )
+,		SchemaEntry("ifcdistributionport",&STEP::ObjectHelper<IfcDistributionPort,3>::Construct )
+,		SchemaEntry("ifcdocumentinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdocumentinformationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdocumentreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdoor",&STEP::ObjectHelper<IfcDoor,5>::Construct )
+,		SchemaEntry("ifcpropertysetdefinition",&STEP::ObjectHelper<IfcPropertySetDefinition,0>::Construct )
+,		SchemaEntry("ifcpredefinedpropertyset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdoorliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdoorpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdoorstandardcase",&STEP::ObjectHelper<IfcDoorStandardCase,0>::Construct )
+,		SchemaEntry("ifcdoorstyle",&STEP::ObjectHelper<IfcDoorStyle,4>::Construct )
+,		SchemaEntry("ifcdoortype",&STEP::ObjectHelper<IfcDoorType,4>::Construct )
+,		SchemaEntry("ifcpredefineditem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdraughtingpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdraughtingpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcductfitting",&STEP::ObjectHelper<IfcDuctFitting,1>::Construct )
+,		SchemaEntry("ifcductfittingtype",&STEP::ObjectHelper<IfcDuctFittingType,1>::Construct )
+,		SchemaEntry("ifcductsegment",&STEP::ObjectHelper<IfcDuctSegment,1>::Construct )
+,		SchemaEntry("ifcductsegmenttype",&STEP::ObjectHelper<IfcDuctSegmentType,1>::Construct )
+,		SchemaEntry("ifcflowtreatmentdevice",&STEP::ObjectHelper<IfcFlowTreatmentDevice,0>::Construct )
+,		SchemaEntry("ifcductsilencer",&STEP::ObjectHelper<IfcDuctSilencer,1>::Construct )
+,		SchemaEntry("ifcflowtreatmentdevicetype",&STEP::ObjectHelper<IfcFlowTreatmentDeviceType,0>::Construct )
+,		SchemaEntry("ifcductsilencertype",&STEP::ObjectHelper<IfcDuctSilencerType,1>::Construct )
+,		SchemaEntry("ifcedge",&STEP::ObjectHelper<IfcEdge,2>::Construct )
+,		SchemaEntry("ifcedgecurve",&STEP::ObjectHelper<IfcEdgeCurve,2>::Construct )
+,		SchemaEntry("ifcloop",&STEP::ObjectHelper<IfcLoop,0>::Construct )
+,		SchemaEntry("ifcedgeloop",&STEP::ObjectHelper<IfcEdgeLoop,1>::Construct )
+,		SchemaEntry("ifcelectricappliance",&STEP::ObjectHelper<IfcElectricAppliance,1>::Construct )
+,		SchemaEntry("ifcelectricappliancetype",&STEP::ObjectHelper<IfcElectricApplianceType,1>::Construct )
+,		SchemaEntry("ifcelectricdistributionboard",&STEP::ObjectHelper<IfcElectricDistributionBoard,1>::Construct )
+,		SchemaEntry("ifcelectricdistributionboardtype",&STEP::ObjectHelper<IfcElectricDistributionBoardType,1>::Construct )
+,		SchemaEntry("ifcflowstoragedevice",&STEP::ObjectHelper<IfcFlowStorageDevice,0>::Construct )
+,		SchemaEntry("ifcelectricflowstoragedevice",&STEP::ObjectHelper<IfcElectricFlowStorageDevice,1>::Construct )
+,		SchemaEntry("ifcflowstoragedevicetype",&STEP::ObjectHelper<IfcFlowStorageDeviceType,0>::Construct )
+,		SchemaEntry("ifcelectricflowstoragedevicetype",&STEP::ObjectHelper<IfcElectricFlowStorageDeviceType,1>::Construct )
+,		SchemaEntry("ifcelectricgenerator",&STEP::ObjectHelper<IfcElectricGenerator,1>::Construct )
+,		SchemaEntry("ifcelectricgeneratortype",&STEP::ObjectHelper<IfcElectricGeneratorType,1>::Construct )
+,		SchemaEntry("ifcelectricmotor",&STEP::ObjectHelper<IfcElectricMotor,1>::Construct )
+,		SchemaEntry("ifcelectricmotortype",&STEP::ObjectHelper<IfcElectricMotorType,1>::Construct )
+,		SchemaEntry("ifcelectrictimecontrol",&STEP::ObjectHelper<IfcElectricTimeControl,1>::Construct )
+,		SchemaEntry("ifcelectrictimecontroltype",&STEP::ObjectHelper<IfcElectricTimeControlType,1>::Construct )
+,		SchemaEntry("ifcelementassembly",&STEP::ObjectHelper<IfcElementAssembly,2>::Construct )
+,		SchemaEntry("ifcelementassemblytype",&STEP::ObjectHelper<IfcElementAssemblyType,1>::Construct )
+,		SchemaEntry("ifcquantityset",&STEP::ObjectHelper<IfcQuantitySet,0>::Construct )
+,		SchemaEntry("ifcelementquantity",&STEP::ObjectHelper<IfcElementQuantity,2>::Construct )
+,		SchemaEntry("ifcellipse",&STEP::ObjectHelper<IfcEllipse,2>::Construct )
+,		SchemaEntry("ifcellipseprofiledef",&STEP::ObjectHelper<IfcEllipseProfileDef,2>::Construct )
+,		SchemaEntry("ifcengine",&STEP::ObjectHelper<IfcEngine,1>::Construct )
+,		SchemaEntry("ifcenginetype",&STEP::ObjectHelper<IfcEngineType,1>::Construct )
+,		SchemaEntry("ifcevaporativecooler",&STEP::ObjectHelper<IfcEvaporativeCooler,1>::Construct )
+,		SchemaEntry("ifcevaporativecoolertype",&STEP::ObjectHelper<IfcEvaporativeCoolerType,1>::Construct )
+,		SchemaEntry("ifcevaporator",&STEP::ObjectHelper<IfcEvaporator,1>::Construct )
+,		SchemaEntry("ifcevaporatortype",&STEP::ObjectHelper<IfcEvaporatorType,1>::Construct )
+,		SchemaEntry("ifcprocess",&STEP::ObjectHelper<IfcProcess,2>::Construct )
+,		SchemaEntry("ifcevent",&STEP::ObjectHelper<IfcEvent,4>::Construct )
+,		SchemaEntry("ifcschedulingtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifceventtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctypeprocess",&STEP::ObjectHelper<IfcTypeProcess,3>::Construct )
+,		SchemaEntry("ifceventtype",&STEP::ObjectHelper<IfcEventType,3>::Construct )
+,		SchemaEntry("ifcextendedproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcexternalreferencerelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcexternalspatialstructureelement",&STEP::ObjectHelper<IfcExternalSpatialStructureElement,0>::Construct )
+,		SchemaEntry("ifcexternalspatialelement",&STEP::ObjectHelper<IfcExternalSpatialElement,1>::Construct )
+,		SchemaEntry("ifcexternallydefinedhatchstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcexternallydefinedsurfacestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcexternallydefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsweptareasolid",&STEP::ObjectHelper<IfcSweptAreaSolid,2>::Construct )
+,		SchemaEntry("ifcextrudedareasolid",&STEP::ObjectHelper<IfcExtrudedAreaSolid,2>::Construct )
+,		SchemaEntry("ifcextrudedareasolidtapered",&STEP::ObjectHelper<IfcExtrudedAreaSolidTapered,1>::Construct )
+,		SchemaEntry("ifcfacebasedsurfacemodel",&STEP::ObjectHelper<IfcFaceBasedSurfaceModel,1>::Construct )
+,		SchemaEntry("ifcfacebound",&STEP::ObjectHelper<IfcFaceBound,2>::Construct )
+,		SchemaEntry("ifcfaceouterbound",&STEP::ObjectHelper<IfcFaceOuterBound,0>::Construct )
+,		SchemaEntry("ifcfacetedbrep",&STEP::ObjectHelper<IfcFacetedBrep,0>::Construct )
+,		SchemaEntry("ifcfacetedbrepwithvoids",&STEP::ObjectHelper<IfcFacetedBrepWithVoids,1>::Construct )
+,		SchemaEntry("ifcstructuralconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfailureconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfan",&STEP::ObjectHelper<IfcFan,1>::Construct )
+,		SchemaEntry("ifcfantype",&STEP::ObjectHelper<IfcFanType,1>::Construct )
+,		SchemaEntry("ifcfastener",&STEP::ObjectHelper<IfcFastener,1>::Construct )
+,		SchemaEntry("ifcfastenertype",&STEP::ObjectHelper<IfcFastenerType,1>::Construct )
+,		SchemaEntry("ifcfeatureelement",&STEP::ObjectHelper<IfcFeatureElement,0>::Construct )
+,		SchemaEntry("ifcfeatureelementaddition",&STEP::ObjectHelper<IfcFeatureElementAddition,0>::Construct )
+,		SchemaEntry("ifcfeatureelementsubtraction",&STEP::ObjectHelper<IfcFeatureElementSubtraction,0>::Construct )
+,		SchemaEntry("ifcfillareastyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfillareastylehatching",&STEP::ObjectHelper<IfcFillAreaStyleHatching,5>::Construct )
+,		SchemaEntry("ifcfillareastyletiles",&STEP::ObjectHelper<IfcFillAreaStyleTiles,3>::Construct )
+,		SchemaEntry("ifcfilter",&STEP::ObjectHelper<IfcFilter,1>::Construct )
+,		SchemaEntry("ifcfiltertype",&STEP::ObjectHelper<IfcFilterType,1>::Construct )
+,		SchemaEntry("ifcfiresuppressionterminal",&STEP::ObjectHelper<IfcFireSuppressionTerminal,1>::Construct )
+,		SchemaEntry("ifcfiresuppressionterminaltype",&STEP::ObjectHelper<IfcFireSuppressionTerminalType,1>::Construct )
+,		SchemaEntry("ifcfixedreferencesweptareasolid",&STEP::ObjectHelper<IfcFixedReferenceSweptAreaSolid,4>::Construct )
+,		SchemaEntry("ifcflowinstrument",&STEP::ObjectHelper<IfcFlowInstrument,1>::Construct )
+,		SchemaEntry("ifcflowinstrumenttype",&STEP::ObjectHelper<IfcFlowInstrumentType,1>::Construct )
+,		SchemaEntry("ifcflowmeter",&STEP::ObjectHelper<IfcFlowMeter,1>::Construct )
+,		SchemaEntry("ifcflowmetertype",&STEP::ObjectHelper<IfcFlowMeterType,1>::Construct )
+,		SchemaEntry("ifcfooting",&STEP::ObjectHelper<IfcFooting,1>::Construct )
+,		SchemaEntry("ifcfootingtype",&STEP::ObjectHelper<IfcFootingType,1>::Construct )
+,		SchemaEntry("ifcfurnishingelement",&STEP::ObjectHelper<IfcFurnishingElement,0>::Construct )
+,		SchemaEntry("ifcfurnishingelementtype",&STEP::ObjectHelper<IfcFurnishingElementType,0>::Construct )
+,		SchemaEntry("ifcfurniture",&STEP::ObjectHelper<IfcFurniture,1>::Construct )
+,		SchemaEntry("ifcfurnituretype",&STEP::ObjectHelper<IfcFurnitureType,2>::Construct )
+,		SchemaEntry("ifcgeographicelement",&STEP::ObjectHelper<IfcGeographicElement,1>::Construct )
+,		SchemaEntry("ifcgeographicelementtype",&STEP::ObjectHelper<IfcGeographicElementType,1>::Construct )
+,		SchemaEntry("ifcgeometricset",&STEP::ObjectHelper<IfcGeometricSet,1>::Construct )
+,		SchemaEntry("ifcgeometriccurveset",&STEP::ObjectHelper<IfcGeometricCurveSet,0>::Construct )
+,		SchemaEntry("ifcrepresentationcontext",&STEP::ObjectHelper<IfcRepresentationContext,2>::Construct )
+,		SchemaEntry("ifcgeometricrepresentationcontext",&STEP::ObjectHelper<IfcGeometricRepresentationContext,4>::Construct )
+,		SchemaEntry("ifcgeometricrepresentationsubcontext",&STEP::ObjectHelper<IfcGeometricRepresentationSubContext,4>::Construct )
+,		SchemaEntry("ifcgrid",&STEP::ObjectHelper<IfcGrid,4>::Construct )
+,		SchemaEntry("ifcgridaxis",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcobjectplacement",&STEP::ObjectHelper<IfcObjectPlacement,0>::Construct )
+,		SchemaEntry("ifcgridplacement",&STEP::ObjectHelper<IfcGridPlacement,2>::Construct )
+,		SchemaEntry("ifcheatexchanger",&STEP::ObjectHelper<IfcHeatExchanger,1>::Construct )
+,		SchemaEntry("ifcheatexchangertype",&STEP::ObjectHelper<IfcHeatExchangerType,1>::Construct )
+,		SchemaEntry("ifchumidifier",&STEP::ObjectHelper<IfcHumidifier,1>::Construct )
+,		SchemaEntry("ifchumidifiertype",&STEP::ObjectHelper<IfcHumidifierType,1>::Construct )
+,		SchemaEntry("ifcishapeprofiledef",&STEP::ObjectHelper<IfcIShapeProfileDef,7>::Construct )
+,		SchemaEntry("ifcimagetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcindexedcolourmap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcindexedpolycurve",&STEP::ObjectHelper<IfcIndexedPolyCurve,3>::Construct )
+,		SchemaEntry("ifctessellateditem",&STEP::ObjectHelper<IfcTessellatedItem,0>::Construct )
+,		SchemaEntry("ifcindexedpolygonalface",&STEP::ObjectHelper<IfcIndexedPolygonalFace,1>::Construct )
+,		SchemaEntry("ifcindexedpolygonalfacewithvoids",&STEP::ObjectHelper<IfcIndexedPolygonalFaceWithVoids,0>::Construct )
+,		SchemaEntry("ifctexturecoordinate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcindexedtexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcindexedtriangletexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcinterceptor",&STEP::ObjectHelper<IfcInterceptor,1>::Construct )
+,		SchemaEntry("ifcinterceptortype",&STEP::ObjectHelper<IfcInterceptorType,1>::Construct )
+,		SchemaEntry("ifcsurfacecurve",&STEP::ObjectHelper<IfcSurfaceCurve,3>::Construct )
+,		SchemaEntry("ifcintersectioncurve",&STEP::ObjectHelper<IfcIntersectionCurve,0>::Construct )
+,		SchemaEntry("ifcinventory",&STEP::ObjectHelper<IfcInventory,6>::Construct )
+,		SchemaEntry("ifctimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcirregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcirregulartimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcjunctionbox",&STEP::ObjectHelper<IfcJunctionBox,1>::Construct )
+,		SchemaEntry("ifcjunctionboxtype",&STEP::ObjectHelper<IfcJunctionBoxType,1>::Construct )
+,		SchemaEntry("ifclshapeprofiledef",&STEP::ObjectHelper<IfcLShapeProfileDef,6>::Construct )
+,		SchemaEntry("ifclaborresource",&STEP::ObjectHelper<IfcLaborResource,1>::Construct )
+,		SchemaEntry("ifclaborresourcetype",&STEP::ObjectHelper<IfcLaborResourceType,1>::Construct )
+,		SchemaEntry("ifclagtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclamp",&STEP::ObjectHelper<IfcLamp,1>::Construct )
+,		SchemaEntry("ifclamptype",&STEP::ObjectHelper<IfcLampType,1>::Construct )
+,		SchemaEntry("ifclibraryinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclibraryreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclightdistributiondata",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclightfixture",&STEP::ObjectHelper<IfcLightFixture,1>::Construct )
+,		SchemaEntry("ifclightfixturetype",&STEP::ObjectHelper<IfcLightFixtureType,1>::Construct )
+,		SchemaEntry("ifclightintensitydistribution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclightsource",&STEP::ObjectHelper<IfcLightSource,4>::Construct )
+,		SchemaEntry("ifclightsourceambient",&STEP::ObjectHelper<IfcLightSourceAmbient,0>::Construct )
+,		SchemaEntry("ifclightsourcedirectional",&STEP::ObjectHelper<IfcLightSourceDirectional,1>::Construct )
+,		SchemaEntry("ifclightsourcegoniometric",&STEP::ObjectHelper<IfcLightSourceGoniometric,6>::Construct )
+,		SchemaEntry("ifclightsourcepositional",&STEP::ObjectHelper<IfcLightSourcePositional,5>::Construct )
+,		SchemaEntry("ifclightsourcespot",&STEP::ObjectHelper<IfcLightSourceSpot,4>::Construct )
+,		SchemaEntry("ifcline",&STEP::ObjectHelper<IfcLine,2>::Construct )
+,		SchemaEntry("ifclocalplacement",&STEP::ObjectHelper<IfcLocalPlacement,2>::Construct )
+,		SchemaEntry("ifcmapconversion",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmappeditem",&STEP::ObjectHelper<IfcMappedItem,2>::Construct )
+,		SchemaEntry("ifcmaterialdefinition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialclassificationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialconstituent",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialconstituentset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcproductrepresentation",&STEP::ObjectHelper<IfcProductRepresentation,3>::Construct )
+,		SchemaEntry("ifcmaterialdefinitionrepresentation",&STEP::ObjectHelper<IfcMaterialDefinitionRepresentation,1>::Construct )
+,		SchemaEntry("ifcmateriallayer",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmateriallayerset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialusagedefinition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmateriallayersetusage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmateriallayerwithoffsets",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmateriallist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialprofile",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialprofileset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialprofilesetusage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialprofilesetusagetapering",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialprofilewithoffsets",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmaterialrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmeasurewithunit",&STEP::ObjectHelper<IfcMeasureWithUnit,2>::Construct )
+,		SchemaEntry("ifcmechanicalfastener",&STEP::ObjectHelper<IfcMechanicalFastener,3>::Construct )
+,		SchemaEntry("ifcmechanicalfastenertype",&STEP::ObjectHelper<IfcMechanicalFastenerType,3>::Construct )
+,		SchemaEntry("ifcmedicaldevice",&STEP::ObjectHelper<IfcMedicalDevice,1>::Construct )
+,		SchemaEntry("ifcmedicaldevicetype",&STEP::ObjectHelper<IfcMedicalDeviceType,1>::Construct )
+,		SchemaEntry("ifcmember",&STEP::ObjectHelper<IfcMember,1>::Construct )
+,		SchemaEntry("ifcmemberstandardcase",&STEP::ObjectHelper<IfcMemberStandardCase,0>::Construct )
+,		SchemaEntry("ifcmembertype",&STEP::ObjectHelper<IfcMemberType,1>::Construct )
+,		SchemaEntry("ifcmetric",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmirroredprofiledef",&STEP::ObjectHelper<IfcMirroredProfileDef,0>::Construct )
+,		SchemaEntry("ifcmonetaryunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmotorconnection",&STEP::ObjectHelper<IfcMotorConnection,1>::Construct )
+,		SchemaEntry("ifcmotorconnectiontype",&STEP::ObjectHelper<IfcMotorConnectionType,1>::Construct )
+,		SchemaEntry("ifcobjective",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcoccupant",&STEP::ObjectHelper<IfcOccupant,1>::Construct )
+,		SchemaEntry("ifcoffsetcurve2d",&STEP::ObjectHelper<IfcOffsetCurve2D,3>::Construct )
+,		SchemaEntry("ifcoffsetcurve3d",&STEP::ObjectHelper<IfcOffsetCurve3D,4>::Construct )
+,		SchemaEntry("ifcopenshell",&STEP::ObjectHelper<IfcOpenShell,0>::Construct )
+,		SchemaEntry("ifcopeningelement",&STEP::ObjectHelper<IfcOpeningElement,1>::Construct )
+,		SchemaEntry("ifcopeningstandardcase",&STEP::ObjectHelper<IfcOpeningStandardCase,0>::Construct )
+,		SchemaEntry("ifcorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcorganizationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcorientededge",&STEP::ObjectHelper<IfcOrientedEdge,2>::Construct )
+,		SchemaEntry("ifcouterboundarycurve",&STEP::ObjectHelper<IfcOuterBoundaryCurve,0>::Construct )
+,		SchemaEntry("ifcoutlet",&STEP::ObjectHelper<IfcOutlet,1>::Construct )
+,		SchemaEntry("ifcoutlettype",&STEP::ObjectHelper<IfcOutletType,1>::Construct )
+,		SchemaEntry("ifcownerhistory",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpath",&STEP::ObjectHelper<IfcPath,1>::Construct )
+,		SchemaEntry("ifcpcurve",&STEP::ObjectHelper<IfcPcurve,2>::Construct )
+,		SchemaEntry("ifcperformancehistory",&STEP::ObjectHelper<IfcPerformanceHistory,2>::Construct )
+,		SchemaEntry("ifcpermeablecoveringproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpermit",&STEP::ObjectHelper<IfcPermit,3>::Construct )
+,		SchemaEntry("ifcperson",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpersonandorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcphysicalquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcphysicalcomplexquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcphysicalsimplequantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpile",&STEP::ObjectHelper<IfcPile,2>::Construct )
+,		SchemaEntry("ifcpiletype",&STEP::ObjectHelper<IfcPileType,1>::Construct )
+,		SchemaEntry("ifcpipefitting",&STEP::ObjectHelper<IfcPipeFitting,1>::Construct )
+,		SchemaEntry("ifcpipefittingtype",&STEP::ObjectHelper<IfcPipeFittingType,1>::Construct )
+,		SchemaEntry("ifcpipesegment",&STEP::ObjectHelper<IfcPipeSegment,1>::Construct )
+,		SchemaEntry("ifcpipesegmenttype",&STEP::ObjectHelper<IfcPipeSegmentType,1>::Construct )
+,		SchemaEntry("ifcpixeltexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcplanarextent",&STEP::ObjectHelper<IfcPlanarExtent,2>::Construct )
+,		SchemaEntry("ifcplanarbox",&STEP::ObjectHelper<IfcPlanarBox,1>::Construct )
+,		SchemaEntry("ifcplane",&STEP::ObjectHelper<IfcPlane,0>::Construct )
+,		SchemaEntry("ifcplate",&STEP::ObjectHelper<IfcPlate,1>::Construct )
+,		SchemaEntry("ifcplatestandardcase",&STEP::ObjectHelper<IfcPlateStandardCase,0>::Construct )
+,		SchemaEntry("ifcplatetype",&STEP::ObjectHelper<IfcPlateType,1>::Construct )
+,		SchemaEntry("ifcpointoncurve",&STEP::ObjectHelper<IfcPointOnCurve,2>::Construct )
+,		SchemaEntry("ifcpointonsurface",&STEP::ObjectHelper<IfcPointOnSurface,3>::Construct )
+,		SchemaEntry("ifcpolyloop",&STEP::ObjectHelper<IfcPolyLoop,1>::Construct )
+,		SchemaEntry("ifcpolygonalboundedhalfspace",&STEP::ObjectHelper<IfcPolygonalBoundedHalfSpace,2>::Construct )
+,		SchemaEntry("ifctessellatedfaceset",&STEP::ObjectHelper<IfcTessellatedFaceSet,1>::Construct )
+,		SchemaEntry("ifcpolygonalfaceset",&STEP::ObjectHelper<IfcPolygonalFaceSet,3>::Construct )
+,		SchemaEntry("ifcpolyline",&STEP::ObjectHelper<IfcPolyline,1>::Construct )
+,		SchemaEntry("ifcpostaladdress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpresentationlayerassignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpresentationlayerwithstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpresentationstyleassignment",&STEP::ObjectHelper<IfcPresentationStyleAssignment,1>::Construct )
+,		SchemaEntry("ifcprocedure",&STEP::ObjectHelper<IfcProcedure,1>::Construct )
+,		SchemaEntry("ifcproceduretype",&STEP::ObjectHelper<IfcProcedureType,1>::Construct )
+,		SchemaEntry("ifcproductdefinitionshape",&STEP::ObjectHelper<IfcProductDefinitionShape,0>::Construct )
+,		SchemaEntry("ifcprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcproject",&STEP::ObjectHelper<IfcProject,0>::Construct )
+,		SchemaEntry("ifcprojectlibrary",&STEP::ObjectHelper<IfcProjectLibrary,0>::Construct )
+,		SchemaEntry("ifcprojectorder",&STEP::ObjectHelper<IfcProjectOrder,3>::Construct )
+,		SchemaEntry("ifcprojectedcrs",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcprojectionelement",&STEP::ObjectHelper<IfcProjectionElement,1>::Construct )
+,		SchemaEntry("ifcsimpleproperty",&STEP::ObjectHelper<IfcSimpleProperty,0>::Construct )
+,		SchemaEntry("ifcpropertyboundedvalue",&STEP::ObjectHelper<IfcPropertyBoundedValue,4>::Construct )
+,		SchemaEntry("ifcpropertydependencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertyenumeratedvalue",&STEP::ObjectHelper<IfcPropertyEnumeratedValue,2>::Construct )
+,		SchemaEntry("ifcpropertyenumeration",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertylistvalue",&STEP::ObjectHelper<IfcPropertyListValue,2>::Construct )
+,		SchemaEntry("ifcpropertyreferencevalue",&STEP::ObjectHelper<IfcPropertyReferenceValue,2>::Construct )
+,		SchemaEntry("ifcpropertyset",&STEP::ObjectHelper<IfcPropertySet,1>::Construct )
+,		SchemaEntry("ifcpropertysettemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertysinglevalue",&STEP::ObjectHelper<IfcPropertySingleValue,2>::Construct )
+,		SchemaEntry("ifcpropertytablevalue",&STEP::ObjectHelper<IfcPropertyTableValue,6>::Construct )
+,		SchemaEntry("ifcprotectivedevice",&STEP::ObjectHelper<IfcProtectiveDevice,1>::Construct )
+,		SchemaEntry("ifcprotectivedevicetrippingunit",&STEP::ObjectHelper<IfcProtectiveDeviceTrippingUnit,1>::Construct )
+,		SchemaEntry("ifcprotectivedevicetrippingunittype",&STEP::ObjectHelper<IfcProtectiveDeviceTrippingUnitType,1>::Construct )
+,		SchemaEntry("ifcprotectivedevicetype",&STEP::ObjectHelper<IfcProtectiveDeviceType,1>::Construct )
+,		SchemaEntry("ifcproxy",&STEP::ObjectHelper<IfcProxy,2>::Construct )
+,		SchemaEntry("ifcpump",&STEP::ObjectHelper<IfcPump,1>::Construct )
+,		SchemaEntry("ifcpumptype",&STEP::ObjectHelper<IfcPumpType,1>::Construct )
+,		SchemaEntry("ifcquantityarea",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantitycount",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantitylength",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantitytime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantityvolume",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantityweight",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrailing",&STEP::ObjectHelper<IfcRailing,1>::Construct )
+,		SchemaEntry("ifcrailingtype",&STEP::ObjectHelper<IfcRailingType,1>::Construct )
+,		SchemaEntry("ifcramp",&STEP::ObjectHelper<IfcRamp,1>::Construct )
+,		SchemaEntry("ifcrampflight",&STEP::ObjectHelper<IfcRampFlight,1>::Construct )
+,		SchemaEntry("ifcrampflighttype",&STEP::ObjectHelper<IfcRampFlightType,1>::Construct )
+,		SchemaEntry("ifcramptype",&STEP::ObjectHelper<IfcRampType,1>::Construct )
+,		SchemaEntry("ifcrationalbsplinecurvewithknots",&STEP::ObjectHelper<IfcRationalBSplineCurveWithKnots,1>::Construct )
+,		SchemaEntry("ifcrationalbsplinesurfacewithknots",&STEP::ObjectHelper<IfcRationalBSplineSurfaceWithKnots,0>::Construct )
+,		SchemaEntry("ifcrectangleprofiledef",&STEP::ObjectHelper<IfcRectangleProfileDef,2>::Construct )
+,		SchemaEntry("ifcrectanglehollowprofiledef",&STEP::ObjectHelper<IfcRectangleHollowProfileDef,3>::Construct )
+,		SchemaEntry("ifcrectangularpyramid",&STEP::ObjectHelper<IfcRectangularPyramid,3>::Construct )
+,		SchemaEntry("ifcrectangulartrimmedsurface",&STEP::ObjectHelper<IfcRectangularTrimmedSurface,7>::Construct )
+,		SchemaEntry("ifcrecurrencepattern",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreinforcementbarproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreinforcementdefinitionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreinforcingelement",&STEP::ObjectHelper<IfcReinforcingElement,1>::Construct )
+,		SchemaEntry("ifcreinforcingbar",&STEP::ObjectHelper<IfcReinforcingBar,5>::Construct )
+,		SchemaEntry("ifcreinforcingelementtype",&STEP::ObjectHelper<IfcReinforcingElementType,0>::Construct )
+,		SchemaEntry("ifcreinforcingbartype",&STEP::ObjectHelper<IfcReinforcingBarType,7>::Construct )
+,		SchemaEntry("ifcreinforcingmesh",&STEP::ObjectHelper<IfcReinforcingMesh,9>::Construct )
+,		SchemaEntry("ifcreinforcingmeshtype",&STEP::ObjectHelper<IfcReinforcingMeshType,11>::Construct )
+,		SchemaEntry("ifcrelationship",&STEP::ObjectHelper<IfcRelationship,0>::Construct )
+,		SchemaEntry("ifcreldecomposes",&STEP::ObjectHelper<IfcRelDecomposes,0>::Construct )
+,		SchemaEntry("ifcrelaggregates",&STEP::ObjectHelper<IfcRelAggregates,2>::Construct )
+,		SchemaEntry("ifcrelassigns",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstoactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstocontrol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstogroup",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstogroupbyfactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstoprocess",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstoproduct",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstoresource",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociates",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesdocument",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociateslibrary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnects",&STEP::ObjectHelper<IfcRelConnects,0>::Construct )
+,		SchemaEntry("ifcrelconnectselements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectspathelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectsporttoelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectsports",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectsstructuralactivity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectsstructuralmember",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectswitheccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectswithrealizingelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelcontainedinspatialstructure",&STEP::ObjectHelper<IfcRelContainedInSpatialStructure,2>::Construct )
+,		SchemaEntry("ifcrelcoversbldgelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelcoversspaces",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreldeclares",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreldefines",&STEP::ObjectHelper<IfcRelDefines,0>::Construct )
+,		SchemaEntry("ifcreldefinesbyobject",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreldefinesbyproperties",&STEP::ObjectHelper<IfcRelDefinesByProperties,2>::Construct )
+,		SchemaEntry("ifcreldefinesbytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreldefinesbytype",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelfillselement",&STEP::ObjectHelper<IfcRelFillsElement,2>::Construct )
+,		SchemaEntry("ifcrelflowcontrolelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelinterfereselements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelnests",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelprojectselement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelreferencedinspatialstructure",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelsequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelservicesbuildings",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelspaceboundary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelspaceboundary1stlevel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelspaceboundary2ndlevel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelvoidselement",&STEP::ObjectHelper<IfcRelVoidsElement,2>::Construct )
+,		SchemaEntry("ifcreparametrisedcompositecurvesegment",&STEP::ObjectHelper<IfcReparametrisedCompositeCurveSegment,1>::Construct )
+,		SchemaEntry("ifcrepresentation",&STEP::ObjectHelper<IfcRepresentation,4>::Construct )
+,		SchemaEntry("ifcrepresentationmap",&STEP::ObjectHelper<IfcRepresentationMap,2>::Construct )
+,		SchemaEntry("ifcresourceapprovalrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcresourceconstraintrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcresourcetime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrevolvedareasolid",&STEP::ObjectHelper<IfcRevolvedAreaSolid,2>::Construct )
+,		SchemaEntry("ifcrevolvedareasolidtapered",&STEP::ObjectHelper<IfcRevolvedAreaSolidTapered,1>::Construct )
+,		SchemaEntry("ifcrightcircularcone",&STEP::ObjectHelper<IfcRightCircularCone,2>::Construct )
+,		SchemaEntry("ifcrightcircularcylinder",&STEP::ObjectHelper<IfcRightCircularCylinder,2>::Construct )
+,		SchemaEntry("ifcroof",&STEP::ObjectHelper<IfcRoof,1>::Construct )
+,		SchemaEntry("ifcrooftype",&STEP::ObjectHelper<IfcRoofType,1>::Construct )
+,		SchemaEntry("ifcroundedrectangleprofiledef",&STEP::ObjectHelper<IfcRoundedRectangleProfileDef,1>::Construct )
+,		SchemaEntry("ifcsiunit",&STEP::ObjectHelper<IfcSIUnit,2>::Construct )
+,		SchemaEntry("ifcsanitaryterminal",&STEP::ObjectHelper<IfcSanitaryTerminal,1>::Construct )
+,		SchemaEntry("ifcsanitaryterminaltype",&STEP::ObjectHelper<IfcSanitaryTerminalType,1>::Construct )
+,		SchemaEntry("ifcseamcurve",&STEP::ObjectHelper<IfcSeamCurve,0>::Construct )
+,		SchemaEntry("ifcsectionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsectionreinforcementproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsectionedspine",&STEP::ObjectHelper<IfcSectionedSpine,3>::Construct )
+,		SchemaEntry("ifcsensor",&STEP::ObjectHelper<IfcSensor,1>::Construct )
+,		SchemaEntry("ifcsensortype",&STEP::ObjectHelper<IfcSensorType,1>::Construct )
+,		SchemaEntry("ifcshadingdevice",&STEP::ObjectHelper<IfcShadingDevice,1>::Construct )
+,		SchemaEntry("ifcshadingdevicetype",&STEP::ObjectHelper<IfcShadingDeviceType,1>::Construct )
+,		SchemaEntry("ifcshapeaspect",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcshapemodel",&STEP::ObjectHelper<IfcShapeModel,0>::Construct )
+,		SchemaEntry("ifcshaperepresentation",&STEP::ObjectHelper<IfcShapeRepresentation,0>::Construct )
+,		SchemaEntry("ifcshellbasedsurfacemodel",&STEP::ObjectHelper<IfcShellBasedSurfaceModel,1>::Construct )
+,		SchemaEntry("ifcsimplepropertytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsite",&STEP::ObjectHelper<IfcSite,5>::Construct )
+,		SchemaEntry("ifcslab",&STEP::ObjectHelper<IfcSlab,1>::Construct )
+,		SchemaEntry("ifcslabelementedcase",&STEP::ObjectHelper<IfcSlabElementedCase,0>::Construct )
+,		SchemaEntry("ifcslabstandardcase",&STEP::ObjectHelper<IfcSlabStandardCase,0>::Construct )
+,		SchemaEntry("ifcslabtype",&STEP::ObjectHelper<IfcSlabType,1>::Construct )
+,		SchemaEntry("ifcslippageconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsolardevice",&STEP::ObjectHelper<IfcSolarDevice,1>::Construct )
+,		SchemaEntry("ifcsolardevicetype",&STEP::ObjectHelper<IfcSolarDeviceType,1>::Construct )
+,		SchemaEntry("ifcspace",&STEP::ObjectHelper<IfcSpace,2>::Construct )
+,		SchemaEntry("ifcspaceheater",&STEP::ObjectHelper<IfcSpaceHeater,1>::Construct )
+,		SchemaEntry("ifcspaceheatertype",&STEP::ObjectHelper<IfcSpaceHeaterType,1>::Construct )
+,		SchemaEntry("ifcspatialelementtype",&STEP::ObjectHelper<IfcSpatialElementType,1>::Construct )
+,		SchemaEntry("ifcspatialstructureelementtype",&STEP::ObjectHelper<IfcSpatialStructureElementType,0>::Construct )
+,		SchemaEntry("ifcspacetype",&STEP::ObjectHelper<IfcSpaceType,2>::Construct )
+,		SchemaEntry("ifcspatialzone",&STEP::ObjectHelper<IfcSpatialZone,1>::Construct )
+,		SchemaEntry("ifcspatialzonetype",&STEP::ObjectHelper<IfcSpatialZoneType,2>::Construct )
+,		SchemaEntry("ifcsphere",&STEP::ObjectHelper<IfcSphere,1>::Construct )
+,		SchemaEntry("ifcsphericalsurface",&STEP::ObjectHelper<IfcSphericalSurface,1>::Construct )
+,		SchemaEntry("ifcstackterminal",&STEP::ObjectHelper<IfcStackTerminal,1>::Construct )
+,		SchemaEntry("ifcstackterminaltype",&STEP::ObjectHelper<IfcStackTerminalType,1>::Construct )
+,		SchemaEntry("ifcstair",&STEP::ObjectHelper<IfcStair,1>::Construct )
+,		SchemaEntry("ifcstairflight",&STEP::ObjectHelper<IfcStairFlight,5>::Construct )
+,		SchemaEntry("ifcstairflighttype",&STEP::ObjectHelper<IfcStairFlightType,1>::Construct )
+,		SchemaEntry("ifcstairtype",&STEP::ObjectHelper<IfcStairType,1>::Construct )
+,		SchemaEntry("ifcstructuralactivity",&STEP::ObjectHelper<IfcStructuralActivity,2>::Construct )
+,		SchemaEntry("ifcstructuralaction",&STEP::ObjectHelper<IfcStructuralAction,1>::Construct )
+,		SchemaEntry("ifcstructuralanalysismodel",&STEP::ObjectHelper<IfcStructuralAnalysisModel,5>::Construct )
+,		SchemaEntry("ifcstructuralitem",&STEP::ObjectHelper<IfcStructuralItem,0>::Construct )
+,		SchemaEntry("ifcstructuralconnection",&STEP::ObjectHelper<IfcStructuralConnection,1>::Construct )
+,		SchemaEntry("ifcstructuralcurveaction",&STEP::ObjectHelper<IfcStructuralCurveAction,2>::Construct )
+,		SchemaEntry("ifcstructuralcurveconnection",&STEP::ObjectHelper<IfcStructuralCurveConnection,1>::Construct )
+,		SchemaEntry("ifcstructuralmember",&STEP::ObjectHelper<IfcStructuralMember,0>::Construct )
+,		SchemaEntry("ifcstructuralcurvemember",&STEP::ObjectHelper<IfcStructuralCurveMember,2>::Construct )
+,		SchemaEntry("ifcstructuralcurvemembervarying",&STEP::ObjectHelper<IfcStructuralCurveMemberVarying,0>::Construct )
+,		SchemaEntry("ifcstructuralreaction",&STEP::ObjectHelper<IfcStructuralReaction,0>::Construct )
+,		SchemaEntry("ifcstructuralcurvereaction",&STEP::ObjectHelper<IfcStructuralCurveReaction,1>::Construct )
+,		SchemaEntry("ifcstructurallinearaction",&STEP::ObjectHelper<IfcStructuralLinearAction,0>::Construct )
+,		SchemaEntry("ifcstructuralload",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadgroup",&STEP::ObjectHelper<IfcStructuralLoadGroup,5>::Construct )
+,		SchemaEntry("ifcstructuralloadcase",&STEP::ObjectHelper<IfcStructuralLoadCase,1>::Construct )
+,		SchemaEntry("ifcstructuralloadconfiguration",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadorresult",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadstatic",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadlinearforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadplanarforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingledisplacement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingledisplacementdistortion",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingleforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingleforcewarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadtemperature",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralsurfaceaction",&STEP::ObjectHelper<IfcStructuralSurfaceAction,2>::Construct )
+,		SchemaEntry("ifcstructuralplanaraction",&STEP::ObjectHelper<IfcStructuralPlanarAction,0>::Construct )
+,		SchemaEntry("ifcstructuralpointaction",&STEP::ObjectHelper<IfcStructuralPointAction,0>::Construct )
+,		SchemaEntry("ifcstructuralpointconnection",&STEP::ObjectHelper<IfcStructuralPointConnection,1>::Construct )
+,		SchemaEntry("ifcstructuralpointreaction",&STEP::ObjectHelper<IfcStructuralPointReaction,0>::Construct )
+,		SchemaEntry("ifcstructuralresultgroup",&STEP::ObjectHelper<IfcStructuralResultGroup,3>::Construct )
+,		SchemaEntry("ifcstructuralsurfaceconnection",&STEP::ObjectHelper<IfcStructuralSurfaceConnection,0>::Construct )
+,		SchemaEntry("ifcstructuralsurfacemember",&STEP::ObjectHelper<IfcStructuralSurfaceMember,2>::Construct )
+,		SchemaEntry("ifcstructuralsurfacemembervarying",&STEP::ObjectHelper<IfcStructuralSurfaceMemberVarying,0>::Construct )
+,		SchemaEntry("ifcstructuralsurfacereaction",&STEP::ObjectHelper<IfcStructuralSurfaceReaction,1>::Construct )
+,		SchemaEntry("ifcstylemodel",&STEP::ObjectHelper<IfcStyleModel,0>::Construct )
+,		SchemaEntry("ifcstyleditem",&STEP::ObjectHelper<IfcStyledItem,3>::Construct )
+,		SchemaEntry("ifcstyledrepresentation",&STEP::ObjectHelper<IfcStyledRepresentation,0>::Construct )
+,		SchemaEntry("ifcsubcontractresource",&STEP::ObjectHelper<IfcSubContractResource,1>::Construct )
+,		SchemaEntry("ifcsubcontractresourcetype",&STEP::ObjectHelper<IfcSubContractResourceType,1>::Construct )
+,		SchemaEntry("ifcsubedge",&STEP::ObjectHelper<IfcSubedge,1>::Construct )
+,		SchemaEntry("ifcsurfacecurvesweptareasolid",&STEP::ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4>::Construct )
+,		SchemaEntry("ifcsurfacefeature",&STEP::ObjectHelper<IfcSurfaceFeature,1>::Construct )
+,		SchemaEntry("ifcsweptsurface",&STEP::ObjectHelper<IfcSweptSurface,2>::Construct )
+,		SchemaEntry("ifcsurfaceoflinearextrusion",&STEP::ObjectHelper<IfcSurfaceOfLinearExtrusion,2>::Construct )
+,		SchemaEntry("ifcsurfaceofrevolution",&STEP::ObjectHelper<IfcSurfaceOfRevolution,1>::Construct )
+,		SchemaEntry("ifcsurfacereinforcementarea",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacestyle",&STEP::ObjectHelper<IfcSurfaceStyle,2>::Construct )
+,		SchemaEntry("ifcsurfacestylelighting",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacestylerefraction",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacestyleshading",&STEP::ObjectHelper<IfcSurfaceStyleShading,2>::Construct )
+,		SchemaEntry("ifcsurfacestylerendering",&STEP::ObjectHelper<IfcSurfaceStyleRendering,7>::Construct )
+,		SchemaEntry("ifcsurfacestylewithtextures",&STEP::ObjectHelper<IfcSurfaceStyleWithTextures,1>::Construct )
+,		SchemaEntry("ifcsweptdisksolid",&STEP::ObjectHelper<IfcSweptDiskSolid,5>::Construct )
+,		SchemaEntry("ifcsweptdisksolidpolygonal",&STEP::ObjectHelper<IfcSweptDiskSolidPolygonal,1>::Construct )
+,		SchemaEntry("ifcswitchingdevice",&STEP::ObjectHelper<IfcSwitchingDevice,1>::Construct )
+,		SchemaEntry("ifcswitchingdevicetype",&STEP::ObjectHelper<IfcSwitchingDeviceType,1>::Construct )
+,		SchemaEntry("ifcsystemfurnitureelement",&STEP::ObjectHelper<IfcSystemFurnitureElement,1>::Construct )
+,		SchemaEntry("ifcsystemfurnitureelementtype",&STEP::ObjectHelper<IfcSystemFurnitureElementType,1>::Construct )
+,		SchemaEntry("ifctshapeprofiledef",&STEP::ObjectHelper<IfcTShapeProfileDef,9>::Construct )
+,		SchemaEntry("ifctable",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctablecolumn",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctablerow",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctank",&STEP::ObjectHelper<IfcTank,1>::Construct )
+,		SchemaEntry("ifctanktype",&STEP::ObjectHelper<IfcTankType,1>::Construct )
+,		SchemaEntry("ifctask",&STEP::ObjectHelper<IfcTask,6>::Construct )
+,		SchemaEntry("ifctasktime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctasktimerecurring",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctasktype",&STEP::ObjectHelper<IfcTaskType,2>::Construct )
+,		SchemaEntry("ifctelecomaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctendon",&STEP::ObjectHelper<IfcTendon,8>::Construct )
+,		SchemaEntry("ifctendonanchor",&STEP::ObjectHelper<IfcTendonAnchor,1>::Construct )
+,		SchemaEntry("ifctendonanchortype",&STEP::ObjectHelper<IfcTendonAnchorType,1>::Construct )
+,		SchemaEntry("ifctendontype",&STEP::ObjectHelper<IfcTendonType,4>::Construct )
+,		SchemaEntry("ifctextliteral",&STEP::ObjectHelper<IfcTextLiteral,3>::Construct )
+,		SchemaEntry("ifctextliteralwithextent",&STEP::ObjectHelper<IfcTextLiteralWithExtent,2>::Construct )
+,		SchemaEntry("ifctextstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctextstylefontmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctextstylefordefinedfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctextstyletextmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctexturecoordinategenerator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctexturevertex",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctexturevertexlist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctimeperiod",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctopologyrepresentation",&STEP::ObjectHelper<IfcTopologyRepresentation,0>::Construct )
+,		SchemaEntry("ifctoroidalsurface",&STEP::ObjectHelper<IfcToroidalSurface,2>::Construct )
+,		SchemaEntry("ifctransformer",&STEP::ObjectHelper<IfcTransformer,1>::Construct )
+,		SchemaEntry("ifctransformertype",&STEP::ObjectHelper<IfcTransformerType,1>::Construct )
+,		SchemaEntry("ifctransportelement",&STEP::ObjectHelper<IfcTransportElement,1>::Construct )
+,		SchemaEntry("ifctransportelementtype",&STEP::ObjectHelper<IfcTransportElementType,1>::Construct )
+,		SchemaEntry("ifctrapeziumprofiledef",&STEP::ObjectHelper<IfcTrapeziumProfileDef,4>::Construct )
+,		SchemaEntry("ifctriangulatedfaceset",&STEP::ObjectHelper<IfcTriangulatedFaceSet,2>::Construct )
+,		SchemaEntry("ifctrimmedcurve",&STEP::ObjectHelper<IfcTrimmedCurve,5>::Construct )
+,		SchemaEntry("ifctubebundle",&STEP::ObjectHelper<IfcTubeBundle,1>::Construct )
+,		SchemaEntry("ifctubebundletype",&STEP::ObjectHelper<IfcTubeBundleType,1>::Construct )
+,		SchemaEntry("ifcushapeprofiledef",&STEP::ObjectHelper<IfcUShapeProfileDef,7>::Construct )
+,		SchemaEntry("ifcunitassignment",&STEP::ObjectHelper<IfcUnitAssignment,1>::Construct )
+,		SchemaEntry("ifcunitarycontrolelement",&STEP::ObjectHelper<IfcUnitaryControlElement,1>::Construct )
+,		SchemaEntry("ifcunitarycontrolelementtype",&STEP::ObjectHelper<IfcUnitaryControlElementType,1>::Construct )
+,		SchemaEntry("ifcunitaryequipment",&STEP::ObjectHelper<IfcUnitaryEquipment,1>::Construct )
+,		SchemaEntry("ifcunitaryequipmenttype",&STEP::ObjectHelper<IfcUnitaryEquipmentType,1>::Construct )
+,		SchemaEntry("ifcvalve",&STEP::ObjectHelper<IfcValve,1>::Construct )
+,		SchemaEntry("ifcvalvetype",&STEP::ObjectHelper<IfcValveType,1>::Construct )
+,		SchemaEntry("ifcvector",&STEP::ObjectHelper<IfcVector,2>::Construct )
+,		SchemaEntry("ifcvertex",&STEP::ObjectHelper<IfcVertex,0>::Construct )
+,		SchemaEntry("ifcvertexloop",&STEP::ObjectHelper<IfcVertexLoop,1>::Construct )
+,		SchemaEntry("ifcvertexpoint",&STEP::ObjectHelper<IfcVertexPoint,1>::Construct )
+,		SchemaEntry("ifcvibrationisolator",&STEP::ObjectHelper<IfcVibrationIsolator,1>::Construct )
+,		SchemaEntry("ifcvibrationisolatortype",&STEP::ObjectHelper<IfcVibrationIsolatorType,1>::Construct )
+,		SchemaEntry("ifcvirtualelement",&STEP::ObjectHelper<IfcVirtualElement,0>::Construct )
+,		SchemaEntry("ifcvirtualgridintersection",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcvoidingfeature",&STEP::ObjectHelper<IfcVoidingFeature,1>::Construct )
+,		SchemaEntry("ifcwall",&STEP::ObjectHelper<IfcWall,1>::Construct )
+,		SchemaEntry("ifcwallelementedcase",&STEP::ObjectHelper<IfcWallElementedCase,0>::Construct )
+,		SchemaEntry("ifcwallstandardcase",&STEP::ObjectHelper<IfcWallStandardCase,0>::Construct )
+,		SchemaEntry("ifcwalltype",&STEP::ObjectHelper<IfcWallType,1>::Construct )
+,		SchemaEntry("ifcwasteterminal",&STEP::ObjectHelper<IfcWasteTerminal,1>::Construct )
+,		SchemaEntry("ifcwasteterminaltype",&STEP::ObjectHelper<IfcWasteTerminalType,1>::Construct )
+,		SchemaEntry("ifcwindow",&STEP::ObjectHelper<IfcWindow,5>::Construct )
+,		SchemaEntry("ifcwindowliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwindowpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwindowstandardcase",&STEP::ObjectHelper<IfcWindowStandardCase,0>::Construct )
+,		SchemaEntry("ifcwindowstyle",&STEP::ObjectHelper<IfcWindowStyle,4>::Construct )
+,		SchemaEntry("ifcwindowtype",&STEP::ObjectHelper<IfcWindowType,4>::Construct )
+,		SchemaEntry("ifcworkcalendar",&STEP::ObjectHelper<IfcWorkCalendar,3>::Construct )
+,		SchemaEntry("ifcworkcontrol",&STEP::ObjectHelper<IfcWorkControl,7>::Construct )
+,		SchemaEntry("ifcworkplan",&STEP::ObjectHelper<IfcWorkPlan,1>::Construct )
+,		SchemaEntry("ifcworkschedule",&STEP::ObjectHelper<IfcWorkSchedule,1>::Construct )
+,		SchemaEntry("ifcworktime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifczshapeprofiledef",&STEP::ObjectHelper<IfcZShapeProfileDef,6>::Construct )
+,		SchemaEntry("ifczone",&STEP::ObjectHelper<IfcZone,1>::Construct )
+
+	};
+}
+
+// -----------------------------------------------------------------------------------------------------------
+void IFC::GetSchema(EXPRESS::ConversionSchema& out)
+{
+	out = EXPRESS::ConversionSchema(schema_raw);
+}
+
+namespace STEP {
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<NotImplemented>(const STEP::DB& db, const LIST& params, NotImplemented* in)
+{
+	return 0;
+}
+
+
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoot* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); }    do { // convert the 'GlobalId' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->GlobalId, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
+    } while(0);
+    do { // convert the 'OwnerHistory' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->OwnerHistory, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
+    } while(0);
+    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'Description' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcObjectDefinition>(const DB& db, const LIST& params, IfcObjectDefinition* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcObjectDefinition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcObject* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcObject"); }    do { // convert the 'ObjectType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcObject,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ObjectType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcControl>(const DB& db, const LIST& params, IfcControl* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcActionRequest>(const DB& db, const LIST& params, IfcActionRequest* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcActor>(const DB& db, const LIST& params, IfcActor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, IfcProduct* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcProduct"); }    do { // convert the 'ObjectPlacement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ObjectPlacement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
+    } while(0);
+    do { // convert the 'Representation' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Representation, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, IfcElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcElement"); }    do { // convert the 'Tag' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElement,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Tag, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionElement>(const DB& db, const LIST& params, IfcDistributionElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionControlElement>(const DB& db, const LIST& params, IfcDistributionControlElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcActuator>(const DB& db, const LIST& params, IfcActuator* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTypeObject>(const DB& db, const LIST& params, IfcTypeObject* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTypeProduct>(const DB& db, const LIST& params, IfcTypeProduct* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementType>(const DB& db, const LIST& params, IfcElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionElementType>(const DB& db, const LIST& params, IfcDistributionElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionControlElementType>(const DB& db, const LIST& params, IfcDistributionControlElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcActuatorType>(const DB& db, const LIST& params, IfcActuatorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRepresentationItem>(const DB& db, const LIST& params, IfcRepresentationItem* in)
+{
+	size_t base = 0;
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeometricRepresentationItem>(const DB& db, const LIST& params, IfcGeometricRepresentationItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSolidModel>(const DB& db, const LIST& params, IfcSolidModel* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& params, IfcManifoldSolidBrep* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); }    do { // convert the 'Outer' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Outer, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAdvancedBrep>(const DB& db, const LIST& params, IfcAdvancedBrep* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAdvancedBrepWithVoids>(const DB& db, const LIST& params, IfcAdvancedBrepWithVoids* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAdvancedBrep*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTopologicalRepresentationItem>(const DB& db, const LIST& params, IfcTopologicalRepresentationItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFace* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); }    do { // convert the 'Bounds' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFace,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Bounds, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFaceSurface>(const DB& db, const LIST& params, IfcFaceSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFace*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAdvancedFace>(const DB& db, const LIST& params, IfcAdvancedFace* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFaceSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionFlowElement>(const DB& db, const LIST& params, IfcDistributionFlowElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowTerminal>(const DB& db, const LIST& params, IfcFlowTerminal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAirTerminal>(const DB& db, const LIST& params, IfcAirTerminal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowController>(const DB& db, const LIST& params, IfcFlowController* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAirTerminalBox>(const DB& db, const LIST& params, IfcAirTerminalBox* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionFlowElementType>(const DB& db, const LIST& params, IfcDistributionFlowElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowControllerType>(const DB& db, const LIST& params, IfcFlowControllerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAirTerminalBoxType>(const DB& db, const LIST& params, IfcAirTerminalBoxType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowTerminalType>(const DB& db, const LIST& params, IfcFlowTerminalType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAirTerminalType>(const DB& db, const LIST& params, IfcAirTerminalType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEnergyConversionDevice>(const DB& db, const LIST& params, IfcEnergyConversionDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAirToAirHeatRecovery>(const DB& db, const LIST& params, IfcAirToAirHeatRecovery* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEnergyConversionDeviceType>(const DB& db, const LIST& params, IfcEnergyConversionDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAirToAirHeatRecoveryType>(const DB& db, const LIST& params, IfcAirToAirHeatRecoveryType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAlarm>(const DB& db, const LIST& params, IfcAlarm* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAlarmType>(const DB& db, const LIST& params, IfcAlarmType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAnnotation>(const DB& db, const LIST& params, IfcAnnotation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcAnnotation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAnnotationFillArea>(const DB& db, const LIST& params, IfcAnnotationFillArea* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params, IfcProfileDef* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); }    do { // convert the 'ProfileType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->ProfileType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
+    } while(0);
+    do { // convert the 'ProfileName' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ProfileName, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const LIST& params, IfcArbitraryClosedProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); }    do { // convert the 'OuterCurve' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->OuterCurve, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const LIST& params, IfcArbitraryOpenProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); }    do { // convert the 'Curve' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Curve, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcArbitraryProfileDefWithVoids>(const DB& db, const LIST& params, IfcArbitraryProfileDefWithVoids* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcArbitraryClosedProfileDef*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcArbitraryProfileDefWithVoids"); }    do { // convert the 'InnerCurves' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->InnerCurves, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcArbitraryProfileDefWithVoids to be a `SET [1:?] OF IfcCurve`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGroup>(const DB& db, const LIST& params, IfcGroup* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAsset>(const DB& db, const LIST& params, IfcAsset* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const LIST& params, IfcParameterizedProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); }    do { // convert the 'Position' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Position, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAsymmetricIShapeProfileDef>(const DB& db, const LIST& params, IfcAsymmetricIShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAudioVisualAppliance>(const DB& db, const LIST& params, IfcAudioVisualAppliance* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAudioVisualApplianceType>(const DB& db, const LIST& params, IfcAudioVisualApplianceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, IfcPlacement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); }    do { // convert the 'Location' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPlacement,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Location, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& params, IfcAxis1Placement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); }    do { // convert the 'Axis' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Axis, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& params, IfcAxis2Placement2D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); }    do { // convert the 'RefDirection' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RefDirection, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAxis2Placement3D>(const DB& db, const LIST& params, IfcAxis2Placement3D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); }    do { // convert the 'Axis' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Axis, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); }
+    } while(0);
+    do { // convert the 'RefDirection' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RefDirection, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCurve>(const DB& db, const LIST& params, IfcCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoundedCurve>(const DB& db, const LIST& params, IfcBoundedCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params, IfcBSplineCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); }    do { // convert the 'Degree' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Degree, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `IfcInteger`")); }
+    } while(0);
+    do { // convert the 'ControlPointsList' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->ControlPointsList, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
+    } while(0);
+    do { // convert the 'CurveForm' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->CurveForm, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
+    } while(0);
+    do { // convert the 'ClosedCurve' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->ClosedCurve, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `IfcLogical`")); }
+    } while(0);
+    do { // convert the 'SelfIntersect' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
+        try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `IfcLogical`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBSplineCurveWithKnots>(const DB& db, const LIST& params, IfcBSplineCurveWithKnots* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBSplineCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurface>(const DB& db, const LIST& params, IfcSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoundedSurface>(const DB& db, const LIST& params, IfcBoundedSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBSplineSurface>(const DB& db, const LIST& params, IfcBSplineSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBSplineSurfaceWithKnots>(const DB& db, const LIST& params, IfcBSplineSurfaceWithKnots* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBSplineSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingElement>(const DB& db, const LIST& params, IfcBuildingElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcBuildingElement"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBeam>(const DB& db, const LIST& params, IfcBeam* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBeamStandardCase>(const DB& db, const LIST& params, IfcBeamStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBeam*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingElementType>(const DB& db, const LIST& params, IfcBuildingElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBeamType>(const DB& db, const LIST& params, IfcBeamType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPresentationItem>(const DB& db, const LIST& params, IfcPresentationItem* in)
+{
+	size_t base = 0;
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCsgPrimitive3D>(const DB& db, const LIST& params, IfcCsgPrimitive3D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBlock>(const DB& db, const LIST& params, IfcBlock* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoiler>(const DB& db, const LIST& params, IfcBoiler* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoilerType>(const DB& db, const LIST& params, IfcBoilerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& params, IfcBooleanResult* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); }    do { // convert the 'Operator' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Operator, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
+    } while(0);
+    do { // convert the 'FirstOperand' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->FirstOperand, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
+    } while(0);
+    do { // convert the 'SecondOperand' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->SecondOperand, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBooleanClippingResult>(const DB& db, const LIST& params, IfcBooleanClippingResult* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBooleanResult*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanClippingResult"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& params, IfcCompositeCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); }    do { // convert the 'Segments' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Segments, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
+    } while(0);
+    do { // convert the 'SelfIntersect' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->SelfIntersect, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `IfcLogical`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCompositeCurveOnSurface>(const DB& db, const LIST& params, IfcCompositeCurveOnSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoundaryCurve>(const DB& db, const LIST& params, IfcBoundaryCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurveOnSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params, IfcBoundingBox* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); }    do { // convert the 'Corner' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Corner, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
+    } while(0);
+    do { // convert the 'XDim' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->XDim, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'YDim' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->YDim, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'ZDim' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->ZDim, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& params, IfcHalfSpaceSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); }    do { // convert the 'BaseSurface' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->BaseSurface, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
+    } while(0);
+    do { // convert the 'AgreementFlag' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->AgreementFlag, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `IfcBoolean`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBoxedHalfSpace>(const DB& db, const LIST& params, IfcBoxedHalfSpace* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpatialElement>(const DB& db, const LIST& params, IfcSpatialElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcSpatialElement"); }    do { // convert the 'LongName' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialElement,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->LongName, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialElement to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const LIST& params, IfcSpatialStructureElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialElement*>(in));
+	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSpatialStructureElement"); }    do { // convert the 'CompositionType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialStructureElement,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->CompositionType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuilding>(const DB& db, const LIST& params, IfcBuilding* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
+	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); }    do { // convert the 'ElevationOfRefHeight' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'ElevationOfTerrain' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'BuildingAddress' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->BuildingAddress, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementComponent>(const DB& db, const LIST& params, IfcElementComponent* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingElementPart>(const DB& db, const LIST& params, IfcBuildingElementPart* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementComponentType>(const DB& db, const LIST& params, IfcElementComponentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingElementPartType>(const DB& db, const LIST& params, IfcBuildingElementPartType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingElementProxy>(const DB& db, const LIST& params, IfcBuildingElementProxy* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingElementProxyType>(const DB& db, const LIST& params, IfcBuildingElementProxyType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingStorey>(const DB& db, const LIST& params, IfcBuildingStorey* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSystem>(const DB& db, const LIST& params, IfcSystem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBuildingSystem>(const DB& db, const LIST& params, IfcBuildingSystem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBurner>(const DB& db, const LIST& params, IfcBurner* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBurnerType>(const DB& db, const LIST& params, IfcBurnerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCShapeProfileDef>(const DB& db, const LIST& params, IfcCShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowFitting>(const DB& db, const LIST& params, IfcFlowFitting* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableCarrierFitting>(const DB& db, const LIST& params, IfcCableCarrierFitting* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowFittingType>(const DB& db, const LIST& params, IfcFlowFittingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableCarrierFittingType>(const DB& db, const LIST& params, IfcCableCarrierFittingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowSegment>(const DB& db, const LIST& params, IfcFlowSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableCarrierSegment>(const DB& db, const LIST& params, IfcCableCarrierSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowSegmentType>(const DB& db, const LIST& params, IfcFlowSegmentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableCarrierSegmentType>(const DB& db, const LIST& params, IfcCableCarrierSegmentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableFitting>(const DB& db, const LIST& params, IfcCableFitting* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableFittingType>(const DB& db, const LIST& params, IfcCableFittingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableSegment>(const DB& db, const LIST& params, IfcCableSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCableSegmentType>(const DB& db, const LIST& params, IfcCableSegmentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPoint>(const DB& db, const LIST& params, IfcPoint* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& params, IfcCartesianPoint* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); }    do { // convert the 'Coordinates' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Coordinates, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianPointList>(const DB& db, const LIST& params, IfcCartesianPointList* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianPointList2D>(const DB& db, const LIST& params, IfcCartesianPointList2D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCartesianPointList*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianPointList3D>(const DB& db, const LIST& params, IfcCartesianPointList3D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCartesianPointList*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db, const LIST& params, IfcCartesianTransformationOperator* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCartesianTransformationOperator"); }    do { // convert the 'Axis1' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Axis1, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
+    } while(0);
+    do { // convert the 'Axis2' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Axis2, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
+    } while(0);
+    do { // convert the 'LocalOrigin' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->LocalOrigin, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
+    } while(0);
+    do { // convert the 'Scale' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Scale, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `IfcReal`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianTransformationOperator2D>(const DB& db, const LIST& params, IfcCartesianTransformationOperator2D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianTransformationOperator2DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator2DnonUniform* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator2D*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCartesianTransformationOperator3D"); }    do { // convert the 'Axis3' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Axis3, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3DnonUniform* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator3D*>(in));
+	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); }    do { // convert the 'Scale2' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Scale2, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `IfcReal`")); }
+    } while(0);
+    do { // convert the 'Scale3' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Scale3, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `IfcReal`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCenterLineProfileDef>(const DB& db, const LIST& params, IfcCenterLineProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcArbitraryOpenProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcChiller>(const DB& db, const LIST& params, IfcChiller* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcChillerType>(const DB& db, const LIST& params, IfcChillerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcChimney>(const DB& db, const LIST& params, IfcChimney* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcChimneyType>(const DB& db, const LIST& params, IfcChimneyType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcConic* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); }    do { // convert the 'Position' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConic,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Position, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcCircle* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); }    do { // convert the 'Radius' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Radius, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& params, IfcCircleProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); }    do { // convert the 'Radius' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Radius, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCircleHollowProfileDef>(const DB& db, const LIST& params, IfcCircleHollowProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); }    do { // convert the 'WallThickness' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->WallThickness, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCivilElement>(const DB& db, const LIST& params, IfcCivilElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCivilElementType>(const DB& db, const LIST& params, IfcCivilElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& params, IfcConnectedFaceSet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); }    do { // convert the 'CfsFaces' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->CfsFaces, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcClosedShell>(const DB& db, const LIST& params, IfcClosedShell* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcClosedShell"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCoil>(const DB& db, const LIST& params, IfcCoil* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCoilType>(const DB& db, const LIST& params, IfcCoilType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST& params, IfcColourSpecification* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcColourSpecification"); }    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, IfcColourRgb* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); }    do { // convert the 'Red' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Red, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
+    } while(0);
+    do { // convert the 'Green' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Green, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
+    } while(0);
+    do { // convert the 'Blue' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Blue, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcColumn>(const DB& db, const LIST& params, IfcColumn* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcColumnStandardCase>(const DB& db, const LIST& params, IfcColumnStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcColumn*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcColumnType>(const DB& db, const LIST& params, IfcColumnType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCommunicationsAppliance>(const DB& db, const LIST& params, IfcCommunicationsAppliance* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCommunicationsApplianceType>(const DB& db, const LIST& params, IfcCommunicationsApplianceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyAbstraction>(const DB& db, const LIST& params, IfcPropertyAbstraction* in)
+{
+	size_t base = 0;
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, IfcProperty* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPropertyAbstraction*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); }    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
+    } while(0);
+    do { // convert the 'Description' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& params, IfcComplexProperty* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); }    do { // convert the 'UsageName' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->UsageName, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
+    } while(0);
+    do { // convert the 'HasProperties' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->HasProperties, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyDefinition>(const DB& db, const LIST& params, IfcPropertyDefinition* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyDefinition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCompositeCurveSegment>(const DB& db, const LIST& params, IfcCompositeCurveSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); }    do { // convert the 'Transition' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Transition, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); }
+    } while(0);
+    do { // convert the 'SameSense' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->SameSense, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `IfcBoolean`")); }
+    } while(0);
+    do { // convert the 'ParentCurve' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->ParentCurve, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCompositeProfileDef>(const DB& db, const LIST& params, IfcCompositeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowMovingDevice>(const DB& db, const LIST& params, IfcFlowMovingDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCompressor>(const DB& db, const LIST& params, IfcCompressor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowMovingDeviceType>(const DB& db, const LIST& params, IfcFlowMovingDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCompressorType>(const DB& db, const LIST& params, IfcCompressorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCondenser>(const DB& db, const LIST& params, IfcCondenser* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCondenserType>(const DB& db, const LIST& params, IfcCondenserType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcResource>(const DB& db, const LIST& params, IfcResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionResource>(const DB& db, const LIST& params, IfcConstructionResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionEquipmentResource>(const DB& db, const LIST& params, IfcConstructionEquipmentResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTypeResource>(const DB& db, const LIST& params, IfcTypeResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionResourceType>(const DB& db, const LIST& params, IfcConstructionResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionEquipmentResourceType>(const DB& db, const LIST& params, IfcConstructionEquipmentResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionMaterialResource>(const DB& db, const LIST& params, IfcConstructionMaterialResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionMaterialResourceType>(const DB& db, const LIST& params, IfcConstructionMaterialResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionProductResource>(const DB& db, const LIST& params, IfcConstructionProductResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConstructionProductResourceType>(const DB& db, const LIST& params, IfcConstructionProductResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcContext>(const DB& db, const LIST& params, IfcContext* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
+	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcContext"); }    do { // convert the 'ObjectType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ObjectType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcContext to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'LongName' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->LongName, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcContext to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'Phase' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Phase, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcContext to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'RepresentationContexts' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RepresentationContexts, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcContext to be a `SET [1:?] OF IfcRepresentationContext`")); }
+    } while(0);
+    do { // convert the 'UnitsInContext' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[4]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->UnitsInContext, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcContext to be a `IfcUnitAssignment`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, IfcNamedUnit* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcNamedUnit"); }    do { // convert the 'Dimensions' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Dimensions, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
+    } while(0);
+    do { // convert the 'UnitType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->UnitType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcContextDependentUnit>(const DB& db, const LIST& params, IfcContextDependentUnit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcController>(const DB& db, const LIST& params, IfcController* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcControllerType>(const DB& db, const LIST& params, IfcControllerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST& params, IfcConversionBasedUnit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); }    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConversionBasedUnit,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'ConversionFactor' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConversionBasedUnit,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->ConversionFactor, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcConversionBasedUnitWithOffset>(const DB& db, const LIST& params, IfcConversionBasedUnitWithOffset* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConversionBasedUnit*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCooledBeam>(const DB& db, const LIST& params, IfcCooledBeam* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCooledBeamType>(const DB& db, const LIST& params, IfcCooledBeamType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCoolingTower>(const DB& db, const LIST& params, IfcCoolingTower* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCoolingTowerType>(const DB& db, const LIST& params, IfcCoolingTowerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCostItem>(const DB& db, const LIST& params, IfcCostItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCostSchedule>(const DB& db, const LIST& params, IfcCostSchedule* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCovering>(const DB& db, const LIST& params, IfcCovering* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCoveringType>(const DB& db, const LIST& params, IfcCoveringType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCrewResource>(const DB& db, const LIST& params, IfcCrewResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCrewResourceType>(const DB& db, const LIST& params, IfcCrewResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCsgSolid>(const DB& db, const LIST& params, IfcCsgSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCurtainWall>(const DB& db, const LIST& params, IfcCurtainWall* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCurtainWallType>(const DB& db, const LIST& params, IfcCurtainWallType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCurveBoundedPlane>(const DB& db, const LIST& params, IfcCurveBoundedPlane* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCurveBoundedSurface>(const DB& db, const LIST& params, IfcCurveBoundedSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& params, IfcPresentationStyle* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyle"); }    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& params, IfcElementarySurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); }    do { // convert the 'Position' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Position, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcCylindricalSurface>(const DB& db, const LIST& params, IfcCylindricalSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDamper>(const DB& db, const LIST& params, IfcDamper* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDamperType>(const DB& db, const LIST& params, IfcDamperType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDerivedProfileDef>(const DB& db, const LIST& params, IfcDerivedProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDirection>(const DB& db, const LIST& params, IfcDirection* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); }    do { // convert the 'DirectionRatios' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->DirectionRatios, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF IfcReal`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDiscreteAccessory>(const DB& db, const LIST& params, IfcDiscreteAccessory* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDiscreteAccessoryType>(const DB& db, const LIST& params, IfcDiscreteAccessoryType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionChamberElement>(const DB& db, const LIST& params, IfcDistributionChamberElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionChamberElementType>(const DB& db, const LIST& params, IfcDistributionChamberElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionSystem>(const DB& db, const LIST& params, IfcDistributionSystem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionCircuit>(const DB& db, const LIST& params, IfcDistributionCircuit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionSystem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPort>(const DB& db, const LIST& params, IfcPort* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDistributionPort>(const DB& db, const LIST& params, IfcDistributionPort* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPort*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDoor>(const DB& db, const LIST& params, IfcDoor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+	if (params.GetSize() < 13) { throw STEP::TypeError("expected 13 arguments to IfcDoor"); }    do { // convert the 'OverallHeight' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->OverallHeight, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'OverallWidth' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->OverallWidth, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'PredefinedType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->PredefinedType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcDoor to be a `IfcDoorTypeEnum`")); }
+    } while(0);
+    do { // convert the 'OperationType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->OperationType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcDoor to be a `IfcDoorTypeOperationEnum`")); }
+    } while(0);
+    do { // convert the 'UserDefinedOperationType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[4]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->UserDefinedOperationType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcDoor to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertySetDefinition>(const DB& db, const LIST& params, IfcPropertySetDefinition* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPropertyDefinition*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySetDefinition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDoorStandardCase>(const DB& db, const LIST& params, IfcDoorStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDoor*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDoorStyle>(const DB& db, const LIST& params, IfcDoorStyle* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDoorType>(const DB& db, const LIST& params, IfcDoorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDuctFitting>(const DB& db, const LIST& params, IfcDuctFitting* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDuctFittingType>(const DB& db, const LIST& params, IfcDuctFittingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDuctSegment>(const DB& db, const LIST& params, IfcDuctSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDuctSegmentType>(const DB& db, const LIST& params, IfcDuctSegmentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowTreatmentDevice>(const DB& db, const LIST& params, IfcFlowTreatmentDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDuctSilencer>(const DB& db, const LIST& params, IfcDuctSilencer* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowTreatmentDeviceType>(const DB& db, const LIST& params, IfcFlowTreatmentDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDuctSilencerType>(const DB& db, const LIST& params, IfcDuctSilencerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEdge>(const DB& db, const LIST& params, IfcEdge* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEdgeCurve>(const DB& db, const LIST& params, IfcEdgeCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLoop>(const DB& db, const LIST& params, IfcLoop* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEdgeLoop>(const DB& db, const LIST& params, IfcEdgeLoop* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricAppliance>(const DB& db, const LIST& params, IfcElectricAppliance* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricApplianceType>(const DB& db, const LIST& params, IfcElectricApplianceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricDistributionBoard>(const DB& db, const LIST& params, IfcElectricDistributionBoard* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricDistributionBoardType>(const DB& db, const LIST& params, IfcElectricDistributionBoardType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowStorageDevice>(const DB& db, const LIST& params, IfcFlowStorageDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricFlowStorageDevice>(const DB& db, const LIST& params, IfcElectricFlowStorageDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowStorageDeviceType>(const DB& db, const LIST& params, IfcFlowStorageDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricFlowStorageDeviceType>(const DB& db, const LIST& params, IfcElectricFlowStorageDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricGenerator>(const DB& db, const LIST& params, IfcElectricGenerator* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricGeneratorType>(const DB& db, const LIST& params, IfcElectricGeneratorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricMotor>(const DB& db, const LIST& params, IfcElectricMotor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricMotorType>(const DB& db, const LIST& params, IfcElectricMotorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricTimeControl>(const DB& db, const LIST& params, IfcElectricTimeControl* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricTimeControlType>(const DB& db, const LIST& params, IfcElectricTimeControlType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementAssembly>(const DB& db, const LIST& params, IfcElementAssembly* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementAssemblyType>(const DB& db, const LIST& params, IfcElementAssemblyType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcQuantitySet>(const DB& db, const LIST& params, IfcQuantitySet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcQuantitySet"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& params, IfcElementQuantity* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcQuantitySet*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); }    do { // convert the 'MethodOfMeasurement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'Quantities' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Quantities, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, IfcEllipse* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); }    do { // convert the 'SemiAxis1' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->SemiAxis1, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'SemiAxis2' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->SemiAxis2, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEllipseProfileDef>(const DB& db, const LIST& params, IfcEllipseProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEngine>(const DB& db, const LIST& params, IfcEngine* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEngineType>(const DB& db, const LIST& params, IfcEngineType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEvaporativeCooler>(const DB& db, const LIST& params, IfcEvaporativeCooler* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEvaporativeCoolerType>(const DB& db, const LIST& params, IfcEvaporativeCoolerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEvaporator>(const DB& db, const LIST& params, IfcEvaporator* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEvaporatorType>(const DB& db, const LIST& params, IfcEvaporatorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProcess>(const DB& db, const LIST& params, IfcProcess* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEvent>(const DB& db, const LIST& params, IfcEvent* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTypeProcess>(const DB& db, const LIST& params, IfcTypeProcess* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEventType>(const DB& db, const LIST& params, IfcEventType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProcess*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcExternalSpatialStructureElement>(const DB& db, const LIST& params, IfcExternalSpatialStructureElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcExternalSpatialElement>(const DB& db, const LIST& params, IfcExternalSpatialElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcExternalSpatialStructureElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& params, IfcSweptAreaSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); }    do { // convert the 'SweptArea' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->SweptArea, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
+    } while(0);
+    do { // convert the 'Position' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Position, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& params, IfcExtrudedAreaSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); }    do { // convert the 'ExtrudedDirection' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcExtrudedAreaSolid,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
+    } while(0);
+    do { // convert the 'Depth' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcExtrudedAreaSolid,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->Depth, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcExtrudedAreaSolidTapered>(const DB& db, const LIST& params, IfcExtrudedAreaSolidTapered* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcExtrudedAreaSolid*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIST& params, IfcFaceBasedSurfaceModel* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); }    do { // convert the 'FbsmFaces' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->FbsmFaces, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, IfcFaceBound* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); }    do { // convert the 'Bound' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Bound, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
+    } while(0);
+    do { // convert the 'Orientation' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->Orientation, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `IfcBoolean`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFaceOuterBound>(const DB& db, const LIST& params, IfcFaceOuterBound* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFaceBound*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceOuterBound"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFacetedBrep>(const DB& db, const LIST& params, IfcFacetedBrep* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFacetedBrepWithVoids>(const DB& db, const LIST& params, IfcFacetedBrepWithVoids* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFacetedBrep*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFan>(const DB& db, const LIST& params, IfcFan* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFanType>(const DB& db, const LIST& params, IfcFanType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFastener>(const DB& db, const LIST& params, IfcFastener* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFastenerType>(const DB& db, const LIST& params, IfcFastenerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFeatureElement>(const DB& db, const LIST& params, IfcFeatureElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcFeatureElement"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFeatureElementAddition>(const DB& db, const LIST& params, IfcFeatureElementAddition* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFeatureElementSubtraction>(const DB& db, const LIST& params, IfcFeatureElementSubtraction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
+	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcFeatureElementSubtraction"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFillAreaStyleHatching>(const DB& db, const LIST& params, IfcFillAreaStyleHatching* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFillAreaStyleTiles>(const DB& db, const LIST& params, IfcFillAreaStyleTiles* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFilter>(const DB& db, const LIST& params, IfcFilter* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFilterType>(const DB& db, const LIST& params, IfcFilterType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFireSuppressionTerminal>(const DB& db, const LIST& params, IfcFireSuppressionTerminal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFireSuppressionTerminalType>(const DB& db, const LIST& params, IfcFireSuppressionTerminalType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFixedReferenceSweptAreaSolid>(const DB& db, const LIST& params, IfcFixedReferenceSweptAreaSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowInstrument>(const DB& db, const LIST& params, IfcFlowInstrument* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowInstrumentType>(const DB& db, const LIST& params, IfcFlowInstrumentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowMeter>(const DB& db, const LIST& params, IfcFlowMeter* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFlowMeterType>(const DB& db, const LIST& params, IfcFlowMeterType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFooting>(const DB& db, const LIST& params, IfcFooting* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFootingType>(const DB& db, const LIST& params, IfcFootingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFurnishingElement>(const DB& db, const LIST& params, IfcFurnishingElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFurnishingElementType>(const DB& db, const LIST& params, IfcFurnishingElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFurniture>(const DB& db, const LIST& params, IfcFurniture* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcFurnitureType>(const DB& db, const LIST& params, IfcFurnitureType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeographicElement>(const DB& db, const LIST& params, IfcGeographicElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeographicElementType>(const DB& db, const LIST& params, IfcGeographicElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeometricSet>(const DB& db, const LIST& params, IfcGeometricSet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeometricCurveSet>(const DB& db, const LIST& params, IfcGeometricCurveSet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricSet*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIST& params, IfcRepresentationContext* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationContext"); }    do { // convert the 'ContextIdentifier' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ContextIdentifier, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'ContextType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ContextType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db, const LIST& params, IfcGeometricRepresentationContext* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentationContext*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); }    do { // convert the 'CoordinateSpaceDimension' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
+    } while(0);
+    do { // convert the 'Precision' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Precision, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `IfcReal`")); }
+    } while(0);
+    do { // convert the 'WorldCoordinateSystem' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
+    } while(0);
+    do { // convert the 'TrueNorth' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->TrueNorth, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGeometricRepresentationSubContext>(const DB& db, const LIST& params, IfcGeometricRepresentationSubContext* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationContext*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGrid>(const DB& db, const LIST& params, IfcGrid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcObjectPlacement>(const DB& db, const LIST& params, IfcObjectPlacement* in)
+{
+	size_t base = 0;
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcGridPlacement>(const DB& db, const LIST& params, IfcGridPlacement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObjectPlacement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcHeatExchanger>(const DB& db, const LIST& params, IfcHeatExchanger* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcHeatExchangerType>(const DB& db, const LIST& params, IfcHeatExchangerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcHumidifier>(const DB& db, const LIST& params, IfcHumidifier* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcHumidifierType>(const DB& db, const LIST& params, IfcHumidifierType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& params, IfcIShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+	if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcIShapeProfileDef"); }    do { // convert the 'OverallWidth' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->OverallWidth, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'OverallDepth' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->OverallDepth, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'WebThickness' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->WebThickness, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'FlangeThickness' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->FlangeThickness, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'FilletRadius' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->FilletRadius, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcNonNegativeLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'FlangeEdgeRadius' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->FlangeEdgeRadius, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcIShapeProfileDef to be a `IfcNonNegativeLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'FlangeSlope' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->FlangeSlope, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcIShapeProfileDef to be a `IfcPlaneAngleMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcIndexedPolyCurve>(const DB& db, const LIST& params, IfcIndexedPolyCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTessellatedItem>(const DB& db, const LIST& params, IfcTessellatedItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcIndexedPolygonalFace>(const DB& db, const LIST& params, IfcIndexedPolygonalFace* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTessellatedItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcIndexedPolygonalFaceWithVoids>(const DB& db, const LIST& params, IfcIndexedPolygonalFaceWithVoids* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcIndexedPolygonalFace*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcInterceptor>(const DB& db, const LIST& params, IfcInterceptor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcInterceptorType>(const DB& db, const LIST& params, IfcInterceptorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceCurve>(const DB& db, const LIST& params, IfcSurfaceCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcIntersectionCurve>(const DB& db, const LIST& params, IfcIntersectionCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSurfaceCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcInventory>(const DB& db, const LIST& params, IfcInventory* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcJunctionBox>(const DB& db, const LIST& params, IfcJunctionBox* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcJunctionBoxType>(const DB& db, const LIST& params, IfcJunctionBoxType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLShapeProfileDef>(const DB& db, const LIST& params, IfcLShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLaborResource>(const DB& db, const LIST& params, IfcLaborResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLaborResourceType>(const DB& db, const LIST& params, IfcLaborResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLamp>(const DB& db, const LIST& params, IfcLamp* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLampType>(const DB& db, const LIST& params, IfcLampType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightFixture>(const DB& db, const LIST& params, IfcLightFixture* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightFixtureType>(const DB& db, const LIST& params, IfcLightFixtureType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightSource>(const DB& db, const LIST& params, IfcLightSource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightSourceAmbient>(const DB& db, const LIST& params, IfcLightSourceAmbient* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightSourceDirectional>(const DB& db, const LIST& params, IfcLightSourceDirectional* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightSourceGoniometric>(const DB& db, const LIST& params, IfcLightSourceGoniometric* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightSourcePositional>(const DB& db, const LIST& params, IfcLightSourcePositional* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLightSourceSpot>(const DB& db, const LIST& params, IfcLightSourceSpot* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLightSourcePositional*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLine>(const DB& db, const LIST& params, IfcLine* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); }    do { // convert the 'Pnt' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Pnt, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); }
+    } while(0);
+    do { // convert the 'Dir' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Dir, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLocalPlacement>(const DB& db, const LIST& params, IfcLocalPlacement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObjectPlacement*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); }    do { // convert the 'PlacementRelTo' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->PlacementRelTo, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); }
+    } while(0);
+    do { // convert the 'RelativePlacement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelativePlacement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMappedItem>(const DB& db, const LIST& params, IfcMappedItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); }    do { // convert the 'MappingSource' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->MappingSource, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); }
+    } while(0);
+    do { // convert the 'MappingTarget' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->MappingTarget, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIST& params, IfcProductRepresentation* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcProductRepresentation"); }    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'Description' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
+    } while(0);
+    do { // convert the 'Representations' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->Representations, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMaterialDefinitionRepresentation>(const DB& db, const LIST& params, IfcMaterialDefinitionRepresentation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& params, IfcMeasureWithUnit* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); }    do { // convert the 'ValueComponent' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->ValueComponent, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
+    } while(0);
+    do { // convert the 'UnitComponent' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->UnitComponent, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMechanicalFastener>(const DB& db, const LIST& params, IfcMechanicalFastener* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMechanicalFastenerType>(const DB& db, const LIST& params, IfcMechanicalFastenerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMedicalDevice>(const DB& db, const LIST& params, IfcMedicalDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMedicalDeviceType>(const DB& db, const LIST& params, IfcMedicalDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMember>(const DB& db, const LIST& params, IfcMember* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMemberStandardCase>(const DB& db, const LIST& params, IfcMemberStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcMember*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMemberType>(const DB& db, const LIST& params, IfcMemberType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMirroredProfileDef>(const DB& db, const LIST& params, IfcMirroredProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDerivedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMotorConnection>(const DB& db, const LIST& params, IfcMotorConnection* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcMotorConnectionType>(const DB& db, const LIST& params, IfcMotorConnectionType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOccupant>(const DB& db, const LIST& params, IfcOccupant* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcActor*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOffsetCurve2D>(const DB& db, const LIST& params, IfcOffsetCurve2D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOffsetCurve3D>(const DB& db, const LIST& params, IfcOffsetCurve3D* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOpenShell>(const DB& db, const LIST& params, IfcOpenShell* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOpeningElement>(const DB& db, const LIST& params, IfcOpeningElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
+	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcOpeningElement"); }    do { // convert the 'PredefinedType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcOpeningElement,1>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->PredefinedType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcOpeningElement to be a `IfcOpeningElementTypeEnum`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOpeningStandardCase>(const DB& db, const LIST& params, IfcOpeningStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcOpeningElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOrientedEdge>(const DB& db, const LIST& params, IfcOrientedEdge* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOuterBoundaryCurve>(const DB& db, const LIST& params, IfcOuterBoundaryCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundaryCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOutlet>(const DB& db, const LIST& params, IfcOutlet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcOutletType>(const DB& db, const LIST& params, IfcOutletType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPath>(const DB& db, const LIST& params, IfcPath* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPcurve>(const DB& db, const LIST& params, IfcPcurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPerformanceHistory>(const DB& db, const LIST& params, IfcPerformanceHistory* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPermit>(const DB& db, const LIST& params, IfcPermit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPile>(const DB& db, const LIST& params, IfcPile* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPileType>(const DB& db, const LIST& params, IfcPileType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPipeFitting>(const DB& db, const LIST& params, IfcPipeFitting* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPipeFittingType>(const DB& db, const LIST& params, IfcPipeFittingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPipeSegment>(const DB& db, const LIST& params, IfcPipeSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPipeSegmentType>(const DB& db, const LIST& params, IfcPipeSegmentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlanarExtent>(const DB& db, const LIST& params, IfcPlanarExtent* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlanarBox>(const DB& db, const LIST& params, IfcPlanarBox* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPlanarExtent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlane>(const DB& db, const LIST& params, IfcPlane* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlane"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlate>(const DB& db, const LIST& params, IfcPlate* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlateStandardCase>(const DB& db, const LIST& params, IfcPlateStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPlate*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPlateType>(const DB& db, const LIST& params, IfcPlateType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPointOnCurve>(const DB& db, const LIST& params, IfcPointOnCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPointOnSurface>(const DB& db, const LIST& params, IfcPointOnSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, IfcPolyLoop* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); }    do { // convert the 'Polygon' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Polygon, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPolygonalBoundedHalfSpace>(const DB& db, const LIST& params, IfcPolygonalBoundedHalfSpace* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); }    do { // convert the 'Position' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Position, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); }
+    } while(0);
+    do { // convert the 'PolygonalBoundary' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTessellatedFaceSet>(const DB& db, const LIST& params, IfcTessellatedFaceSet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTessellatedItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPolygonalFaceSet>(const DB& db, const LIST& params, IfcPolygonalFaceSet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTessellatedFaceSet*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPolyline>(const DB& db, const LIST& params, IfcPolyline* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); }    do { // convert the 'Points' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Points, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, const LIST& params, IfcPresentationStyleAssignment* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); }    do { // convert the 'Styles' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Styles, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProcedure>(const DB& db, const LIST& params, IfcProcedure* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProcedureType>(const DB& db, const LIST& params, IfcProcedureType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProcess*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProductDefinitionShape>(const DB& db, const LIST& params, IfcProductDefinitionShape* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProject>(const DB& db, const LIST& params, IfcProject* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcContext*>(in));
+	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProjectLibrary>(const DB& db, const LIST& params, IfcProjectLibrary* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcContext*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProjectOrder>(const DB& db, const LIST& params, IfcProjectOrder* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProjectionElement>(const DB& db, const LIST& params, IfcProjectionElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementAddition*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSimpleProperty>(const DB& db, const LIST& params, IfcSimpleProperty* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSimpleProperty"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyBoundedValue>(const DB& db, const LIST& params, IfcPropertyBoundedValue* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyEnumeratedValue>(const DB& db, const LIST& params, IfcPropertyEnumeratedValue* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyListValue>(const DB& db, const LIST& params, IfcPropertyListValue* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); }    do { // convert the 'ListValues' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ListValues, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); }
+    } while(0);
+    do { // convert the 'Unit' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Unit, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyReferenceValue>(const DB& db, const LIST& params, IfcPropertyReferenceValue* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params, IfcPropertySet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); }    do { // convert the 'HasProperties' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->HasProperties, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertySingleValue>(const DB& db, const LIST& params, IfcPropertySingleValue* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); }    do { // convert the 'NominalValue' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->NominalValue, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); }
+    } while(0);
+    do { // convert the 'Unit' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Unit, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPropertyTableValue>(const DB& db, const LIST& params, IfcPropertyTableValue* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProtectiveDevice>(const DB& db, const LIST& params, IfcProtectiveDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProtectiveDeviceTrippingUnit>(const DB& db, const LIST& params, IfcProtectiveDeviceTrippingUnit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProtectiveDeviceTrippingUnitType>(const DB& db, const LIST& params, IfcProtectiveDeviceTrippingUnitType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProtectiveDeviceType>(const DB& db, const LIST& params, IfcProtectiveDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProxy>(const DB& db, const LIST& params, IfcProxy* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPump>(const DB& db, const LIST& params, IfcPump* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcPumpType>(const DB& db, const LIST& params, IfcPumpType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRailing>(const DB& db, const LIST& params, IfcRailing* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRailingType>(const DB& db, const LIST& params, IfcRailingType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRamp>(const DB& db, const LIST& params, IfcRamp* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRampFlight>(const DB& db, const LIST& params, IfcRampFlight* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRampFlightType>(const DB& db, const LIST& params, IfcRampFlightType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRampType>(const DB& db, const LIST& params, IfcRampType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRationalBSplineCurveWithKnots>(const DB& db, const LIST& params, IfcRationalBSplineCurveWithKnots* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBSplineCurveWithKnots*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRationalBSplineSurfaceWithKnots>(const DB& db, const LIST& params, IfcRationalBSplineSurfaceWithKnots* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBSplineSurfaceWithKnots*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST& params, IfcRectangleProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); }    do { // convert the 'XDim' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->XDim, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'YDim' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->YDim, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRectangleHollowProfileDef>(const DB& db, const LIST& params, IfcRectangleHollowProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRectangularPyramid>(const DB& db, const LIST& params, IfcRectangularPyramid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRectangularTrimmedSurface>(const DB& db, const LIST& params, IfcRectangularTrimmedSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReinforcingElement>(const DB& db, const LIST& params, IfcReinforcingElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReinforcingBar>(const DB& db, const LIST& params, IfcReinforcingBar* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReinforcingElementType>(const DB& db, const LIST& params, IfcReinforcingElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReinforcingBarType>(const DB& db, const LIST& params, IfcReinforcingBarType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReinforcingMesh>(const DB& db, const LIST& params, IfcReinforcingMesh* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReinforcingMeshType>(const DB& db, const LIST& params, IfcReinforcingMeshType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelationship>(const DB& db, const LIST& params, IfcRelationship* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelDecomposes>(const DB& db, const LIST& params, IfcRelDecomposes* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelDecomposes"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelAggregates>(const DB& db, const LIST& params, IfcRelAggregates* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelAggregates"); }    do { // convert the 'RelatingObject' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatingObject, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelAggregates to be a `IfcObjectDefinition`")); }
+    } while(0);
+    do { // convert the 'RelatedObjects' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelAggregates to be a `SET [1:?] OF IfcObjectDefinition`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelConnects>(const DB& db, const LIST& params, IfcRelConnects* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelConnects"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db, const LIST& params, IfcRelContainedInSpatialStructure* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); }    do { // convert the 'RelatedElements' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatedElements, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); }
+    } while(0);
+    do { // convert the 'RelatingStructure' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatingStructure, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialElement`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params, IfcRelDefines* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelDefines"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LIST& params, IfcRelDefinesByProperties* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelDefines*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); }    do { // convert the 'RelatedObjects' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatedObjects, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefinesByProperties to be a `SET [1:?] OF IfcObjectDefinition`")); }
+    } while(0);
+    do { // convert the 'RelatingPropertyDefinition' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinitionSelect`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelFillsElement>(const DB& db, const LIST& params, IfcRelFillsElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); }    do { // convert the 'RelatingOpeningElement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); }
+    } while(0);
+    do { // convert the 'RelatedBuildingElement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& params, IfcRelVoidsElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); }    do { // convert the 'RelatingBuildingElement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
+    } while(0);
+    do { // convert the 'RelatedOpeningElement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcReparametrisedCompositeCurveSegment>(const DB& db, const LIST& params, IfcReparametrisedCompositeCurveSegment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurveSegment*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& params, IfcRepresentation* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); }    do { // convert the 'ContextOfItems' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->ContextOfItems, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
+    } while(0);
+    do { // convert the 'RepresentationIdentifier' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'RepresentationType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RepresentationType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'Items' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->Items, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& params, IfcRepresentationMap* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); }    do { // convert the 'MappingOrigin' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->MappingOrigin, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
+    } while(0);
+    do { // convert the 'MappedRepresentation' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->MappedRepresentation, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRevolvedAreaSolid>(const DB& db, const LIST& params, IfcRevolvedAreaSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); }    do { // convert the 'Axis' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRevolvedAreaSolid,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Axis, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); }
+    } while(0);
+    do { // convert the 'Angle' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRevolvedAreaSolid,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->Angle, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRevolvedAreaSolidTapered>(const DB& db, const LIST& params, IfcRevolvedAreaSolidTapered* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRevolvedAreaSolid*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRightCircularCone>(const DB& db, const LIST& params, IfcRightCircularCone* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRightCircularCylinder>(const DB& db, const LIST& params, IfcRightCircularCylinder* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRoof>(const DB& db, const LIST& params, IfcRoof* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRoofType>(const DB& db, const LIST& params, IfcRoofType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRoundedRectangleProfileDef>(const DB& db, const LIST& params, IfcRoundedRectangleProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcSIUnit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); }    do { // convert the 'Prefix' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Prefix, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
+    } while(0);
+    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSanitaryTerminal>(const DB& db, const LIST& params, IfcSanitaryTerminal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSanitaryTerminalType>(const DB& db, const LIST& params, IfcSanitaryTerminalType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSeamCurve>(const DB& db, const LIST& params, IfcSeamCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSurfaceCurve*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSectionedSpine>(const DB& db, const LIST& params, IfcSectionedSpine* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSensor>(const DB& db, const LIST& params, IfcSensor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSensorType>(const DB& db, const LIST& params, IfcSensorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcShadingDevice>(const DB& db, const LIST& params, IfcShadingDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcShadingDeviceType>(const DB& db, const LIST& params, IfcShadingDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcShapeModel>(const DB& db, const LIST& params, IfcShapeModel* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentation*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcShapeRepresentation>(const DB& db, const LIST& params, IfcShapeRepresentation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LIST& params, IfcShellBasedSurfaceModel* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); }    do { // convert the 'SbsmBoundary' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->SbsmBoundary, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSite* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
+	if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); }    do { // convert the 'RefLatitude' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RefLatitude, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
+    } while(0);
+    do { // convert the 'RefLongitude' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RefLongitude, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
+    } while(0);
+    do { // convert the 'RefElevation' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->RefElevation, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'LandTitleNumber' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->LandTitleNumber, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'SiteAddress' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->SiteAddress, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSlab>(const DB& db, const LIST& params, IfcSlab* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSlabElementedCase>(const DB& db, const LIST& params, IfcSlabElementedCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSlab*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSlabStandardCase>(const DB& db, const LIST& params, IfcSlabStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSlab*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSlabType>(const DB& db, const LIST& params, IfcSlabType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSolarDevice>(const DB& db, const LIST& params, IfcSolarDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSolarDeviceType>(const DB& db, const LIST& params, IfcSolarDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSpace* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
+	if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); }    do { // convert the 'PredefinedType' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->PredefinedType, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcSpaceTypeEnum`")); }
+    } while(0);
+    do { // convert the 'ElevationWithFlooring' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpaceHeater>(const DB& db, const LIST& params, IfcSpaceHeater* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpaceHeaterType>(const DB& db, const LIST& params, IfcSpaceHeaterType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpatialElementType>(const DB& db, const LIST& params, IfcSpatialElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpatialStructureElementType>(const DB& db, const LIST& params, IfcSpatialStructureElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpaceType>(const DB& db, const LIST& params, IfcSpaceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpatialZone>(const DB& db, const LIST& params, IfcSpatialZone* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSpatialZoneType>(const DB& db, const LIST& params, IfcSpatialZoneType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSpatialElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSphere>(const DB& db, const LIST& params, IfcSphere* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSphericalSurface>(const DB& db, const LIST& params, IfcSphericalSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStackTerminal>(const DB& db, const LIST& params, IfcStackTerminal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStackTerminalType>(const DB& db, const LIST& params, IfcStackTerminalType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStair>(const DB& db, const LIST& params, IfcStair* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStairFlight>(const DB& db, const LIST& params, IfcStairFlight* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStairFlightType>(const DB& db, const LIST& params, IfcStairFlightType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStairType>(const DB& db, const LIST& params, IfcStairType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralActivity>(const DB& db, const LIST& params, IfcStructuralActivity* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralAction>(const DB& db, const LIST& params, IfcStructuralAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralAnalysisModel>(const DB& db, const LIST& params, IfcStructuralAnalysisModel* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralItem>(const DB& db, const LIST& params, IfcStructuralItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralConnection>(const DB& db, const LIST& params, IfcStructuralConnection* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralCurveAction>(const DB& db, const LIST& params, IfcStructuralCurveAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralCurveConnection>(const DB& db, const LIST& params, IfcStructuralCurveConnection* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralMember>(const DB& db, const LIST& params, IfcStructuralMember* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralCurveMember>(const DB& db, const LIST& params, IfcStructuralCurveMember* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralCurveMemberVarying>(const DB& db, const LIST& params, IfcStructuralCurveMemberVarying* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralCurveMember*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralReaction>(const DB& db, const LIST& params, IfcStructuralReaction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralCurveReaction>(const DB& db, const LIST& params, IfcStructuralCurveReaction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralLinearAction>(const DB& db, const LIST& params, IfcStructuralLinearAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralCurveAction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralLoadGroup>(const DB& db, const LIST& params, IfcStructuralLoadGroup* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralLoadCase>(const DB& db, const LIST& params, IfcStructuralLoadCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralLoadGroup*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralSurfaceAction>(const DB& db, const LIST& params, IfcStructuralSurfaceAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralPlanarAction>(const DB& db, const LIST& params, IfcStructuralPlanarAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralSurfaceAction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralPointAction>(const DB& db, const LIST& params, IfcStructuralPointAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralPointConnection>(const DB& db, const LIST& params, IfcStructuralPointConnection* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralPointReaction>(const DB& db, const LIST& params, IfcStructuralPointReaction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralResultGroup>(const DB& db, const LIST& params, IfcStructuralResultGroup* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralSurfaceConnection>(const DB& db, const LIST& params, IfcStructuralSurfaceConnection* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralSurfaceMember>(const DB& db, const LIST& params, IfcStructuralSurfaceMember* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralSurfaceMemberVarying>(const DB& db, const LIST& params, IfcStructuralSurfaceMemberVarying* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralSurfaceMember*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStructuralSurfaceReaction>(const DB& db, const LIST& params, IfcStructuralSurfaceReaction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStyleModel>(const DB& db, const LIST& params, IfcStyleModel* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentation*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params, IfcStyledItem* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcStyledItem"); }    do { // convert the 'Item' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Item, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
+    } while(0);
+    do { // convert the 'Styles' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Styles, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcStyleAssignmentSelect`")); }
+    } while(0);
+    do { // convert the 'Name' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcStyledRepresentation>(const DB& db, const LIST& params, IfcStyledRepresentation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStyleModel*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSubContractResource>(const DB& db, const LIST& params, IfcSubContractResource* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSubContractResourceType>(const DB& db, const LIST& params, IfcSubContractResourceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSubedge>(const DB& db, const LIST& params, IfcSubedge* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceCurveSweptAreaSolid>(const DB& db, const LIST& params, IfcSurfaceCurveSweptAreaSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceFeature>(const DB& db, const LIST& params, IfcSurfaceFeature* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSweptSurface>(const DB& db, const LIST& params, IfcSweptSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceOfLinearExtrusion>(const DB& db, const LIST& params, IfcSurfaceOfLinearExtrusion* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceOfRevolution>(const DB& db, const LIST& params, IfcSurfaceOfRevolution* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params, IfcSurfaceStyle* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); }    do { // convert the 'Side' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Side, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
+    } while(0);
+    do { // convert the 'Styles' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Styles, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST& params, IfcSurfaceStyleShading* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSurfaceStyleShading"); }    do { // convert the 'SurfaceColour' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->SurfaceColour, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
+    } while(0);
+    do { // convert the 'Transparency' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,2>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->Transparency, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleShading to be a `IfcNormalisedRatioMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIST& params, IfcSurfaceStyleRendering* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSurfaceStyleShading*>(in));
+	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); }    do { // convert the 'DiffuseColour' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->DiffuseColour, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
+    } while(0);
+    do { // convert the 'TransmissionColour' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->TransmissionColour, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
+    } while(0);
+    do { // convert the 'DiffuseTransmissionColour' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
+    } while(0);
+    do { // convert the 'ReflectionColour' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->ReflectionColour, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
+    } while(0);
+    do { // convert the 'SpecularColour' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->SpecularColour, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
+    } while(0);
+    do { // convert the 'SpecularHighlight' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->SpecularHighlight, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
+    } while(0);
+    do { // convert the 'ReflectanceMethod' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const LIST& params, IfcSurfaceStyleWithTextures* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); }    do { // convert the 'Textures' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Textures, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSweptDiskSolid>(const DB& db, const LIST& params, IfcSweptDiskSolid* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); }    do { // convert the 'Directrix' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->Directrix, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); }
+    } while(0);
+    do { // convert the 'Radius' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->Radius, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'InnerRadius' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->InnerRadius, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'StartParam' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->StartParam, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
+    } while(0);
+    do { // convert the 'EndParam' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[4]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->EndParam, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSweptDiskSolidPolygonal>(const DB& db, const LIST& params, IfcSweptDiskSolidPolygonal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSweptDiskSolid*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSwitchingDevice>(const DB& db, const LIST& params, IfcSwitchingDevice* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSwitchingDeviceType>(const DB& db, const LIST& params, IfcSwitchingDeviceType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSystemFurnitureElement>(const DB& db, const LIST& params, IfcSystemFurnitureElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcSystemFurnitureElementType>(const DB& db, const LIST& params, IfcSystemFurnitureElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTShapeProfileDef>(const DB& db, const LIST& params, IfcTShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTank>(const DB& db, const LIST& params, IfcTank* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTankType>(const DB& db, const LIST& params, IfcTankType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTask>(const DB& db, const LIST& params, IfcTask* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTaskType>(const DB& db, const LIST& params, IfcTaskType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProcess*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTendon>(const DB& db, const LIST& params, IfcTendon* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTendonAnchor>(const DB& db, const LIST& params, IfcTendonAnchor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTendonAnchorType>(const DB& db, const LIST& params, IfcTendonAnchorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTendonType>(const DB& db, const LIST& params, IfcTendonType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTextLiteral>(const DB& db, const LIST& params, IfcTextLiteral* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTextLiteralWithExtent>(const DB& db, const LIST& params, IfcTextLiteralWithExtent* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTextLiteral*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTopologyRepresentation>(const DB& db, const LIST& params, IfcTopologyRepresentation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcToroidalSurface>(const DB& db, const LIST& params, IfcToroidalSurface* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTransformer>(const DB& db, const LIST& params, IfcTransformer* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTransformerType>(const DB& db, const LIST& params, IfcTransformerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTransportElement>(const DB& db, const LIST& params, IfcTransportElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTransportElementType>(const DB& db, const LIST& params, IfcTransportElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTrapeziumProfileDef>(const DB& db, const LIST& params, IfcTrapeziumProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTriangulatedFaceSet>(const DB& db, const LIST& params, IfcTriangulatedFaceSet* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTessellatedFaceSet*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTrimmedCurve>(const DB& db, const LIST& params, IfcTrimmedCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); }    do { // convert the 'BasisCurve' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->BasisCurve, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); }
+    } while(0);
+    do { // convert the 'Trim1' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Trim1, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
+    } while(0);
+    do { // convert the 'Trim2' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Trim2, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
+    } while(0);
+    do { // convert the 'SenseAgreement' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->SenseAgreement, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `IfcBoolean`")); }
+    } while(0);
+    do { // convert the 'MasterRepresentation' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->MasterRepresentation, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTubeBundle>(const DB& db, const LIST& params, IfcTubeBundle* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcTubeBundleType>(const DB& db, const LIST& params, IfcTubeBundleType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcUShapeProfileDef>(const DB& db, const LIST& params, IfcUShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& params, IfcUnitAssignment* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); }    do { // convert the 'Units' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Units, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcUnitaryControlElement>(const DB& db, const LIST& params, IfcUnitaryControlElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcUnitaryControlElementType>(const DB& db, const LIST& params, IfcUnitaryControlElementType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcUnitaryEquipment>(const DB& db, const LIST& params, IfcUnitaryEquipment* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcUnitaryEquipmentType>(const DB& db, const LIST& params, IfcUnitaryEquipmentType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcValve>(const DB& db, const LIST& params, IfcValve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcValveType>(const DB& db, const LIST& params, IfcValveType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcVector* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); }    do { // convert the 'Orientation' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Orientation, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
+    } while(0);
+    do { // convert the 'Magnitude' argument
+        boost::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->Magnitude, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVertex>(const DB& db, const LIST& params, IfcVertex* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVertexLoop>(const DB& db, const LIST& params, IfcVertexLoop* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVertexPoint>(const DB& db, const LIST& params, IfcVertexPoint* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcVertex*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVibrationIsolator>(const DB& db, const LIST& params, IfcVibrationIsolator* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVibrationIsolatorType>(const DB& db, const LIST& params, IfcVibrationIsolatorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVirtualElement>(const DB& db, const LIST& params, IfcVirtualElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcVoidingFeature>(const DB& db, const LIST& params, IfcVoidingFeature* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWall>(const DB& db, const LIST& params, IfcWall* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWallElementedCase>(const DB& db, const LIST& params, IfcWallElementedCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcWall*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWallStandardCase>(const DB& db, const LIST& params, IfcWallStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcWall*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWallType>(const DB& db, const LIST& params, IfcWallType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWasteTerminal>(const DB& db, const LIST& params, IfcWasteTerminal* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWasteTerminalType>(const DB& db, const LIST& params, IfcWasteTerminalType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWindow>(const DB& db, const LIST& params, IfcWindow* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWindowStandardCase>(const DB& db, const LIST& params, IfcWindowStandardCase* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcWindow*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWindowStyle>(const DB& db, const LIST& params, IfcWindowStyle* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWindowType>(const DB& db, const LIST& params, IfcWindowType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWorkCalendar>(const DB& db, const LIST& params, IfcWorkCalendar* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWorkControl>(const DB& db, const LIST& params, IfcWorkControl* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWorkPlan>(const DB& db, const LIST& params, IfcWorkPlan* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcWorkSchedule>(const DB& db, const LIST& params, IfcWorkSchedule* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcZShapeProfileDef>(const DB& db, const LIST& params, IfcZShapeProfileDef* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcZone>(const DB& db, const LIST& params, IfcZone* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+
+} // ! STEP
+} // ! Assimp
+
+#endif

code/Importer/IFC/IFCReaderGen_4.h

@@ -0,0 +1,5449 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2010, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
+
+#ifndef INCLUDED_IFC_READER_GEN_H
+#define INCLUDED_IFC_READER_GEN_H
+
+#include "STEPFile.h"
+
+namespace Assimp {
+namespace IFC {
+	using namespace STEP;
+	using namespace STEP::EXPRESS;
+	
+	
+	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
+		
+	};
+	
+
+	// ******************************************************************************
+	// IFC Custom data types
+	// ******************************************************************************
+
+
+    // C++ wrapper type for IfcStrippedOptional
+    typedef BOOLEAN IfcStrippedOptional;
+    // C++ wrapper type for IfcAbsorbedDoseMeasure
+    typedef REAL IfcAbsorbedDoseMeasure;
+    // C++ wrapper type for IfcAccelerationMeasure
+    typedef REAL IfcAccelerationMeasure;
+    // C++ wrapper type for IfcAmountOfSubstanceMeasure
+    typedef REAL IfcAmountOfSubstanceMeasure;
+    // C++ wrapper type for IfcAngularVelocityMeasure
+    typedef REAL IfcAngularVelocityMeasure;
+    // C++ wrapper type for IfcArcIndex
+    typedef ListOf< INTEGER, 3, 3 > IfcArcIndex;
+    // C++ wrapper type for IfcAreaDensityMeasure
+    typedef REAL IfcAreaDensityMeasure;
+    // C++ wrapper type for IfcAreaMeasure
+    typedef REAL IfcAreaMeasure;
+    // C++ wrapper type for IfcBoolean
+    typedef BOOLEAN IfcBoolean;
+    // C++ wrapper type for IfcBoxAlignment
+    typedef STRING IfcBoxAlignment;
+    // C++ wrapper type for IfcCardinalPointReference
+    typedef INTEGER IfcCardinalPointReference;
+    // C++ wrapper type for IfcCompoundPlaneAngleMeasure
+    typedef ListOf< INTEGER, 3, 4 > IfcCompoundPlaneAngleMeasure;
+    // C++ wrapper type for IfcContextDependentMeasure
+    typedef REAL IfcContextDependentMeasure;
+    // C++ wrapper type for IfcCountMeasure
+    typedef NUMBER IfcCountMeasure;
+    // C++ wrapper type for IfcCurvatureMeasure
+    typedef REAL IfcCurvatureMeasure;
+    // C++ wrapper type for IfcDate
+    typedef STRING IfcDate;
+    // C++ wrapper type for IfcDateTime
+    typedef STRING IfcDateTime;
+    // C++ wrapper type for IfcDayInMonthNumber
+    typedef INTEGER IfcDayInMonthNumber;
+    // C++ wrapper type for IfcDayInWeekNumber
+    typedef INTEGER IfcDayInWeekNumber;
+    // C++ wrapper type for IfcDescriptiveMeasure
+    typedef STRING IfcDescriptiveMeasure;
+    // C++ wrapper type for IfcDimensionCount
+    typedef INTEGER IfcDimensionCount;
+    // C++ wrapper type for IfcDoseEquivalentMeasure
+    typedef REAL IfcDoseEquivalentMeasure;
+    // C++ wrapper type for IfcDuration
+    typedef STRING IfcDuration;
+    // C++ wrapper type for IfcDynamicViscosityMeasure
+    typedef REAL IfcDynamicViscosityMeasure;
+    // C++ wrapper type for IfcElectricCapacitanceMeasure
+    typedef REAL IfcElectricCapacitanceMeasure;
+    // C++ wrapper type for IfcElectricChargeMeasure
+    typedef REAL IfcElectricChargeMeasure;
+    // C++ wrapper type for IfcElectricConductanceMeasure
+    typedef REAL IfcElectricConductanceMeasure;
+    // C++ wrapper type for IfcElectricCurrentMeasure
+    typedef REAL IfcElectricCurrentMeasure;
+    // C++ wrapper type for IfcElectricResistanceMeasure
+    typedef REAL IfcElectricResistanceMeasure;
+    // C++ wrapper type for IfcElectricVoltageMeasure
+    typedef REAL IfcElectricVoltageMeasure;
+    // C++ wrapper type for IfcEnergyMeasure
+    typedef REAL IfcEnergyMeasure;
+    // C++ wrapper type for IfcFontStyle
+    typedef STRING IfcFontStyle;
+    // C++ wrapper type for IfcFontVariant
+    typedef STRING IfcFontVariant;
+    // C++ wrapper type for IfcFontWeight
+    typedef STRING IfcFontWeight;
+    // C++ wrapper type for IfcForceMeasure
+    typedef REAL IfcForceMeasure;
+    // C++ wrapper type for IfcFrequencyMeasure
+    typedef REAL IfcFrequencyMeasure;
+    // C++ wrapper type for IfcGloballyUniqueId
+    typedef STRING IfcGloballyUniqueId;
+    // C++ wrapper type for IfcHeatFluxDensityMeasure
+    typedef REAL IfcHeatFluxDensityMeasure;
+    // C++ wrapper type for IfcHeatingValueMeasure
+    typedef REAL IfcHeatingValueMeasure;
+    // C++ wrapper type for IfcIdentifier
+    typedef STRING IfcIdentifier;
+    // C++ wrapper type for IfcIlluminanceMeasure
+    typedef REAL IfcIlluminanceMeasure;
+    // C++ wrapper type for IfcInductanceMeasure
+    typedef REAL IfcInductanceMeasure;
+    // C++ wrapper type for IfcInteger
+    typedef INTEGER IfcInteger;
+    // C++ wrapper type for IfcIntegerCountRateMeasure
+    typedef INTEGER IfcIntegerCountRateMeasure;
+    // C++ wrapper type for IfcIonConcentrationMeasure
+    typedef REAL IfcIonConcentrationMeasure;
+    // C++ wrapper type for IfcIsothermalMoistureCapacityMeasure
+    typedef REAL IfcIsothermalMoistureCapacityMeasure;
+    // C++ wrapper type for IfcKinematicViscosityMeasure
+    typedef REAL IfcKinematicViscosityMeasure;
+    // C++ wrapper type for IfcLabel
+    typedef STRING IfcLabel;
+    // C++ wrapper type for IfcLanguageId
+    typedef STRING IfcLanguageId;
+    // C++ wrapper type for IfcLengthMeasure
+    typedef REAL IfcLengthMeasure;
+    // C++ wrapper type for IfcLineIndex
+    typedef ListOf< INTEGER, 2, 0 > IfcLineIndex;
+    // C++ wrapper type for IfcLinearForceMeasure
+    typedef REAL IfcLinearForceMeasure;
+    // C++ wrapper type for IfcLinearMomentMeasure
+    typedef REAL IfcLinearMomentMeasure;
+    // C++ wrapper type for IfcLinearStiffnessMeasure
+    typedef REAL IfcLinearStiffnessMeasure;
+    // C++ wrapper type for IfcLinearVelocityMeasure
+    typedef REAL IfcLinearVelocityMeasure;
+    // C++ wrapper type for IfcLogical
+    typedef LOGICAL IfcLogical;
+    // C++ wrapper type for IfcLuminousFluxMeasure
+    typedef REAL IfcLuminousFluxMeasure;
+    // C++ wrapper type for IfcLuminousIntensityDistributionMeasure
+    typedef REAL IfcLuminousIntensityDistributionMeasure;
+    // C++ wrapper type for IfcLuminousIntensityMeasure
+    typedef REAL IfcLuminousIntensityMeasure;
+    // C++ wrapper type for IfcMagneticFluxDensityMeasure
+    typedef REAL IfcMagneticFluxDensityMeasure;
+    // C++ wrapper type for IfcMagneticFluxMeasure
+    typedef REAL IfcMagneticFluxMeasure;
+    // C++ wrapper type for IfcMassDensityMeasure
+    typedef REAL IfcMassDensityMeasure;
+    // C++ wrapper type for IfcMassFlowRateMeasure
+    typedef REAL IfcMassFlowRateMeasure;
+    // C++ wrapper type for IfcMassMeasure
+    typedef REAL IfcMassMeasure;
+    // C++ wrapper type for IfcMassPerLengthMeasure
+    typedef REAL IfcMassPerLengthMeasure;
+    // C++ wrapper type for IfcModulusOfElasticityMeasure
+    typedef REAL IfcModulusOfElasticityMeasure;
+    // C++ wrapper type for IfcModulusOfLinearSubgradeReactionMeasure
+    typedef REAL IfcModulusOfLinearSubgradeReactionMeasure;
+    // C++ wrapper type for IfcModulusOfRotationalSubgradeReactionMeasure
+    typedef REAL IfcModulusOfRotationalSubgradeReactionMeasure;
+    // C++ wrapper type for IfcModulusOfSubgradeReactionMeasure
+    typedef REAL IfcModulusOfSubgradeReactionMeasure;
+    // C++ wrapper type for IfcMoistureDiffusivityMeasure
+    typedef REAL IfcMoistureDiffusivityMeasure;
+    // C++ wrapper type for IfcMolecularWeightMeasure
+    typedef REAL IfcMolecularWeightMeasure;
+    // C++ wrapper type for IfcMomentOfInertiaMeasure
+    typedef REAL IfcMomentOfInertiaMeasure;
+    // C++ wrapper type for IfcMonetaryMeasure
+    typedef REAL IfcMonetaryMeasure;
+    // C++ wrapper type for IfcMonthInYearNumber
+    typedef INTEGER IfcMonthInYearNumber;
+    // C++ wrapper type for IfcNonNegativeLengthMeasure
+    typedef REAL IfcNonNegativeLengthMeasure;
+    // C++ wrapper type for IfcNormalisedRatioMeasure
+    typedef REAL IfcNormalisedRatioMeasure;
+    // C++ wrapper type for IfcNumericMeasure
+    typedef NUMBER IfcNumericMeasure;
+    // C++ wrapper type for IfcPHMeasure
+    typedef REAL IfcPHMeasure;
+    // C++ wrapper type for IfcParameterValue
+    typedef REAL IfcParameterValue;
+    // C++ wrapper type for IfcPlanarForceMeasure
+    typedef REAL IfcPlanarForceMeasure;
+    // C++ wrapper type for IfcPlaneAngleMeasure
+    typedef REAL IfcPlaneAngleMeasure;
+    // C++ wrapper type for IfcPositiveInteger
+    typedef INTEGER IfcPositiveInteger;
+    // C++ wrapper type for IfcPositiveLengthMeasure
+    typedef REAL IfcPositiveLengthMeasure;
+    // C++ wrapper type for IfcPositivePlaneAngleMeasure
+    typedef REAL IfcPositivePlaneAngleMeasure;
+    // C++ wrapper type for IfcPositiveRatioMeasure
+    typedef REAL IfcPositiveRatioMeasure;
+    // C++ wrapper type for IfcPowerMeasure
+    typedef REAL IfcPowerMeasure;
+    // C++ wrapper type for IfcPresentableText
+    typedef STRING IfcPresentableText;
+    // C++ wrapper type for IfcPressureMeasure
+    typedef REAL IfcPressureMeasure;
+    // C++ wrapper type for IfcRadioActivityMeasure
+    typedef REAL IfcRadioActivityMeasure;
+    // C++ wrapper type for IfcRatioMeasure
+    typedef REAL IfcRatioMeasure;
+    // C++ wrapper type for IfcReal
+    typedef REAL IfcReal;
+    // C++ wrapper type for IfcRotationalFrequencyMeasure
+    typedef REAL IfcRotationalFrequencyMeasure;
+    // C++ wrapper type for IfcRotationalMassMeasure
+    typedef REAL IfcRotationalMassMeasure;
+    // C++ wrapper type for IfcRotationalStiffnessMeasure
+    typedef REAL IfcRotationalStiffnessMeasure;
+    // C++ wrapper type for IfcSectionModulusMeasure
+    typedef REAL IfcSectionModulusMeasure;
+    // C++ wrapper type for IfcSectionalAreaIntegralMeasure
+    typedef REAL IfcSectionalAreaIntegralMeasure;
+    // C++ wrapper type for IfcShearModulusMeasure
+    typedef REAL IfcShearModulusMeasure;
+    // C++ wrapper type for IfcSolidAngleMeasure
+    typedef REAL IfcSolidAngleMeasure;
+    // C++ wrapper type for IfcSoundPowerLevelMeasure
+    typedef REAL IfcSoundPowerLevelMeasure;
+    // C++ wrapper type for IfcSoundPowerMeasure
+    typedef REAL IfcSoundPowerMeasure;
+    // C++ wrapper type for IfcSoundPressureLevelMeasure
+    typedef REAL IfcSoundPressureLevelMeasure;
+    // C++ wrapper type for IfcSoundPressureMeasure
+    typedef REAL IfcSoundPressureMeasure;
+    // C++ wrapper type for IfcSpecificHeatCapacityMeasure
+    typedef REAL IfcSpecificHeatCapacityMeasure;
+    // C++ wrapper type for IfcSpecularExponent
+    typedef REAL IfcSpecularExponent;
+    // C++ wrapper type for IfcSpecularRoughness
+    typedef REAL IfcSpecularRoughness;
+    // C++ wrapper type for IfcTemperatureGradientMeasure
+    typedef REAL IfcTemperatureGradientMeasure;
+    // C++ wrapper type for IfcTemperatureRateOfChangeMeasure
+    typedef REAL IfcTemperatureRateOfChangeMeasure;
+    // C++ wrapper type for IfcText
+    typedef STRING IfcText;
+    // C++ wrapper type for IfcTextAlignment
+    typedef STRING IfcTextAlignment;
+    // C++ wrapper type for IfcTextDecoration
+    typedef STRING IfcTextDecoration;
+    // C++ wrapper type for IfcTextFontName
+    typedef STRING IfcTextFontName;
+    // C++ wrapper type for IfcTextTransformation
+    typedef STRING IfcTextTransformation;
+    // C++ wrapper type for IfcThermalAdmittanceMeasure
+    typedef REAL IfcThermalAdmittanceMeasure;
+    // C++ wrapper type for IfcThermalConductivityMeasure
+    typedef REAL IfcThermalConductivityMeasure;
+    // C++ wrapper type for IfcThermalExpansionCoefficientMeasure
+    typedef REAL IfcThermalExpansionCoefficientMeasure;
+    // C++ wrapper type for IfcThermalResistanceMeasure
+    typedef REAL IfcThermalResistanceMeasure;
+    // C++ wrapper type for IfcThermalTransmittanceMeasure
+    typedef REAL IfcThermalTransmittanceMeasure;
+    // C++ wrapper type for IfcThermodynamicTemperatureMeasure
+    typedef REAL IfcThermodynamicTemperatureMeasure;
+    // C++ wrapper type for IfcTime
+    typedef STRING IfcTime;
+    // C++ wrapper type for IfcTimeMeasure
+    typedef REAL IfcTimeMeasure;
+    // C++ wrapper type for IfcTimeStamp
+    typedef INTEGER IfcTimeStamp;
+    // C++ wrapper type for IfcTorqueMeasure
+    typedef REAL IfcTorqueMeasure;
+    // C++ wrapper type for IfcURIReference
+    typedef STRING IfcURIReference;
+    // C++ wrapper type for IfcVaporPermeabilityMeasure
+    typedef REAL IfcVaporPermeabilityMeasure;
+    // C++ wrapper type for IfcVolumeMeasure
+    typedef REAL IfcVolumeMeasure;
+    // C++ wrapper type for IfcVolumetricFlowRateMeasure
+    typedef REAL IfcVolumetricFlowRateMeasure;
+    // C++ wrapper type for IfcWarpingConstantMeasure
+    typedef REAL IfcWarpingConstantMeasure;
+    // C++ wrapper type for IfcWarpingMomentMeasure
+    typedef REAL IfcWarpingMomentMeasure;
+    // C++ wrapper type for IfcActionRequestTypeEnum
+    typedef ENUMERATION IfcActionRequestTypeEnum;
+    // C++ wrapper type for IfcActionSourceTypeEnum
+    typedef ENUMERATION IfcActionSourceTypeEnum;
+    // C++ wrapper type for IfcActionTypeEnum
+    typedef ENUMERATION IfcActionTypeEnum;
+    // C++ wrapper type for IfcActuatorTypeEnum
+    typedef ENUMERATION IfcActuatorTypeEnum;
+    // C++ wrapper type for IfcAddressTypeEnum
+    typedef ENUMERATION IfcAddressTypeEnum;
+    // C++ wrapper type for IfcAirTerminalBoxTypeEnum
+    typedef ENUMERATION IfcAirTerminalBoxTypeEnum;
+    // C++ wrapper type for IfcAirTerminalTypeEnum
+    typedef ENUMERATION IfcAirTerminalTypeEnum;
+    // C++ wrapper type for IfcAirToAirHeatRecoveryTypeEnum
+    typedef ENUMERATION IfcAirToAirHeatRecoveryTypeEnum;
+    // C++ wrapper type for IfcAlarmTypeEnum
+    typedef ENUMERATION IfcAlarmTypeEnum;
+    // C++ wrapper type for IfcAnalysisModelTypeEnum
+    typedef ENUMERATION IfcAnalysisModelTypeEnum;
+    // C++ wrapper type for IfcAnalysisTheoryTypeEnum
+    typedef ENUMERATION IfcAnalysisTheoryTypeEnum;
+    // C++ wrapper type for IfcArithmeticOperatorEnum
+    typedef ENUMERATION IfcArithmeticOperatorEnum;
+    // C++ wrapper type for IfcAssemblyPlaceEnum
+    typedef ENUMERATION IfcAssemblyPlaceEnum;
+    // C++ wrapper type for IfcAudioVisualApplianceTypeEnum
+    typedef ENUMERATION IfcAudioVisualApplianceTypeEnum;
+    // C++ wrapper type for IfcBSplineCurveForm
+    typedef ENUMERATION IfcBSplineCurveForm;
+    // C++ wrapper type for IfcBSplineSurfaceForm
+    typedef ENUMERATION IfcBSplineSurfaceForm;
+    // C++ wrapper type for IfcBeamTypeEnum
+    typedef ENUMERATION IfcBeamTypeEnum;
+    // C++ wrapper type for IfcBenchmarkEnum
+    typedef ENUMERATION IfcBenchmarkEnum;
+    // C++ wrapper type for IfcBoilerTypeEnum
+    typedef ENUMERATION IfcBoilerTypeEnum;
+    // C++ wrapper type for IfcBooleanOperator
+    typedef ENUMERATION IfcBooleanOperator;
+    // C++ wrapper type for IfcBuildingElementPartTypeEnum
+    typedef ENUMERATION IfcBuildingElementPartTypeEnum;
+    // C++ wrapper type for IfcBuildingElementProxyTypeEnum
+    typedef ENUMERATION IfcBuildingElementProxyTypeEnum;
+    // C++ wrapper type for IfcBuildingSystemTypeEnum
+    typedef ENUMERATION IfcBuildingSystemTypeEnum;
+    // C++ wrapper type for IfcBurnerTypeEnum
+    typedef ENUMERATION IfcBurnerTypeEnum;
+    // C++ wrapper type for IfcCableCarrierFittingTypeEnum
+    typedef ENUMERATION IfcCableCarrierFittingTypeEnum;
+    // C++ wrapper type for IfcCableCarrierSegmentTypeEnum
+    typedef ENUMERATION IfcCableCarrierSegmentTypeEnum;
+    // C++ wrapper type for IfcCableFittingTypeEnum
+    typedef ENUMERATION IfcCableFittingTypeEnum;
+    // C++ wrapper type for IfcCableSegmentTypeEnum
+    typedef ENUMERATION IfcCableSegmentTypeEnum;
+    // C++ wrapper type for IfcChangeActionEnum
+    typedef ENUMERATION IfcChangeActionEnum;
+    // C++ wrapper type for IfcChillerTypeEnum
+    typedef ENUMERATION IfcChillerTypeEnum;
+    // C++ wrapper type for IfcChimneyTypeEnum
+    typedef ENUMERATION IfcChimneyTypeEnum;
+    // C++ wrapper type for IfcCoilTypeEnum
+    typedef ENUMERATION IfcCoilTypeEnum;
+    // C++ wrapper type for IfcColumnTypeEnum
+    typedef ENUMERATION IfcColumnTypeEnum;
+    // C++ wrapper type for IfcCommunicationsApplianceTypeEnum
+    typedef ENUMERATION IfcCommunicationsApplianceTypeEnum;
+    // C++ wrapper type for IfcComplexPropertyTemplateTypeEnum
+    typedef ENUMERATION IfcComplexPropertyTemplateTypeEnum;
+    // C++ wrapper type for IfcCompressorTypeEnum
+    typedef ENUMERATION IfcCompressorTypeEnum;
+    // C++ wrapper type for IfcCondenserTypeEnum
+    typedef ENUMERATION IfcCondenserTypeEnum;
+    // C++ wrapper type for IfcConnectionTypeEnum
+    typedef ENUMERATION IfcConnectionTypeEnum;
+    // C++ wrapper type for IfcConstraintEnum
+    typedef ENUMERATION IfcConstraintEnum;
+    // C++ wrapper type for IfcConstructionEquipmentResourceTypeEnum
+    typedef ENUMERATION IfcConstructionEquipmentResourceTypeEnum;
+    // C++ wrapper type for IfcConstructionMaterialResourceTypeEnum
+    typedef ENUMERATION IfcConstructionMaterialResourceTypeEnum;
+    // C++ wrapper type for IfcConstructionProductResourceTypeEnum
+    typedef ENUMERATION IfcConstructionProductResourceTypeEnum;
+    // C++ wrapper type for IfcControllerTypeEnum
+    typedef ENUMERATION IfcControllerTypeEnum;
+    // C++ wrapper type for IfcCooledBeamTypeEnum
+    typedef ENUMERATION IfcCooledBeamTypeEnum;
+    // C++ wrapper type for IfcCoolingTowerTypeEnum
+    typedef ENUMERATION IfcCoolingTowerTypeEnum;
+    // C++ wrapper type for IfcCostItemTypeEnum
+    typedef ENUMERATION IfcCostItemTypeEnum;
+    // C++ wrapper type for IfcCostScheduleTypeEnum
+    typedef ENUMERATION IfcCostScheduleTypeEnum;
+    // C++ wrapper type for IfcCoveringTypeEnum
+    typedef ENUMERATION IfcCoveringTypeEnum;
+    // C++ wrapper type for IfcCrewResourceTypeEnum
+    typedef ENUMERATION IfcCrewResourceTypeEnum;
+    // C++ wrapper type for IfcCurtainWallTypeEnum
+    typedef ENUMERATION IfcCurtainWallTypeEnum;
+    // C++ wrapper type for IfcCurveInterpolationEnum
+    typedef ENUMERATION IfcCurveInterpolationEnum;
+    // C++ wrapper type for IfcDamperTypeEnum
+    typedef ENUMERATION IfcDamperTypeEnum;
+    // C++ wrapper type for IfcDataOriginEnum
+    typedef ENUMERATION IfcDataOriginEnum;
+    // C++ wrapper type for IfcDerivedUnitEnum
+    typedef ENUMERATION IfcDerivedUnitEnum;
+    // C++ wrapper type for IfcDirectionSenseEnum
+    typedef ENUMERATION IfcDirectionSenseEnum;
+    // C++ wrapper type for IfcDiscreteAccessoryTypeEnum
+    typedef ENUMERATION IfcDiscreteAccessoryTypeEnum;
+    // C++ wrapper type for IfcDistributionChamberElementTypeEnum
+    typedef ENUMERATION IfcDistributionChamberElementTypeEnum;
+    // C++ wrapper type for IfcDistributionPortTypeEnum
+    typedef ENUMERATION IfcDistributionPortTypeEnum;
+    // C++ wrapper type for IfcDistributionSystemEnum
+    typedef ENUMERATION IfcDistributionSystemEnum;
+    // C++ wrapper type for IfcDocumentConfidentialityEnum
+    typedef ENUMERATION IfcDocumentConfidentialityEnum;
+    // C++ wrapper type for IfcDocumentStatusEnum
+    typedef ENUMERATION IfcDocumentStatusEnum;
+    // C++ wrapper type for IfcDoorPanelOperationEnum
+    typedef ENUMERATION IfcDoorPanelOperationEnum;
+    // C++ wrapper type for IfcDoorPanelPositionEnum
+    typedef ENUMERATION IfcDoorPanelPositionEnum;
+    // C++ wrapper type for IfcDoorStyleConstructionEnum
+    typedef ENUMERATION IfcDoorStyleConstructionEnum;
+    // C++ wrapper type for IfcDoorStyleOperationEnum
+    typedef ENUMERATION IfcDoorStyleOperationEnum;
+    // C++ wrapper type for IfcDoorTypeEnum
+    typedef ENUMERATION IfcDoorTypeEnum;
+    // C++ wrapper type for IfcDoorTypeOperationEnum
+    typedef ENUMERATION IfcDoorTypeOperationEnum;
+    // C++ wrapper type for IfcDuctFittingTypeEnum
+    typedef ENUMERATION IfcDuctFittingTypeEnum;
+    // C++ wrapper type for IfcDuctSegmentTypeEnum
+    typedef ENUMERATION IfcDuctSegmentTypeEnum;
+    // C++ wrapper type for IfcDuctSilencerTypeEnum
+    typedef ENUMERATION IfcDuctSilencerTypeEnum;
+    // C++ wrapper type for IfcElectricApplianceTypeEnum
+    typedef ENUMERATION IfcElectricApplianceTypeEnum;
+    // C++ wrapper type for IfcElectricDistributionBoardTypeEnum
+    typedef ENUMERATION IfcElectricDistributionBoardTypeEnum;
+    // C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum
+    typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum;
+    // C++ wrapper type for IfcElectricGeneratorTypeEnum
+    typedef ENUMERATION IfcElectricGeneratorTypeEnum;
+    // C++ wrapper type for IfcElectricMotorTypeEnum
+    typedef ENUMERATION IfcElectricMotorTypeEnum;
+    // C++ wrapper type for IfcElectricTimeControlTypeEnum
+    typedef ENUMERATION IfcElectricTimeControlTypeEnum;
+    // C++ wrapper type for IfcElementAssemblyTypeEnum
+    typedef ENUMERATION IfcElementAssemblyTypeEnum;
+    // C++ wrapper type for IfcElementCompositionEnum
+    typedef ENUMERATION IfcElementCompositionEnum;
+    // C++ wrapper type for IfcEngineTypeEnum
+    typedef ENUMERATION IfcEngineTypeEnum;
+    // C++ wrapper type for IfcEvaporativeCoolerTypeEnum
+    typedef ENUMERATION IfcEvaporativeCoolerTypeEnum;
+    // C++ wrapper type for IfcEvaporatorTypeEnum
+    typedef ENUMERATION IfcEvaporatorTypeEnum;
+    // C++ wrapper type for IfcEventTriggerTypeEnum
+    typedef ENUMERATION IfcEventTriggerTypeEnum;
+    // C++ wrapper type for IfcEventTypeEnum
+    typedef ENUMERATION IfcEventTypeEnum;
+    // C++ wrapper type for IfcExternalSpatialElementTypeEnum
+    typedef ENUMERATION IfcExternalSpatialElementTypeEnum;
+    // C++ wrapper type for IfcFanTypeEnum
+    typedef ENUMERATION IfcFanTypeEnum;
+    // C++ wrapper type for IfcFastenerTypeEnum
+    typedef ENUMERATION IfcFastenerTypeEnum;
+    // C++ wrapper type for IfcFilterTypeEnum
+    typedef ENUMERATION IfcFilterTypeEnum;
+    // C++ wrapper type for IfcFireSuppressionTerminalTypeEnum
+    typedef ENUMERATION IfcFireSuppressionTerminalTypeEnum;
+    // C++ wrapper type for IfcFlowDirectionEnum
+    typedef ENUMERATION IfcFlowDirectionEnum;
+    // C++ wrapper type for IfcFlowInstrumentTypeEnum
+    typedef ENUMERATION IfcFlowInstrumentTypeEnum;
+    // C++ wrapper type for IfcFlowMeterTypeEnum
+    typedef ENUMERATION IfcFlowMeterTypeEnum;
+    // C++ wrapper type for IfcFootingTypeEnum
+    typedef ENUMERATION IfcFootingTypeEnum;
+    // C++ wrapper type for IfcFurnitureTypeEnum
+    typedef ENUMERATION IfcFurnitureTypeEnum;
+    // C++ wrapper type for IfcGeographicElementTypeEnum
+    typedef ENUMERATION IfcGeographicElementTypeEnum;
+    // C++ wrapper type for IfcGeometricProjectionEnum
+    typedef ENUMERATION IfcGeometricProjectionEnum;
+    // C++ wrapper type for IfcGlobalOrLocalEnum
+    typedef ENUMERATION IfcGlobalOrLocalEnum;
+    // C++ wrapper type for IfcGridTypeEnum
+    typedef ENUMERATION IfcGridTypeEnum;
+    // C++ wrapper type for IfcHeatExchangerTypeEnum
+    typedef ENUMERATION IfcHeatExchangerTypeEnum;
+    // C++ wrapper type for IfcHumidifierTypeEnum
+    typedef ENUMERATION IfcHumidifierTypeEnum;
+    // C++ wrapper type for IfcInterceptorTypeEnum
+    typedef ENUMERATION IfcInterceptorTypeEnum;
+    // C++ wrapper type for IfcInternalOrExternalEnum
+    typedef ENUMERATION IfcInternalOrExternalEnum;
+    // C++ wrapper type for IfcInventoryTypeEnum
+    typedef ENUMERATION IfcInventoryTypeEnum;
+    // C++ wrapper type for IfcJunctionBoxTypeEnum
+    typedef ENUMERATION IfcJunctionBoxTypeEnum;
+    // C++ wrapper type for IfcKnotType
+    typedef ENUMERATION IfcKnotType;
+    // C++ wrapper type for IfcLaborResourceTypeEnum
+    typedef ENUMERATION IfcLaborResourceTypeEnum;
+    // C++ wrapper type for IfcLampTypeEnum
+    typedef ENUMERATION IfcLampTypeEnum;
+    // C++ wrapper type for IfcLayerSetDirectionEnum
+    typedef ENUMERATION IfcLayerSetDirectionEnum;
+    // C++ wrapper type for IfcLightDistributionCurveEnum
+    typedef ENUMERATION IfcLightDistributionCurveEnum;
+    // C++ wrapper type for IfcLightEmissionSourceEnum
+    typedef ENUMERATION IfcLightEmissionSourceEnum;
+    // C++ wrapper type for IfcLightFixtureTypeEnum
+    typedef ENUMERATION IfcLightFixtureTypeEnum;
+    // C++ wrapper type for IfcLoadGroupTypeEnum
+    typedef ENUMERATION IfcLoadGroupTypeEnum;
+    // C++ wrapper type for IfcLogicalOperatorEnum
+    typedef ENUMERATION IfcLogicalOperatorEnum;
+    // C++ wrapper type for IfcMechanicalFastenerTypeEnum
+    typedef ENUMERATION IfcMechanicalFastenerTypeEnum;
+    // C++ wrapper type for IfcMedicalDeviceTypeEnum
+    typedef ENUMERATION IfcMedicalDeviceTypeEnum;
+    // C++ wrapper type for IfcMemberTypeEnum
+    typedef ENUMERATION IfcMemberTypeEnum;
+    // C++ wrapper type for IfcMotorConnectionTypeEnum
+    typedef ENUMERATION IfcMotorConnectionTypeEnum;
+    // C++ wrapper type for IfcNullStyle
+    typedef ENUMERATION IfcNullStyle;
+    // C++ wrapper type for IfcObjectTypeEnum
+    typedef ENUMERATION IfcObjectTypeEnum;
+    // C++ wrapper type for IfcObjectiveEnum
+    typedef ENUMERATION IfcObjectiveEnum;
+    // C++ wrapper type for IfcOccupantTypeEnum
+    typedef ENUMERATION IfcOccupantTypeEnum;
+    // C++ wrapper type for IfcOpeningElementTypeEnum
+    typedef ENUMERATION IfcOpeningElementTypeEnum;
+    // C++ wrapper type for IfcOutletTypeEnum
+    typedef ENUMERATION IfcOutletTypeEnum;
+    // C++ wrapper type for IfcPerformanceHistoryTypeEnum
+    typedef ENUMERATION IfcPerformanceHistoryTypeEnum;
+    // C++ wrapper type for IfcPermeableCoveringOperationEnum
+    typedef ENUMERATION IfcPermeableCoveringOperationEnum;
+    // C++ wrapper type for IfcPermitTypeEnum
+    typedef ENUMERATION IfcPermitTypeEnum;
+    // C++ wrapper type for IfcPhysicalOrVirtualEnum
+    typedef ENUMERATION IfcPhysicalOrVirtualEnum;
+    // C++ wrapper type for IfcPileConstructionEnum
+    typedef ENUMERATION IfcPileConstructionEnum;
+    // C++ wrapper type for IfcPileTypeEnum
+    typedef ENUMERATION IfcPileTypeEnum;
+    // C++ wrapper type for IfcPipeFittingTypeEnum
+    typedef ENUMERATION IfcPipeFittingTypeEnum;
+    // C++ wrapper type for IfcPipeSegmentTypeEnum
+    typedef ENUMERATION IfcPipeSegmentTypeEnum;
+    // C++ wrapper type for IfcPlateTypeEnum
+    typedef ENUMERATION IfcPlateTypeEnum;
+    // C++ wrapper type for IfcPreferredSurfaceCurveRepresentation
+    typedef ENUMERATION IfcPreferredSurfaceCurveRepresentation;
+    // C++ wrapper type for IfcProcedureTypeEnum
+    typedef ENUMERATION IfcProcedureTypeEnum;
+    // C++ wrapper type for IfcProfileTypeEnum
+    typedef ENUMERATION IfcProfileTypeEnum;
+    // C++ wrapper type for IfcProjectOrderTypeEnum
+    typedef ENUMERATION IfcProjectOrderTypeEnum;
+    // C++ wrapper type for IfcProjectedOrTrueLengthEnum
+    typedef ENUMERATION IfcProjectedOrTrueLengthEnum;
+    // C++ wrapper type for IfcProjectionElementTypeEnum
+    typedef ENUMERATION IfcProjectionElementTypeEnum;
+    // C++ wrapper type for IfcPropertySetTemplateTypeEnum
+    typedef ENUMERATION IfcPropertySetTemplateTypeEnum;
+    // C++ wrapper type for IfcProtectiveDeviceTrippingUnitTypeEnum
+    typedef ENUMERATION IfcProtectiveDeviceTrippingUnitTypeEnum;
+    // C++ wrapper type for IfcProtectiveDeviceTypeEnum
+    typedef ENUMERATION IfcProtectiveDeviceTypeEnum;
+    // C++ wrapper type for IfcPumpTypeEnum
+    typedef ENUMERATION IfcPumpTypeEnum;
+    // C++ wrapper type for IfcRailingTypeEnum
+    typedef ENUMERATION IfcRailingTypeEnum;
+    // C++ wrapper type for IfcRampFlightTypeEnum
+    typedef ENUMERATION IfcRampFlightTypeEnum;
+    // C++ wrapper type for IfcRampTypeEnum
+    typedef ENUMERATION IfcRampTypeEnum;
+    // C++ wrapper type for IfcRecurrenceTypeEnum
+    typedef ENUMERATION IfcRecurrenceTypeEnum;
+    // C++ wrapper type for IfcReflectanceMethodEnum
+    typedef ENUMERATION IfcReflectanceMethodEnum;
+    // C++ wrapper type for IfcReinforcingBarRoleEnum
+    typedef ENUMERATION IfcReinforcingBarRoleEnum;
+    // C++ wrapper type for IfcReinforcingBarSurfaceEnum
+    typedef ENUMERATION IfcReinforcingBarSurfaceEnum;
+    // C++ wrapper type for IfcReinforcingBarTypeEnum
+    typedef ENUMERATION IfcReinforcingBarTypeEnum;
+    // C++ wrapper type for IfcReinforcingMeshTypeEnum
+    typedef ENUMERATION IfcReinforcingMeshTypeEnum;
+    // C++ wrapper type for IfcRoleEnum
+    typedef ENUMERATION IfcRoleEnum;
+    // C++ wrapper type for IfcRoofTypeEnum
+    typedef ENUMERATION IfcRoofTypeEnum;
+    // C++ wrapper type for IfcSIPrefix
+    typedef ENUMERATION IfcSIPrefix;
+    // C++ wrapper type for IfcSIUnitName
+    typedef ENUMERATION IfcSIUnitName;
+    // C++ wrapper type for IfcSanitaryTerminalTypeEnum
+    typedef ENUMERATION IfcSanitaryTerminalTypeEnum;
+    // C++ wrapper type for IfcSectionTypeEnum
+    typedef ENUMERATION IfcSectionTypeEnum;
+    // C++ wrapper type for IfcSensorTypeEnum
+    typedef ENUMERATION IfcSensorTypeEnum;
+    // C++ wrapper type for IfcSequenceEnum
+    typedef ENUMERATION IfcSequenceEnum;
+    // C++ wrapper type for IfcShadingDeviceTypeEnum
+    typedef ENUMERATION IfcShadingDeviceTypeEnum;
+    // C++ wrapper type for IfcSimplePropertyTemplateTypeEnum
+    typedef ENUMERATION IfcSimplePropertyTemplateTypeEnum;
+    // C++ wrapper type for IfcSlabTypeEnum
+    typedef ENUMERATION IfcSlabTypeEnum;
+    // C++ wrapper type for IfcSolarDeviceTypeEnum
+    typedef ENUMERATION IfcSolarDeviceTypeEnum;
+    // C++ wrapper type for IfcSpaceHeaterTypeEnum
+    typedef ENUMERATION IfcSpaceHeaterTypeEnum;
+    // C++ wrapper type for IfcSpaceTypeEnum
+    typedef ENUMERATION IfcSpaceTypeEnum;
+    // C++ wrapper type for IfcSpatialZoneTypeEnum
+    typedef ENUMERATION IfcSpatialZoneTypeEnum;
+    // C++ wrapper type for IfcStackTerminalTypeEnum
+    typedef ENUMERATION IfcStackTerminalTypeEnum;
+    // C++ wrapper type for IfcStairFlightTypeEnum
+    typedef ENUMERATION IfcStairFlightTypeEnum;
+    // C++ wrapper type for IfcStairTypeEnum
+    typedef ENUMERATION IfcStairTypeEnum;
+    // C++ wrapper type for IfcStateEnum
+    typedef ENUMERATION IfcStateEnum;
+    // C++ wrapper type for IfcStructuralCurveActivityTypeEnum
+    typedef ENUMERATION IfcStructuralCurveActivityTypeEnum;
+    // C++ wrapper type for IfcStructuralCurveMemberTypeEnum
+    typedef ENUMERATION IfcStructuralCurveMemberTypeEnum;
+    // C++ wrapper type for IfcStructuralSurfaceActivityTypeEnum
+    typedef ENUMERATION IfcStructuralSurfaceActivityTypeEnum;
+    // C++ wrapper type for IfcStructuralSurfaceMemberTypeEnum
+    typedef ENUMERATION IfcStructuralSurfaceMemberTypeEnum;
+    // C++ wrapper type for IfcSubContractResourceTypeEnum
+    typedef ENUMERATION IfcSubContractResourceTypeEnum;
+    // C++ wrapper type for IfcSurfaceFeatureTypeEnum
+    typedef ENUMERATION IfcSurfaceFeatureTypeEnum;
+    // C++ wrapper type for IfcSurfaceSide
+    typedef ENUMERATION IfcSurfaceSide;
+    // C++ wrapper type for IfcSwitchingDeviceTypeEnum
+    typedef ENUMERATION IfcSwitchingDeviceTypeEnum;
+    // C++ wrapper type for IfcSystemFurnitureElementTypeEnum
+    typedef ENUMERATION IfcSystemFurnitureElementTypeEnum;
+    // C++ wrapper type for IfcTankTypeEnum
+    typedef ENUMERATION IfcTankTypeEnum;
+    // C++ wrapper type for IfcTaskDurationEnum
+    typedef ENUMERATION IfcTaskDurationEnum;
+    // C++ wrapper type for IfcTaskTypeEnum
+    typedef ENUMERATION IfcTaskTypeEnum;
+    // C++ wrapper type for IfcTendonAnchorTypeEnum
+    typedef ENUMERATION IfcTendonAnchorTypeEnum;
+    // C++ wrapper type for IfcTendonTypeEnum
+    typedef ENUMERATION IfcTendonTypeEnum;
+    // C++ wrapper type for IfcTextPath
+    typedef ENUMERATION IfcTextPath;
+    // C++ wrapper type for IfcTimeSeriesDataTypeEnum
+    typedef ENUMERATION IfcTimeSeriesDataTypeEnum;
+    // C++ wrapper type for IfcTransformerTypeEnum
+    typedef ENUMERATION IfcTransformerTypeEnum;
+    // C++ wrapper type for IfcTransitionCode
+    typedef ENUMERATION IfcTransitionCode;
+    // C++ wrapper type for IfcTransportElementTypeEnum
+    typedef ENUMERATION IfcTransportElementTypeEnum;
+    // C++ wrapper type for IfcTrimmingPreference
+    typedef ENUMERATION IfcTrimmingPreference;
+    // C++ wrapper type for IfcTubeBundleTypeEnum
+    typedef ENUMERATION IfcTubeBundleTypeEnum;
+    // C++ wrapper type for IfcUnitEnum
+    typedef ENUMERATION IfcUnitEnum;
+    // C++ wrapper type for IfcUnitaryControlElementTypeEnum
+    typedef ENUMERATION IfcUnitaryControlElementTypeEnum;
+    // C++ wrapper type for IfcUnitaryEquipmentTypeEnum
+    typedef ENUMERATION IfcUnitaryEquipmentTypeEnum;
+    // C++ wrapper type for IfcValveTypeEnum
+    typedef ENUMERATION IfcValveTypeEnum;
+    // C++ wrapper type for IfcVibrationIsolatorTypeEnum
+    typedef ENUMERATION IfcVibrationIsolatorTypeEnum;
+    // C++ wrapper type for IfcVoidingFeatureTypeEnum
+    typedef ENUMERATION IfcVoidingFeatureTypeEnum;
+    // C++ wrapper type for IfcWallTypeEnum
+    typedef ENUMERATION IfcWallTypeEnum;
+    // C++ wrapper type for IfcWasteTerminalTypeEnum
+    typedef ENUMERATION IfcWasteTerminalTypeEnum;
+    // C++ wrapper type for IfcWindowPanelOperationEnum
+    typedef ENUMERATION IfcWindowPanelOperationEnum;
+    // C++ wrapper type for IfcWindowPanelPositionEnum
+    typedef ENUMERATION IfcWindowPanelPositionEnum;
+    // C++ wrapper type for IfcWindowStyleConstructionEnum
+    typedef ENUMERATION IfcWindowStyleConstructionEnum;
+    // C++ wrapper type for IfcWindowStyleOperationEnum
+    typedef ENUMERATION IfcWindowStyleOperationEnum;
+    // C++ wrapper type for IfcWindowTypeEnum
+    typedef ENUMERATION IfcWindowTypeEnum;
+    // C++ wrapper type for IfcWindowTypePartitioningEnum
+    typedef ENUMERATION IfcWindowTypePartitioningEnum;
+    // C++ wrapper type for IfcWorkCalendarTypeEnum
+    typedef ENUMERATION IfcWorkCalendarTypeEnum;
+    // C++ wrapper type for IfcWorkPlanTypeEnum
+    typedef ENUMERATION IfcWorkPlanTypeEnum;
+    // C++ wrapper type for IfcWorkScheduleTypeEnum
+    typedef ENUMERATION IfcWorkScheduleTypeEnum;
+    // C++ wrapper type for IfcActorSelect
+    typedef SELECT IfcActorSelect;
+    // C++ wrapper type for IfcAppliedValueSelect
+    typedef SELECT IfcAppliedValueSelect;
+    // C++ wrapper type for IfcAxis2Placement
+    typedef SELECT IfcAxis2Placement;
+    // C++ wrapper type for IfcBendingParameterSelect
+    typedef SELECT IfcBendingParameterSelect;
+    // C++ wrapper type for IfcBooleanOperand
+    typedef SELECT IfcBooleanOperand;
+    // C++ wrapper type for IfcClassificationReferenceSelect
+    typedef SELECT IfcClassificationReferenceSelect;
+    // C++ wrapper type for IfcClassificationSelect
+    typedef SELECT IfcClassificationSelect;
+    // C++ wrapper type for IfcColour
+    typedef SELECT IfcColour;
+    // C++ wrapper type for IfcColourOrFactor
+    typedef SELECT IfcColourOrFactor;
+    // C++ wrapper type for IfcCoordinateReferenceSystemSelect
+    typedef SELECT IfcCoordinateReferenceSystemSelect;
+    // C++ wrapper type for IfcCsgSelect
+    typedef SELECT IfcCsgSelect;
+    // C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect
+    typedef SELECT IfcCurveFontOrScaledCurveFontSelect;
+    // C++ wrapper type for IfcCurveOnSurface
+    typedef SELECT IfcCurveOnSurface;
+    // C++ wrapper type for IfcCurveOrEdgeCurve
+    typedef SELECT IfcCurveOrEdgeCurve;
+    // C++ wrapper type for IfcCurveStyleFontSelect
+    typedef SELECT IfcCurveStyleFontSelect;
+    // C++ wrapper type for IfcDefinitionSelect
+    typedef SELECT IfcDefinitionSelect;
+    // C++ wrapper type for IfcDerivedMeasureValue
+    typedef SELECT IfcDerivedMeasureValue;
+    // C++ wrapper type for IfcDocumentSelect
+    typedef SELECT IfcDocumentSelect;
+    // C++ wrapper type for IfcFillStyleSelect
+    typedef SELECT IfcFillStyleSelect;
+    // C++ wrapper type for IfcGeometricSetSelect
+    typedef SELECT IfcGeometricSetSelect;
+    // C++ wrapper type for IfcGridPlacementDirectionSelect
+    typedef SELECT IfcGridPlacementDirectionSelect;
+    // C++ wrapper type for IfcHatchLineDistanceSelect
+    typedef SELECT IfcHatchLineDistanceSelect;
+    // C++ wrapper type for IfcLayeredItem
+    typedef SELECT IfcLayeredItem;
+    // C++ wrapper type for IfcLibrarySelect
+    typedef SELECT IfcLibrarySelect;
+    // C++ wrapper type for IfcLightDistributionDataSourceSelect
+    typedef SELECT IfcLightDistributionDataSourceSelect;
+    // C++ wrapper type for IfcMaterialSelect
+    typedef SELECT IfcMaterialSelect;
+    // C++ wrapper type for IfcMeasureValue
+    typedef SELECT IfcMeasureValue;
+    // C++ wrapper type for IfcMetricValueSelect
+    typedef SELECT IfcMetricValueSelect;
+    // C++ wrapper type for IfcModulusOfRotationalSubgradeReactionSelect
+    typedef SELECT IfcModulusOfRotationalSubgradeReactionSelect;
+    // C++ wrapper type for IfcModulusOfSubgradeReactionSelect
+    typedef SELECT IfcModulusOfSubgradeReactionSelect;
+    // C++ wrapper type for IfcModulusOfTranslationalSubgradeReactionSelect
+    typedef SELECT IfcModulusOfTranslationalSubgradeReactionSelect;
+    // C++ wrapper type for IfcObjectReferenceSelect
+    typedef SELECT IfcObjectReferenceSelect;
+    // C++ wrapper type for IfcPointOrVertexPoint
+    typedef SELECT IfcPointOrVertexPoint;
+    // C++ wrapper type for IfcPresentationStyleSelect
+    typedef SELECT IfcPresentationStyleSelect;
+    // C++ wrapper type for IfcProcessSelect
+    typedef SELECT IfcProcessSelect;
+    // C++ wrapper type for IfcProductRepresentationSelect
+    typedef SELECT IfcProductRepresentationSelect;
+    // C++ wrapper type for IfcProductSelect
+    typedef SELECT IfcProductSelect;
+    // C++ wrapper type for IfcPropertySetDefinitionSelect
+    typedef SELECT IfcPropertySetDefinitionSelect;
+    // C++ wrapper type for IfcResourceObjectSelect
+    typedef SELECT IfcResourceObjectSelect;
+    // C++ wrapper type for IfcResourceSelect
+    typedef SELECT IfcResourceSelect;
+    // C++ wrapper type for IfcRotationalStiffnessSelect
+    typedef SELECT IfcRotationalStiffnessSelect;
+    // C++ wrapper type for IfcSegmentIndexSelect
+    typedef SELECT IfcSegmentIndexSelect;
+    // C++ wrapper type for IfcShell
+    typedef SELECT IfcShell;
+    // C++ wrapper type for IfcSimpleValue
+    typedef SELECT IfcSimpleValue;
+    // C++ wrapper type for IfcSizeSelect
+    typedef SELECT IfcSizeSelect;
+    // C++ wrapper type for IfcSolidOrShell
+    typedef SELECT IfcSolidOrShell;
+    // C++ wrapper type for IfcSpaceBoundarySelect
+    typedef SELECT IfcSpaceBoundarySelect;
+    // C++ wrapper type for IfcSpecularHighlightSelect
+    typedef SELECT IfcSpecularHighlightSelect;
+    // C++ wrapper type for IfcStructuralActivityAssignmentSelect
+    typedef SELECT IfcStructuralActivityAssignmentSelect;
+    // C++ wrapper type for IfcStyleAssignmentSelect
+    typedef SELECT IfcStyleAssignmentSelect;
+    // C++ wrapper type for IfcSurfaceOrFaceSurface
+    typedef SELECT IfcSurfaceOrFaceSurface;
+    // C++ wrapper type for IfcSurfaceStyleElementSelect
+    typedef SELECT IfcSurfaceStyleElementSelect;
+    // C++ wrapper type for IfcTextFontSelect
+    typedef SELECT IfcTextFontSelect;
+    // C++ wrapper type for IfcTimeOrRatioSelect
+    typedef SELECT IfcTimeOrRatioSelect;
+    // C++ wrapper type for IfcTranslationalStiffnessSelect
+    typedef SELECT IfcTranslationalStiffnessSelect;
+    // C++ wrapper type for IfcTrimmingSelect
+    typedef SELECT IfcTrimmingSelect;
+    // C++ wrapper type for IfcUnit
+    typedef SELECT IfcUnit;
+    // C++ wrapper type for IfcValue
+    typedef SELECT IfcValue;
+    // C++ wrapper type for IfcVectorOrDirection
+    typedef SELECT IfcVectorOrDirection;
+    // C++ wrapper type for IfcWarpingStiffnessSelect
+    typedef SELECT IfcWarpingStiffnessSelect;
+
+
+	// ******************************************************************************
+	// IFC Entities
+	// ******************************************************************************
+
+	struct IfcRoot;
+	struct IfcObjectDefinition;
+	struct IfcObject;
+	struct IfcControl;
+	struct IfcActionRequest;
+	struct IfcActor;
+	typedef NotImplemented IfcActorRole; // (not currently used by Assimp)
+	struct IfcProduct;
+	struct IfcElement;
+	struct IfcDistributionElement;
+	struct IfcDistributionControlElement;
+	struct IfcActuator;
+	struct IfcTypeObject;
+	struct IfcTypeProduct;
+	struct IfcElementType;
+	struct IfcDistributionElementType;
+	struct IfcDistributionControlElementType;
+	struct IfcActuatorType;
+	typedef NotImplemented IfcAddress; // (not currently used by Assimp)
+	struct IfcRepresentationItem;
+	struct IfcGeometricRepresentationItem;
+	struct IfcSolidModel;
+	struct IfcManifoldSolidBrep;
+	struct IfcAdvancedBrep;
+	struct IfcAdvancedBrepWithVoids;
+	struct IfcTopologicalRepresentationItem;
+	struct IfcFace;
+	struct IfcFaceSurface;
+	struct IfcAdvancedFace;
+	struct IfcDistributionFlowElement;
+	struct IfcFlowTerminal;
+	struct IfcAirTerminal;
+	struct IfcFlowController;
+	struct IfcAirTerminalBox;
+	struct IfcDistributionFlowElementType;
+	struct IfcFlowControllerType;
+	struct IfcAirTerminalBoxType;
+	struct IfcFlowTerminalType;
+	struct IfcAirTerminalType;
+	struct IfcEnergyConversionDevice;
+	struct IfcAirToAirHeatRecovery;
+	struct IfcEnergyConversionDeviceType;
+	struct IfcAirToAirHeatRecoveryType;
+	struct IfcAlarm;
+	struct IfcAlarmType;
+	struct IfcAnnotation;
+	struct IfcAnnotationFillArea;
+	typedef NotImplemented IfcApplication; // (not currently used by Assimp)
+	typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp)
+	typedef NotImplemented IfcApproval; // (not currently used by Assimp)
+	typedef NotImplemented IfcResourceLevelRelationship; // (not currently used by Assimp)
+	typedef NotImplemented IfcApprovalRelationship; // (not currently used by Assimp)
+	struct IfcProfileDef;
+	struct IfcArbitraryClosedProfileDef;
+	struct IfcArbitraryOpenProfileDef;
+	struct IfcArbitraryProfileDefWithVoids;
+	struct IfcGroup;
+	struct IfcAsset;
+	struct IfcParameterizedProfileDef;
+	struct IfcAsymmetricIShapeProfileDef;
+	struct IfcAudioVisualAppliance;
+	struct IfcAudioVisualApplianceType;
+	struct IfcPlacement;
+	struct IfcAxis1Placement;
+	struct IfcAxis2Placement2D;
+	struct IfcAxis2Placement3D;
+	struct IfcCurve;
+	struct IfcBoundedCurve;
+	struct IfcBSplineCurve;
+	struct IfcBSplineCurveWithKnots;
+	struct IfcSurface;
+	struct IfcBoundedSurface;
+	struct IfcBSplineSurface;
+	struct IfcBSplineSurfaceWithKnots;
+	struct IfcBuildingElement;
+	struct IfcBeam;
+	struct IfcBeamStandardCase;
+	struct IfcBuildingElementType;
+	struct IfcBeamType;
+	struct IfcPresentationItem;
+	typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp)
+	typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp)
+	struct IfcCsgPrimitive3D;
+	struct IfcBlock;
+	struct IfcBoiler;
+	struct IfcBoilerType;
+	struct IfcBooleanResult;
+	struct IfcBooleanClippingResult;
+	typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp)
+	struct IfcCompositeCurve;
+	struct IfcCompositeCurveOnSurface;
+	struct IfcBoundaryCurve;
+	typedef NotImplemented IfcBoundaryEdgeCondition; // (not currently used by Assimp)
+	typedef NotImplemented IfcBoundaryFaceCondition; // (not currently used by Assimp)
+	typedef NotImplemented IfcBoundaryNodeCondition; // (not currently used by Assimp)
+	typedef NotImplemented IfcBoundaryNodeConditionWarping; // (not currently used by Assimp)
+	struct IfcBoundingBox;
+	struct IfcHalfSpaceSolid;
+	struct IfcBoxedHalfSpace;
+	struct IfcSpatialElement;
+	struct IfcSpatialStructureElement;
+	struct IfcBuilding;
+	struct IfcElementComponent;
+	struct IfcBuildingElementPart;
+	struct IfcElementComponentType;
+	struct IfcBuildingElementPartType;
+	struct IfcBuildingElementProxy;
+	struct IfcBuildingElementProxyType;
+	struct IfcBuildingStorey;
+	struct IfcSystem;
+	struct IfcBuildingSystem;
+	struct IfcBurner;
+	struct IfcBurnerType;
+	struct IfcCShapeProfileDef;
+	struct IfcFlowFitting;
+	struct IfcCableCarrierFitting;
+	struct IfcFlowFittingType;
+	struct IfcCableCarrierFittingType;
+	struct IfcFlowSegment;
+	struct IfcCableCarrierSegment;
+	struct IfcFlowSegmentType;
+	struct IfcCableCarrierSegmentType;
+	struct IfcCableFitting;
+	struct IfcCableFittingType;
+	struct IfcCableSegment;
+	struct IfcCableSegmentType;
+	struct IfcPoint;
+	struct IfcCartesianPoint;
+	struct IfcCartesianPointList;
+	struct IfcCartesianPointList2D;
+	struct IfcCartesianPointList3D;
+	struct IfcCartesianTransformationOperator;
+	struct IfcCartesianTransformationOperator2D;
+	struct IfcCartesianTransformationOperator2DnonUniform;
+	struct IfcCartesianTransformationOperator3D;
+	struct IfcCartesianTransformationOperator3DnonUniform;
+	struct IfcCenterLineProfileDef;
+	struct IfcChiller;
+	struct IfcChillerType;
+	struct IfcChimney;
+	struct IfcChimneyType;
+	struct IfcConic;
+	struct IfcCircle;
+	struct IfcCircleProfileDef;
+	struct IfcCircleHollowProfileDef;
+	struct IfcCivilElement;
+	struct IfcCivilElementType;
+	typedef NotImplemented IfcExternalInformation; // (not currently used by Assimp)
+	typedef NotImplemented IfcClassification; // (not currently used by Assimp)
+	typedef NotImplemented IfcExternalReference; // (not currently used by Assimp)
+	typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp)
+	struct IfcConnectedFaceSet;
+	struct IfcClosedShell;
+	struct IfcCoil;
+	struct IfcCoilType;
+	struct IfcColourSpecification;
+	struct IfcColourRgb;
+	typedef NotImplemented IfcColourRgbList; // (not currently used by Assimp)
+	struct IfcColumn;
+	struct IfcColumnStandardCase;
+	struct IfcColumnType;
+	struct IfcCommunicationsAppliance;
+	struct IfcCommunicationsApplianceType;
+	struct IfcPropertyAbstraction;
+	struct IfcProperty;
+	struct IfcComplexProperty;
+	struct IfcPropertyDefinition;
+	typedef NotImplemented IfcPropertyTemplateDefinition; // (not currently used by Assimp)
+	typedef NotImplemented IfcPropertyTemplate; // (not currently used by Assimp)
+	typedef NotImplemented IfcComplexPropertyTemplate; // (not currently used by Assimp)
+	struct IfcCompositeCurveSegment;
+	struct IfcCompositeProfileDef;
+	struct IfcFlowMovingDevice;
+	struct IfcCompressor;
+	struct IfcFlowMovingDeviceType;
+	struct IfcCompressorType;
+	struct IfcCondenser;
+	struct IfcCondenserType;
+	typedef NotImplemented IfcConnectionGeometry; // (not currently used by Assimp)
+	typedef NotImplemented IfcConnectionCurveGeometry; // (not currently used by Assimp)
+	typedef NotImplemented IfcConnectionPointGeometry; // (not currently used by Assimp)
+	typedef NotImplemented IfcConnectionPointEccentricity; // (not currently used by Assimp)
+	typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp)
+	typedef NotImplemented IfcConnectionVolumeGeometry; // (not currently used by Assimp)
+	typedef NotImplemented IfcConstraint; // (not currently used by Assimp)
+	struct IfcResource;
+	struct IfcConstructionResource;
+	struct IfcConstructionEquipmentResource;
+	struct IfcTypeResource;
+	struct IfcConstructionResourceType;
+	struct IfcConstructionEquipmentResourceType;
+	struct IfcConstructionMaterialResource;
+	struct IfcConstructionMaterialResourceType;
+	struct IfcConstructionProductResource;
+	struct IfcConstructionProductResourceType;
+	struct IfcContext;
+	struct IfcNamedUnit;
+	struct IfcContextDependentUnit;
+	struct IfcController;
+	struct IfcControllerType;
+	struct IfcConversionBasedUnit;
+	struct IfcConversionBasedUnitWithOffset;
+	struct IfcCooledBeam;
+	struct IfcCooledBeamType;
+	struct IfcCoolingTower;
+	struct IfcCoolingTowerType;
+	typedef NotImplemented IfcCoordinateOperation; // (not currently used by Assimp)
+	typedef NotImplemented IfcCoordinateReferenceSystem; // (not currently used by Assimp)
+	struct IfcCostItem;
+	struct IfcCostSchedule;
+	typedef NotImplemented IfcCostValue; // (not currently used by Assimp)
+	struct IfcCovering;
+	struct IfcCoveringType;
+	struct IfcCrewResource;
+	struct IfcCrewResourceType;
+	struct IfcCsgSolid;
+	typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp)
+	struct IfcCurtainWall;
+	struct IfcCurtainWallType;
+	struct IfcCurveBoundedPlane;
+	struct IfcCurveBoundedSurface;
+	struct IfcPresentationStyle;
+	typedef NotImplemented IfcCurveStyle; // (not currently used by Assimp)
+	typedef NotImplemented IfcCurveStyleFont; // (not currently used by Assimp)
+	typedef NotImplemented IfcCurveStyleFontAndScaling; // (not currently used by Assimp)
+	typedef NotImplemented IfcCurveStyleFontPattern; // (not currently used by Assimp)
+	struct IfcElementarySurface;
+	struct IfcCylindricalSurface;
+	struct IfcDamper;
+	struct IfcDamperType;
+	struct IfcDerivedProfileDef;
+	typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp)
+	typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp)
+	typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp)
+	struct IfcDirection;
+	struct IfcDiscreteAccessory;
+	struct IfcDiscreteAccessoryType;
+	struct IfcDistributionChamberElement;
+	struct IfcDistributionChamberElementType;
+	struct IfcDistributionSystem;
+	struct IfcDistributionCircuit;
+	struct IfcPort;
+	struct IfcDistributionPort;
+	typedef NotImplemented IfcDocumentInformation; // (not currently used by Assimp)
+	typedef NotImplemented IfcDocumentInformationRelationship; // (not currently used by Assimp)
+	typedef NotImplemented IfcDocumentReference; // (not currently used by Assimp)
+	struct IfcDoor;
+	struct IfcPropertySetDefinition;
+	typedef NotImplemented IfcPreDefinedPropertySet; // (not currently used by Assimp)
+	typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp)
+	struct IfcDoorStandardCase;
+	struct IfcDoorStyle;
+	struct IfcDoorType;
+	typedef NotImplemented IfcPreDefinedItem; // (not currently used by Assimp)
+	typedef NotImplemented IfcPreDefinedColour; // (not currently used by Assimp)
+	typedef NotImplemented IfcDraughtingPreDefinedColour; // (not currently used by Assimp)
+	typedef NotImplemented IfcPreDefinedCurveFont; // (not currently used by Assimp)
+	typedef NotImplemented IfcDraughtingPreDefinedCurveFont; // (not currently used by Assimp)
+	struct IfcDuctFitting;
+	struct IfcDuctFittingType;
+	struct IfcDuctSegment;
+	struct IfcDuctSegmentType;
+	struct IfcFlowTreatmentDevice;
+	struct IfcDuctSilencer;
+	struct IfcFlowTreatmentDeviceType;
+	struct IfcDuctSilencerType;
+	struct IfcEdge;
+	struct IfcEdgeCurve;
+	struct IfcLoop;
+	struct IfcEdgeLoop;
+	struct IfcElectricAppliance;
+	struct IfcElectricApplianceType;
+	struct IfcElectricDistributionBoard;
+	struct IfcElectricDistributionBoardType;
+	struct IfcFlowStorageDevice;
+	struct IfcElectricFlowStorageDevice;
+	struct IfcFlowStorageDeviceType;
+	struct IfcElectricFlowStorageDeviceType;
+	struct IfcElectricGenerator;
+	struct IfcElectricGeneratorType;
+	struct IfcElectricMotor;
+	struct IfcElectricMotorType;
+	struct IfcElectricTimeControl;
+	struct IfcElectricTimeControlType;
+	struct IfcElementAssembly;
+	struct IfcElementAssemblyType;
+	struct IfcQuantitySet;
+	struct IfcElementQuantity;
+	struct IfcEllipse;
+	struct IfcEllipseProfileDef;
+	struct IfcEngine;
+	struct IfcEngineType;
+	struct IfcEvaporativeCooler;
+	struct IfcEvaporativeCoolerType;
+	struct IfcEvaporator;
+	struct IfcEvaporatorType;
+	struct IfcProcess;
+	struct IfcEvent;
+	typedef NotImplemented IfcSchedulingTime; // (not currently used by Assimp)
+	typedef NotImplemented IfcEventTime; // (not currently used by Assimp)
+	struct IfcTypeProcess;
+	struct IfcEventType;
+	typedef NotImplemented IfcExtendedProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcExternalReferenceRelationship; // (not currently used by Assimp)
+	struct IfcExternalSpatialStructureElement;
+	struct IfcExternalSpatialElement;
+	typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp)
+	typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp)
+	typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp)
+	struct IfcSweptAreaSolid;
+	struct IfcExtrudedAreaSolid;
+	struct IfcExtrudedAreaSolidTapered;
+	struct IfcFaceBasedSurfaceModel;
+	struct IfcFaceBound;
+	struct IfcFaceOuterBound;
+	struct IfcFacetedBrep;
+	struct IfcFacetedBrepWithVoids;
+	typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp)
+	typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp)
+	struct IfcFan;
+	struct IfcFanType;
+	struct IfcFastener;
+	struct IfcFastenerType;
+	struct IfcFeatureElement;
+	struct IfcFeatureElementAddition;
+	struct IfcFeatureElementSubtraction;
+	typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp)
+	struct IfcFillAreaStyleHatching;
+	struct IfcFillAreaStyleTiles;
+	struct IfcFilter;
+	struct IfcFilterType;
+	struct IfcFireSuppressionTerminal;
+	struct IfcFireSuppressionTerminalType;
+	struct IfcFixedReferenceSweptAreaSolid;
+	struct IfcFlowInstrument;
+	struct IfcFlowInstrumentType;
+	struct IfcFlowMeter;
+	struct IfcFlowMeterType;
+	struct IfcFooting;
+	struct IfcFootingType;
+	struct IfcFurnishingElement;
+	struct IfcFurnishingElementType;
+	struct IfcFurniture;
+	struct IfcFurnitureType;
+	struct IfcGeographicElement;
+	struct IfcGeographicElementType;
+	struct IfcGeometricSet;
+	struct IfcGeometricCurveSet;
+	struct IfcRepresentationContext;
+	struct IfcGeometricRepresentationContext;
+	struct IfcGeometricRepresentationSubContext;
+	struct IfcGrid;
+	typedef NotImplemented IfcGridAxis; // (not currently used by Assimp)
+	struct IfcObjectPlacement;
+	struct IfcGridPlacement;
+	struct IfcHeatExchanger;
+	struct IfcHeatExchangerType;
+	struct IfcHumidifier;
+	struct IfcHumidifierType;
+	struct IfcIShapeProfileDef;
+	typedef NotImplemented IfcImageTexture; // (not currently used by Assimp)
+	typedef NotImplemented IfcIndexedColourMap; // (not currently used by Assimp)
+	struct IfcIndexedPolyCurve;
+	struct IfcTessellatedItem;
+	struct IfcIndexedPolygonalFace;
+	struct IfcIndexedPolygonalFaceWithVoids;
+	typedef NotImplemented IfcTextureCoordinate; // (not currently used by Assimp)
+	typedef NotImplemented IfcIndexedTextureMap; // (not currently used by Assimp)
+	typedef NotImplemented IfcIndexedTriangleTextureMap; // (not currently used by Assimp)
+	struct IfcInterceptor;
+	struct IfcInterceptorType;
+	struct IfcSurfaceCurve;
+	struct IfcIntersectionCurve;
+	struct IfcInventory;
+	typedef NotImplemented IfcTimeSeries; // (not currently used by Assimp)
+	typedef NotImplemented IfcIrregularTimeSeries; // (not currently used by Assimp)
+	typedef NotImplemented IfcIrregularTimeSeriesValue; // (not currently used by Assimp)
+	struct IfcJunctionBox;
+	struct IfcJunctionBoxType;
+	struct IfcLShapeProfileDef;
+	struct IfcLaborResource;
+	struct IfcLaborResourceType;
+	typedef NotImplemented IfcLagTime; // (not currently used by Assimp)
+	struct IfcLamp;
+	struct IfcLampType;
+	typedef NotImplemented IfcLibraryInformation; // (not currently used by Assimp)
+	typedef NotImplemented IfcLibraryReference; // (not currently used by Assimp)
+	typedef NotImplemented IfcLightDistributionData; // (not currently used by Assimp)
+	struct IfcLightFixture;
+	struct IfcLightFixtureType;
+	typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp)
+	struct IfcLightSource;
+	struct IfcLightSourceAmbient;
+	struct IfcLightSourceDirectional;
+	struct IfcLightSourceGoniometric;
+	struct IfcLightSourcePositional;
+	struct IfcLightSourceSpot;
+	struct IfcLine;
+	struct IfcLocalPlacement;
+	typedef NotImplemented IfcMapConversion; // (not currently used by Assimp)
+	struct IfcMappedItem;
+	typedef NotImplemented IfcMaterialDefinition; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterial; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialClassificationRelationship; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialConstituent; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialConstituentSet; // (not currently used by Assimp)
+	struct IfcProductRepresentation;
+	struct IfcMaterialDefinitionRepresentation;
+	typedef NotImplemented IfcMaterialLayer; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialLayerSet; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialUsageDefinition; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialLayerSetUsage; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialLayerWithOffsets; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialList; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialProfile; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialProfileSet; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialProfileSetUsage; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialProfileSetUsageTapering; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialProfileWithOffsets; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcMaterialRelationship; // (not currently used by Assimp)
+	struct IfcMeasureWithUnit;
+	struct IfcMechanicalFastener;
+	struct IfcMechanicalFastenerType;
+	struct IfcMedicalDevice;
+	struct IfcMedicalDeviceType;
+	struct IfcMember;
+	struct IfcMemberStandardCase;
+	struct IfcMemberType;
+	typedef NotImplemented IfcMetric; // (not currently used by Assimp)
+	struct IfcMirroredProfileDef;
+	typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp)
+	struct IfcMotorConnection;
+	struct IfcMotorConnectionType;
+	typedef NotImplemented IfcObjective; // (not currently used by Assimp)
+	struct IfcOccupant;
+	struct IfcOffsetCurve2D;
+	struct IfcOffsetCurve3D;
+	struct IfcOpenShell;
+	struct IfcOpeningElement;
+	struct IfcOpeningStandardCase;
+	typedef NotImplemented IfcOrganization; // (not currently used by Assimp)
+	typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp)
+	struct IfcOrientedEdge;
+	struct IfcOuterBoundaryCurve;
+	struct IfcOutlet;
+	struct IfcOutletType;
+	typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp)
+	struct IfcPath;
+	struct IfcPcurve;
+	struct IfcPerformanceHistory;
+	typedef NotImplemented IfcPermeableCoveringProperties; // (not currently used by Assimp)
+	struct IfcPermit;
+	typedef NotImplemented IfcPerson; // (not currently used by Assimp)
+	typedef NotImplemented IfcPersonAndOrganization; // (not currently used by Assimp)
+	typedef NotImplemented IfcPhysicalQuantity; // (not currently used by Assimp)
+	typedef NotImplemented IfcPhysicalComplexQuantity; // (not currently used by Assimp)
+	typedef NotImplemented IfcPhysicalSimpleQuantity; // (not currently used by Assimp)
+	struct IfcPile;
+	struct IfcPileType;
+	struct IfcPipeFitting;
+	struct IfcPipeFittingType;
+	struct IfcPipeSegment;
+	struct IfcPipeSegmentType;
+	typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp)
+	struct IfcPlanarExtent;
+	struct IfcPlanarBox;
+	struct IfcPlane;
+	struct IfcPlate;
+	struct IfcPlateStandardCase;
+	struct IfcPlateType;
+	struct IfcPointOnCurve;
+	struct IfcPointOnSurface;
+	struct IfcPolyLoop;
+	struct IfcPolygonalBoundedHalfSpace;
+	struct IfcTessellatedFaceSet;
+	struct IfcPolygonalFaceSet;
+	struct IfcPolyline;
+	typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp)
+	typedef NotImplemented IfcPreDefinedProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp)
+	typedef NotImplemented IfcPresentationLayerAssignment; // (not currently used by Assimp)
+	typedef NotImplemented IfcPresentationLayerWithStyle; // (not currently used by Assimp)
+	struct IfcPresentationStyleAssignment;
+	struct IfcProcedure;
+	struct IfcProcedureType;
+	struct IfcProductDefinitionShape;
+	typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp)
+	struct IfcProject;
+	struct IfcProjectLibrary;
+	struct IfcProjectOrder;
+	typedef NotImplemented IfcProjectedCRS; // (not currently used by Assimp)
+	struct IfcProjectionElement;
+	struct IfcSimpleProperty;
+	struct IfcPropertyBoundedValue;
+	typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp)
+	struct IfcPropertyEnumeratedValue;
+	typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp)
+	struct IfcPropertyListValue;
+	struct IfcPropertyReferenceValue;
+	struct IfcPropertySet;
+	typedef NotImplemented IfcPropertySetTemplate; // (not currently used by Assimp)
+	struct IfcPropertySingleValue;
+	struct IfcPropertyTableValue;
+	struct IfcProtectiveDevice;
+	struct IfcProtectiveDeviceTrippingUnit;
+	struct IfcProtectiveDeviceTrippingUnitType;
+	struct IfcProtectiveDeviceType;
+	struct IfcProxy;
+	struct IfcPump;
+	struct IfcPumpType;
+	typedef NotImplemented IfcQuantityArea; // (not currently used by Assimp)
+	typedef NotImplemented IfcQuantityCount; // (not currently used by Assimp)
+	typedef NotImplemented IfcQuantityLength; // (not currently used by Assimp)
+	typedef NotImplemented IfcQuantityTime; // (not currently used by Assimp)
+	typedef NotImplemented IfcQuantityVolume; // (not currently used by Assimp)
+	typedef NotImplemented IfcQuantityWeight; // (not currently used by Assimp)
+	struct IfcRailing;
+	struct IfcRailingType;
+	struct IfcRamp;
+	struct IfcRampFlight;
+	struct IfcRampFlightType;
+	struct IfcRampType;
+	struct IfcRationalBSplineCurveWithKnots;
+	struct IfcRationalBSplineSurfaceWithKnots;
+	struct IfcRectangleProfileDef;
+	struct IfcRectangleHollowProfileDef;
+	struct IfcRectangularPyramid;
+	struct IfcRectangularTrimmedSurface;
+	typedef NotImplemented IfcRecurrencePattern; // (not currently used by Assimp)
+	typedef NotImplemented IfcReference; // (not currently used by Assimp)
+	typedef NotImplemented IfcRegularTimeSeries; // (not currently used by Assimp)
+	typedef NotImplemented IfcReinforcementBarProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcReinforcementDefinitionProperties; // (not currently used by Assimp)
+	struct IfcReinforcingElement;
+	struct IfcReinforcingBar;
+	struct IfcReinforcingElementType;
+	struct IfcReinforcingBarType;
+	struct IfcReinforcingMesh;
+	struct IfcReinforcingMeshType;
+	struct IfcRelationship;
+	struct IfcRelDecomposes;
+	struct IfcRelAggregates;
+	typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToGroupByFactor; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociatesApproval; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociatesClassification; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociatesConstraint; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociatesDocument; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociatesLibrary; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelAssociatesMaterial; // (not currently used by Assimp)
+	struct IfcRelConnects;
+	typedef NotImplemented IfcRelConnectsElements; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsPathElements; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsPortToElement; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsPorts; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsStructuralActivity; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsStructuralMember; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsWithEccentricity; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelConnectsWithRealizingElements; // (not currently used by Assimp)
+	struct IfcRelContainedInSpatialStructure;
+	typedef NotImplemented IfcRelCoversBldgElements; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelCoversSpaces; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelDeclares; // (not currently used by Assimp)
+	struct IfcRelDefines;
+	typedef NotImplemented IfcRelDefinesByObject; // (not currently used by Assimp)
+	struct IfcRelDefinesByProperties;
+	typedef NotImplemented IfcRelDefinesByTemplate; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp)
+	struct IfcRelFillsElement;
+	typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelInterferesElements; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelNests; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelSequence; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelServicesBuildings; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelSpaceBoundary; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelSpaceBoundary1stLevel; // (not currently used by Assimp)
+	typedef NotImplemented IfcRelSpaceBoundary2ndLevel; // (not currently used by Assimp)
+	struct IfcRelVoidsElement;
+	struct IfcReparametrisedCompositeCurveSegment;
+	struct IfcRepresentation;
+	struct IfcRepresentationMap;
+	typedef NotImplemented IfcResourceApprovalRelationship; // (not currently used by Assimp)
+	typedef NotImplemented IfcResourceConstraintRelationship; // (not currently used by Assimp)
+	typedef NotImplemented IfcResourceTime; // (not currently used by Assimp)
+	struct IfcRevolvedAreaSolid;
+	struct IfcRevolvedAreaSolidTapered;
+	struct IfcRightCircularCone;
+	struct IfcRightCircularCylinder;
+	struct IfcRoof;
+	struct IfcRoofType;
+	struct IfcRoundedRectangleProfileDef;
+	struct IfcSIUnit;
+	struct IfcSanitaryTerminal;
+	struct IfcSanitaryTerminalType;
+	struct IfcSeamCurve;
+	typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp)
+	struct IfcSectionedSpine;
+	struct IfcSensor;
+	struct IfcSensorType;
+	struct IfcShadingDevice;
+	struct IfcShadingDeviceType;
+	typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp)
+	struct IfcShapeModel;
+	struct IfcShapeRepresentation;
+	struct IfcShellBasedSurfaceModel;
+	typedef NotImplemented IfcSimplePropertyTemplate; // (not currently used by Assimp)
+	struct IfcSite;
+	struct IfcSlab;
+	struct IfcSlabElementedCase;
+	struct IfcSlabStandardCase;
+	struct IfcSlabType;
+	typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp)
+	struct IfcSolarDevice;
+	struct IfcSolarDeviceType;
+	struct IfcSpace;
+	struct IfcSpaceHeater;
+	struct IfcSpaceHeaterType;
+	struct IfcSpatialElementType;
+	struct IfcSpatialStructureElementType;
+	struct IfcSpaceType;
+	struct IfcSpatialZone;
+	struct IfcSpatialZoneType;
+	struct IfcSphere;
+	struct IfcSphericalSurface;
+	struct IfcStackTerminal;
+	struct IfcStackTerminalType;
+	struct IfcStair;
+	struct IfcStairFlight;
+	struct IfcStairFlightType;
+	struct IfcStairType;
+	struct IfcStructuralActivity;
+	struct IfcStructuralAction;
+	struct IfcStructuralAnalysisModel;
+	struct IfcStructuralItem;
+	struct IfcStructuralConnection;
+	struct IfcStructuralCurveAction;
+	struct IfcStructuralCurveConnection;
+	struct IfcStructuralMember;
+	struct IfcStructuralCurveMember;
+	struct IfcStructuralCurveMemberVarying;
+	struct IfcStructuralReaction;
+	struct IfcStructuralCurveReaction;
+	struct IfcStructuralLinearAction;
+	typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp)
+	struct IfcStructuralLoadGroup;
+	struct IfcStructuralLoadCase;
+	typedef NotImplemented IfcStructuralLoadConfiguration; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadOrResult; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadStatic; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadLinearForce; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadPlanarForce; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadSingleDisplacement; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadSingleDisplacementDistortion; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadSingleForce; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadSingleForceWarping; // (not currently used by Assimp)
+	typedef NotImplemented IfcStructuralLoadTemperature; // (not currently used by Assimp)
+	struct IfcStructuralSurfaceAction;
+	struct IfcStructuralPlanarAction;
+	struct IfcStructuralPointAction;
+	struct IfcStructuralPointConnection;
+	struct IfcStructuralPointReaction;
+	struct IfcStructuralResultGroup;
+	struct IfcStructuralSurfaceConnection;
+	struct IfcStructuralSurfaceMember;
+	struct IfcStructuralSurfaceMemberVarying;
+	struct IfcStructuralSurfaceReaction;
+	struct IfcStyleModel;
+	struct IfcStyledItem;
+	struct IfcStyledRepresentation;
+	struct IfcSubContractResource;
+	struct IfcSubContractResourceType;
+	struct IfcSubedge;
+	struct IfcSurfaceCurveSweptAreaSolid;
+	struct IfcSurfaceFeature;
+	struct IfcSweptSurface;
+	struct IfcSurfaceOfLinearExtrusion;
+	struct IfcSurfaceOfRevolution;
+	typedef NotImplemented IfcSurfaceReinforcementArea; // (not currently used by Assimp)
+	struct IfcSurfaceStyle;
+	typedef NotImplemented IfcSurfaceStyleLighting; // (not currently used by Assimp)
+	typedef NotImplemented IfcSurfaceStyleRefraction; // (not currently used by Assimp)
+	struct IfcSurfaceStyleShading;
+	struct IfcSurfaceStyleRendering;
+	struct IfcSurfaceStyleWithTextures;
+	struct IfcSweptDiskSolid;
+	struct IfcSweptDiskSolidPolygonal;
+	struct IfcSwitchingDevice;
+	struct IfcSwitchingDeviceType;
+	struct IfcSystemFurnitureElement;
+	struct IfcSystemFurnitureElementType;
+	struct IfcTShapeProfileDef;
+	typedef NotImplemented IfcTable; // (not currently used by Assimp)
+	typedef NotImplemented IfcTableColumn; // (not currently used by Assimp)
+	typedef NotImplemented IfcTableRow; // (not currently used by Assimp)
+	struct IfcTank;
+	struct IfcTankType;
+	struct IfcTask;
+	typedef NotImplemented IfcTaskTime; // (not currently used by Assimp)
+	typedef NotImplemented IfcTaskTimeRecurring; // (not currently used by Assimp)
+	struct IfcTaskType;
+	typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp)
+	struct IfcTendon;
+	struct IfcTendonAnchor;
+	struct IfcTendonAnchorType;
+	struct IfcTendonType;
+	struct IfcTextLiteral;
+	struct IfcTextLiteralWithExtent;
+	typedef NotImplemented IfcTextStyle; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextStyleFontModel; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextStyleForDefinedFont; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextStyleTextModel; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextureCoordinateGenerator; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextureMap; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextureVertex; // (not currently used by Assimp)
+	typedef NotImplemented IfcTextureVertexList; // (not currently used by Assimp)
+	typedef NotImplemented IfcTimePeriod; // (not currently used by Assimp)
+	typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp)
+	struct IfcTopologyRepresentation;
+	struct IfcToroidalSurface;
+	struct IfcTransformer;
+	struct IfcTransformerType;
+	struct IfcTransportElement;
+	struct IfcTransportElementType;
+	struct IfcTrapeziumProfileDef;
+	struct IfcTriangulatedFaceSet;
+	struct IfcTrimmedCurve;
+	struct IfcTubeBundle;
+	struct IfcTubeBundleType;
+	struct IfcUShapeProfileDef;
+	struct IfcUnitAssignment;
+	struct IfcUnitaryControlElement;
+	struct IfcUnitaryControlElementType;
+	struct IfcUnitaryEquipment;
+	struct IfcUnitaryEquipmentType;
+	struct IfcValve;
+	struct IfcValveType;
+	struct IfcVector;
+	struct IfcVertex;
+	struct IfcVertexLoop;
+	struct IfcVertexPoint;
+	struct IfcVibrationIsolator;
+	struct IfcVibrationIsolatorType;
+	struct IfcVirtualElement;
+	typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp)
+	struct IfcVoidingFeature;
+	struct IfcWall;
+	struct IfcWallElementedCase;
+	struct IfcWallStandardCase;
+	struct IfcWallType;
+	struct IfcWasteTerminal;
+	struct IfcWasteTerminalType;
+	struct IfcWindow;
+	typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp)
+	typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp)
+	struct IfcWindowStandardCase;
+	struct IfcWindowStyle;
+	struct IfcWindowType;
+	struct IfcWorkCalendar;
+	struct IfcWorkControl;
+	struct IfcWorkPlan;
+	struct IfcWorkSchedule;
+	typedef NotImplemented IfcWorkTime; // (not currently used by Assimp)
+	struct IfcZShapeProfileDef;
+	struct IfcZone;
+
+
+
+    // C++ wrapper for IfcRoot
+    struct IfcRoot :  ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {}
+		IfcGloballyUniqueId::Out GlobalId;
+		Maybe< Lazy< NotImplemented > > OwnerHistory;
+		Maybe< IfcLabel::Out > Name;
+		Maybe< IfcText::Out > Description;
+    };
+
+    // C++ wrapper for IfcObjectDefinition
+    struct IfcObjectDefinition : IfcRoot, ObjectHelper<IfcObjectDefinition,0> { IfcObjectDefinition() : Object("IfcObjectDefinition") {}
+
+    };
+
+    // C++ wrapper for IfcObject
+    struct IfcObject : IfcObjectDefinition, ObjectHelper<IfcObject,1> { IfcObject() : Object("IfcObject") {}
+		Maybe< IfcLabel::Out > ObjectType;
+    };
+
+    // C++ wrapper for IfcControl
+    struct IfcControl : IfcObject, ObjectHelper<IfcControl,1> { IfcControl() : Object("IfcControl") {}
+		Maybe< IfcIdentifier::Out > Identification;
+    };
+
+    // C++ wrapper for IfcActionRequest
+    struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,3> { IfcActionRequest() : Object("IfcActionRequest") {}
+		Maybe< IfcActionRequestTypeEnum::Out > PredefinedType;
+		Maybe< IfcLabel::Out > Status;
+		Maybe< IfcText::Out > LongDescription;
+    };
+
+    // C++ wrapper for IfcActor
+    struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {}
+		IfcActorSelect::Out TheActor;
+    };
+
+    // C++ wrapper for IfcProduct
+    struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {}
+		Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement;
+		Maybe< Lazy< IfcProductRepresentation > > Representation;
+    };
+
+    // C++ wrapper for IfcElement
+    struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {}
+		Maybe< IfcIdentifier::Out > Tag;
+    };
+
+    // C++ wrapper for IfcDistributionElement
+    struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionControlElement
+    struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,0> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {}
+
+    };
+
+    // C++ wrapper for IfcActuator
+    struct IfcActuator : IfcDistributionControlElement, ObjectHelper<IfcActuator,1> { IfcActuator() : Object("IfcActuator") {}
+		Maybe< IfcActuatorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTypeObject
+    struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {}
+		Maybe< IfcIdentifier::Out > ApplicableOccurrence;
+		Maybe< ListOf< Lazy< IfcPropertySetDefinition >, 1, 0 > > HasPropertySets;
+    };
+
+    // C++ wrapper for IfcTypeProduct
+    struct IfcTypeProduct : IfcTypeObject, ObjectHelper<IfcTypeProduct,2> { IfcTypeProduct() : Object("IfcTypeProduct") {}
+		Maybe< ListOf< Lazy< IfcRepresentationMap >, 1, 0 > > RepresentationMaps;
+		Maybe< IfcLabel::Out > Tag;
+    };
+
+    // C++ wrapper for IfcElementType
+    struct IfcElementType : IfcTypeProduct, ObjectHelper<IfcElementType,1> { IfcElementType() : Object("IfcElementType") {}
+		Maybe< IfcLabel::Out > ElementType;
+    };
+
+    // C++ wrapper for IfcDistributionElementType
+    struct IfcDistributionElementType : IfcElementType, ObjectHelper<IfcDistributionElementType,0> { IfcDistributionElementType() : Object("IfcDistributionElementType") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionControlElementType
+    struct IfcDistributionControlElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionControlElementType,0> { IfcDistributionControlElementType() : Object("IfcDistributionControlElementType") {}
+
+    };
+
+    // C++ wrapper for IfcActuatorType
+    struct IfcActuatorType : IfcDistributionControlElementType, ObjectHelper<IfcActuatorType,1> { IfcActuatorType() : Object("IfcActuatorType") {}
+		IfcActuatorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRepresentationItem
+    struct IfcRepresentationItem :  ObjectHelper<IfcRepresentationItem,0> { IfcRepresentationItem() : Object("IfcRepresentationItem") {}
+
+    };
+
+    // C++ wrapper for IfcGeometricRepresentationItem
+    struct IfcGeometricRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcGeometricRepresentationItem,0> { IfcGeometricRepresentationItem() : Object("IfcGeometricRepresentationItem") {}
+
+    };
+
+    // C++ wrapper for IfcSolidModel
+    struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {}
+
+    };
+
+    // C++ wrapper for IfcManifoldSolidBrep
+    struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {}
+		Lazy< IfcClosedShell > Outer;
+    };
+
+    // C++ wrapper for IfcAdvancedBrep
+    struct IfcAdvancedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcAdvancedBrep,0> { IfcAdvancedBrep() : Object("IfcAdvancedBrep") {}
+
+    };
+
+    // C++ wrapper for IfcAdvancedBrepWithVoids
+    struct IfcAdvancedBrepWithVoids : IfcAdvancedBrep, ObjectHelper<IfcAdvancedBrepWithVoids,1> { IfcAdvancedBrepWithVoids() : Object("IfcAdvancedBrepWithVoids") {}
+		ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
+    };
+
+    // C++ wrapper for IfcTopologicalRepresentationItem
+    struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {}
+
+    };
+
+    // C++ wrapper for IfcFace
+    struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {}
+		ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds;
+    };
+
+    // C++ wrapper for IfcFaceSurface
+    struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {}
+		Lazy< IfcSurface > FaceSurface;
+		IfcBoolean::Out SameSense;
+    };
+
+    // C++ wrapper for IfcAdvancedFace
+    struct IfcAdvancedFace : IfcFaceSurface, ObjectHelper<IfcAdvancedFace,0> { IfcAdvancedFace() : Object("IfcAdvancedFace") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionFlowElement
+    struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {}
+
+    };
+
+    // C++ wrapper for IfcFlowTerminal
+    struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {}
+
+    };
+
+    // C++ wrapper for IfcAirTerminal
+    struct IfcAirTerminal : IfcFlowTerminal, ObjectHelper<IfcAirTerminal,1> { IfcAirTerminal() : Object("IfcAirTerminal") {}
+		Maybe< IfcAirTerminalTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowController
+    struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {}
+
+    };
+
+    // C++ wrapper for IfcAirTerminalBox
+    struct IfcAirTerminalBox : IfcFlowController, ObjectHelper<IfcAirTerminalBox,1> { IfcAirTerminalBox() : Object("IfcAirTerminalBox") {}
+		Maybe< IfcAirTerminalBoxTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDistributionFlowElementType
+    struct IfcDistributionFlowElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionFlowElementType,0> { IfcDistributionFlowElementType() : Object("IfcDistributionFlowElementType") {}
+
+    };
+
+    // C++ wrapper for IfcFlowControllerType
+    struct IfcFlowControllerType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowControllerType,0> { IfcFlowControllerType() : Object("IfcFlowControllerType") {}
+
+    };
+
+    // C++ wrapper for IfcAirTerminalBoxType
+    struct IfcAirTerminalBoxType : IfcFlowControllerType, ObjectHelper<IfcAirTerminalBoxType,1> { IfcAirTerminalBoxType() : Object("IfcAirTerminalBoxType") {}
+		IfcAirTerminalBoxTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowTerminalType
+    struct IfcFlowTerminalType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTerminalType,0> { IfcFlowTerminalType() : Object("IfcFlowTerminalType") {}
+
+    };
+
+    // C++ wrapper for IfcAirTerminalType
+    struct IfcAirTerminalType : IfcFlowTerminalType, ObjectHelper<IfcAirTerminalType,1> { IfcAirTerminalType() : Object("IfcAirTerminalType") {}
+		IfcAirTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcEnergyConversionDevice
+    struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {}
+
+    };
+
+    // C++ wrapper for IfcAirToAirHeatRecovery
+    struct IfcAirToAirHeatRecovery : IfcEnergyConversionDevice, ObjectHelper<IfcAirToAirHeatRecovery,1> { IfcAirToAirHeatRecovery() : Object("IfcAirToAirHeatRecovery") {}
+		Maybe< IfcAirToAirHeatRecoveryTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcEnergyConversionDeviceType
+    struct IfcEnergyConversionDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcEnergyConversionDeviceType,0> { IfcEnergyConversionDeviceType() : Object("IfcEnergyConversionDeviceType") {}
+
+    };
+
+    // C++ wrapper for IfcAirToAirHeatRecoveryType
+    struct IfcAirToAirHeatRecoveryType : IfcEnergyConversionDeviceType, ObjectHelper<IfcAirToAirHeatRecoveryType,1> { IfcAirToAirHeatRecoveryType() : Object("IfcAirToAirHeatRecoveryType") {}
+		IfcAirToAirHeatRecoveryTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcAlarm
+    struct IfcAlarm : IfcDistributionControlElement, ObjectHelper<IfcAlarm,1> { IfcAlarm() : Object("IfcAlarm") {}
+		Maybe< IfcAlarmTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcAlarmType
+    struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {}
+		IfcAlarmTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcAnnotation
+    struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {}
+
+    };
+
+    // C++ wrapper for IfcAnnotationFillArea
+    struct IfcAnnotationFillArea : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationFillArea,2> { IfcAnnotationFillArea() : Object("IfcAnnotationFillArea") {}
+		Lazy< IfcCurve > OuterBoundary;
+		Maybe< ListOf< Lazy< IfcCurve >, 1, 0 > > InnerBoundaries;
+    };
+
+    // C++ wrapper for IfcProfileDef
+    struct IfcProfileDef :  ObjectHelper<IfcProfileDef,2> { IfcProfileDef() : Object("IfcProfileDef") {}
+		IfcProfileTypeEnum::Out ProfileType;
+		Maybe< IfcLabel::Out > ProfileName;
+    };
+
+    // C++ wrapper for IfcArbitraryClosedProfileDef
+    struct IfcArbitraryClosedProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryClosedProfileDef,1> { IfcArbitraryClosedProfileDef() : Object("IfcArbitraryClosedProfileDef") {}
+		Lazy< IfcCurve > OuterCurve;
+    };
+
+    // C++ wrapper for IfcArbitraryOpenProfileDef
+    struct IfcArbitraryOpenProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryOpenProfileDef,1> { IfcArbitraryOpenProfileDef() : Object("IfcArbitraryOpenProfileDef") {}
+		Lazy< IfcBoundedCurve > Curve;
+    };
+
+    // C++ wrapper for IfcArbitraryProfileDefWithVoids
+    struct IfcArbitraryProfileDefWithVoids : IfcArbitraryClosedProfileDef, ObjectHelper<IfcArbitraryProfileDefWithVoids,1> { IfcArbitraryProfileDefWithVoids() : Object("IfcArbitraryProfileDefWithVoids") {}
+		ListOf< Lazy< IfcCurve >, 1, 0 > InnerCurves;
+    };
+
+    // C++ wrapper for IfcGroup
+    struct IfcGroup : IfcObject, ObjectHelper<IfcGroup,0> { IfcGroup() : Object("IfcGroup") {}
+
+    };
+
+    // C++ wrapper for IfcAsset
+    struct IfcAsset : IfcGroup, ObjectHelper<IfcAsset,9> { IfcAsset() : Object("IfcAsset") {}
+		Maybe< IfcIdentifier::Out > Identification;
+		Maybe< Lazy< NotImplemented > > OriginalValue;
+		Maybe< Lazy< NotImplemented > > CurrentValue;
+		Maybe< Lazy< NotImplemented > > TotalReplacementCost;
+		Maybe< IfcActorSelect::Out > Owner;
+		Maybe< IfcActorSelect::Out > User;
+		Maybe< Lazy< NotImplemented > > ResponsiblePerson;
+		Maybe< IfcDate::Out > IncorporationDate;
+		Maybe< Lazy< NotImplemented > > DepreciatedValue;
+    };
+
+    // C++ wrapper for IfcParameterizedProfileDef
+    struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {}
+		Maybe< Lazy< IfcAxis2Placement2D > > Position;
+    };
+
+    // C++ wrapper for IfcAsymmetricIShapeProfileDef
+    struct IfcAsymmetricIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,12> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out BottomFlangeWidth;
+		IfcPositiveLengthMeasure::Out OverallDepth;
+		IfcPositiveLengthMeasure::Out WebThickness;
+		IfcPositiveLengthMeasure::Out BottomFlangeThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > BottomFlangeFilletRadius;
+		IfcPositiveLengthMeasure::Out TopFlangeWidth;
+		Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > TopFlangeFilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > BottomFlangeEdgeRadius;
+		Maybe< IfcPlaneAngleMeasure::Out > BottomFlangeSlope;
+		Maybe< IfcNonNegativeLengthMeasure::Out > TopFlangeEdgeRadius;
+		Maybe< IfcPlaneAngleMeasure::Out > TopFlangeSlope;
+    };
+
+    // C++ wrapper for IfcAudioVisualAppliance
+    struct IfcAudioVisualAppliance : IfcFlowTerminal, ObjectHelper<IfcAudioVisualAppliance,1> { IfcAudioVisualAppliance() : Object("IfcAudioVisualAppliance") {}
+		Maybe< IfcAudioVisualApplianceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcAudioVisualApplianceType
+    struct IfcAudioVisualApplianceType : IfcFlowTerminalType, ObjectHelper<IfcAudioVisualApplianceType,1> { IfcAudioVisualApplianceType() : Object("IfcAudioVisualApplianceType") {}
+		IfcAudioVisualApplianceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPlacement
+    struct IfcPlacement : IfcGeometricRepresentationItem, ObjectHelper<IfcPlacement,1> { IfcPlacement() : Object("IfcPlacement") {}
+		Lazy< IfcCartesianPoint > Location;
+    };
+
+    // C++ wrapper for IfcAxis1Placement
+    struct IfcAxis1Placement : IfcPlacement, ObjectHelper<IfcAxis1Placement,1> { IfcAxis1Placement() : Object("IfcAxis1Placement") {}
+		Maybe< Lazy< IfcDirection > > Axis;
+    };
+
+    // C++ wrapper for IfcAxis2Placement2D
+    struct IfcAxis2Placement2D : IfcPlacement, ObjectHelper<IfcAxis2Placement2D,1> { IfcAxis2Placement2D() : Object("IfcAxis2Placement2D") {}
+		Maybe< Lazy< IfcDirection > > RefDirection;
+    };
+
+    // C++ wrapper for IfcAxis2Placement3D
+    struct IfcAxis2Placement3D : IfcPlacement, ObjectHelper<IfcAxis2Placement3D,2> { IfcAxis2Placement3D() : Object("IfcAxis2Placement3D") {}
+		Maybe< Lazy< IfcDirection > > Axis;
+		Maybe< Lazy< IfcDirection > > RefDirection;
+    };
+
+    // C++ wrapper for IfcCurve
+    struct IfcCurve : IfcGeometricRepresentationItem, ObjectHelper<IfcCurve,0> { IfcCurve() : Object("IfcCurve") {}
+
+    };
+
+    // C++ wrapper for IfcBoundedCurve
+    struct IfcBoundedCurve : IfcCurve, ObjectHelper<IfcBoundedCurve,0> { IfcBoundedCurve() : Object("IfcBoundedCurve") {}
+
+    };
+
+    // C++ wrapper for IfcBSplineCurve
+    struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {}
+		IfcInteger::Out Degree;
+		ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList;
+		IfcBSplineCurveForm::Out CurveForm;
+		IfcLogical::Out ClosedCurve;
+		IfcLogical::Out SelfIntersect;
+    };
+
+    // C++ wrapper for IfcBSplineCurveWithKnots
+    struct IfcBSplineCurveWithKnots : IfcBSplineCurve, ObjectHelper<IfcBSplineCurveWithKnots,3> { IfcBSplineCurveWithKnots() : Object("IfcBSplineCurveWithKnots") {}
+		ListOf< IfcInteger, 2, 0 >::Out KnotMultiplicities;
+		ListOf< IfcParameterValue, 2, 0 >::Out Knots;
+		IfcKnotType::Out KnotSpec;
+    };
+
+    // C++ wrapper for IfcSurface
+    struct IfcSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcSurface,0> { IfcSurface() : Object("IfcSurface") {}
+
+    };
+
+    // C++ wrapper for IfcBoundedSurface
+    struct IfcBoundedSurface : IfcSurface, ObjectHelper<IfcBoundedSurface,0> { IfcBoundedSurface() : Object("IfcBoundedSurface") {}
+
+    };
+
+    // C++ wrapper for IfcBSplineSurface
+    struct IfcBSplineSurface : IfcBoundedSurface, ObjectHelper<IfcBSplineSurface,6> { IfcBSplineSurface() : Object("IfcBSplineSurface") {}
+		IfcInteger::Out UDegree;
+		IfcInteger::Out VDegree;
+		IfcBSplineSurfaceForm::Out SurfaceForm;
+		IfcLogical::Out UClosed;
+		IfcLogical::Out VClosed;
+		IfcLogical::Out SelfIntersect;
+    };
+
+    // C++ wrapper for IfcBSplineSurfaceWithKnots
+    struct IfcBSplineSurfaceWithKnots : IfcBSplineSurface, ObjectHelper<IfcBSplineSurfaceWithKnots,5> { IfcBSplineSurfaceWithKnots() : Object("IfcBSplineSurfaceWithKnots") {}
+		ListOf< IfcInteger, 2, 0 >::Out UMultiplicities;
+		ListOf< IfcInteger, 2, 0 >::Out VMultiplicities;
+		ListOf< IfcParameterValue, 2, 0 >::Out UKnots;
+		ListOf< IfcParameterValue, 2, 0 >::Out VKnots;
+		IfcKnotType::Out KnotSpec;
+    };
+
+    // C++ wrapper for IfcBuildingElement
+    struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {}
+
+    };
+
+    // C++ wrapper for IfcBeam
+    struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,1> { IfcBeam() : Object("IfcBeam") {}
+		Maybe< IfcBeamTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcBeamStandardCase
+    struct IfcBeamStandardCase : IfcBeam, ObjectHelper<IfcBeamStandardCase,0> { IfcBeamStandardCase() : Object("IfcBeamStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcBuildingElementType
+    struct IfcBuildingElementType : IfcElementType, ObjectHelper<IfcBuildingElementType,0> { IfcBuildingElementType() : Object("IfcBuildingElementType") {}
+
+    };
+
+    // C++ wrapper for IfcBeamType
+    struct IfcBeamType : IfcBuildingElementType, ObjectHelper<IfcBeamType,1> { IfcBeamType() : Object("IfcBeamType") {}
+		IfcBeamTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPresentationItem
+    struct IfcPresentationItem :  ObjectHelper<IfcPresentationItem,0> { IfcPresentationItem() : Object("IfcPresentationItem") {}
+
+    };
+
+    // C++ wrapper for IfcCsgPrimitive3D
+    struct IfcCsgPrimitive3D : IfcGeometricRepresentationItem, ObjectHelper<IfcCsgPrimitive3D,1> { IfcCsgPrimitive3D() : Object("IfcCsgPrimitive3D") {}
+		Lazy< IfcAxis2Placement3D > Position;
+    };
+
+    // C++ wrapper for IfcBlock
+    struct IfcBlock : IfcCsgPrimitive3D, ObjectHelper<IfcBlock,3> { IfcBlock() : Object("IfcBlock") {}
+		IfcPositiveLengthMeasure::Out XLength;
+		IfcPositiveLengthMeasure::Out YLength;
+		IfcPositiveLengthMeasure::Out ZLength;
+    };
+
+    // C++ wrapper for IfcBoiler
+    struct IfcBoiler : IfcEnergyConversionDevice, ObjectHelper<IfcBoiler,1> { IfcBoiler() : Object("IfcBoiler") {}
+		Maybe< IfcBoilerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcBoilerType
+    struct IfcBoilerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBoilerType,1> { IfcBoilerType() : Object("IfcBoilerType") {}
+		IfcBoilerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcBooleanResult
+    struct IfcBooleanResult : IfcGeometricRepresentationItem, ObjectHelper<IfcBooleanResult,3> { IfcBooleanResult() : Object("IfcBooleanResult") {}
+		IfcBooleanOperator::Out Operator;
+		IfcBooleanOperand::Out FirstOperand;
+		IfcBooleanOperand::Out SecondOperand;
+    };
+
+    // C++ wrapper for IfcBooleanClippingResult
+    struct IfcBooleanClippingResult : IfcBooleanResult, ObjectHelper<IfcBooleanClippingResult,0> { IfcBooleanClippingResult() : Object("IfcBooleanClippingResult") {}
+
+    };
+
+    // C++ wrapper for IfcCompositeCurve
+    struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {}
+		ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments;
+		IfcLogical::Out SelfIntersect;
+    };
+
+    // C++ wrapper for IfcCompositeCurveOnSurface
+    struct IfcCompositeCurveOnSurface : IfcCompositeCurve, ObjectHelper<IfcCompositeCurveOnSurface,0> { IfcCompositeCurveOnSurface() : Object("IfcCompositeCurveOnSurface") {}
+
+    };
+
+    // C++ wrapper for IfcBoundaryCurve
+    struct IfcBoundaryCurve : IfcCompositeCurveOnSurface, ObjectHelper<IfcBoundaryCurve,0> { IfcBoundaryCurve() : Object("IfcBoundaryCurve") {}
+
+    };
+
+    // C++ wrapper for IfcBoundingBox
+    struct IfcBoundingBox : IfcGeometricRepresentationItem, ObjectHelper<IfcBoundingBox,4> { IfcBoundingBox() : Object("IfcBoundingBox") {}
+		Lazy< IfcCartesianPoint > Corner;
+		IfcPositiveLengthMeasure::Out XDim;
+		IfcPositiveLengthMeasure::Out YDim;
+		IfcPositiveLengthMeasure::Out ZDim;
+    };
+
+    // C++ wrapper for IfcHalfSpaceSolid
+    struct IfcHalfSpaceSolid : IfcGeometricRepresentationItem, ObjectHelper<IfcHalfSpaceSolid,2> { IfcHalfSpaceSolid() : Object("IfcHalfSpaceSolid") {}
+		Lazy< IfcSurface > BaseSurface;
+		IfcBoolean::Out AgreementFlag;
+    };
+
+    // C++ wrapper for IfcBoxedHalfSpace
+    struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {}
+		Lazy< IfcBoundingBox > Enclosure;
+    };
+
+    // C++ wrapper for IfcSpatialElement
+    struct IfcSpatialElement : IfcProduct, ObjectHelper<IfcSpatialElement,1> { IfcSpatialElement() : Object("IfcSpatialElement") {}
+		Maybe< IfcLabel::Out > LongName;
+    };
+
+    // C++ wrapper for IfcSpatialStructureElement
+    struct IfcSpatialStructureElement : IfcSpatialElement, ObjectHelper<IfcSpatialStructureElement,1> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {}
+		Maybe< IfcElementCompositionEnum::Out > CompositionType;
+    };
+
+    // C++ wrapper for IfcBuilding
+    struct IfcBuilding : IfcSpatialStructureElement, ObjectHelper<IfcBuilding,3> { IfcBuilding() : Object("IfcBuilding") {}
+		Maybe< IfcLengthMeasure::Out > ElevationOfRefHeight;
+		Maybe< IfcLengthMeasure::Out > ElevationOfTerrain;
+		Maybe< Lazy< NotImplemented > > BuildingAddress;
+    };
+
+    // C++ wrapper for IfcElementComponent
+    struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {}
+
+    };
+
+    // C++ wrapper for IfcBuildingElementPart
+    struct IfcBuildingElementPart : IfcElementComponent, ObjectHelper<IfcBuildingElementPart,1> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {}
+		Maybe< IfcBuildingElementPartTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElementComponentType
+    struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {}
+
+    };
+
+    // C++ wrapper for IfcBuildingElementPartType
+    struct IfcBuildingElementPartType : IfcElementComponentType, ObjectHelper<IfcBuildingElementPartType,1> { IfcBuildingElementPartType() : Object("IfcBuildingElementPartType") {}
+		IfcBuildingElementPartTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcBuildingElementProxy
+    struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {}
+		Maybe< IfcBuildingElementProxyTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcBuildingElementProxyType
+    struct IfcBuildingElementProxyType : IfcBuildingElementType, ObjectHelper<IfcBuildingElementProxyType,1> { IfcBuildingElementProxyType() : Object("IfcBuildingElementProxyType") {}
+		IfcBuildingElementProxyTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcBuildingStorey
+    struct IfcBuildingStorey : IfcSpatialStructureElement, ObjectHelper<IfcBuildingStorey,1> { IfcBuildingStorey() : Object("IfcBuildingStorey") {}
+		Maybe< IfcLengthMeasure::Out > Elevation;
+    };
+
+    // C++ wrapper for IfcSystem
+    struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {}
+
+    };
+
+    // C++ wrapper for IfcBuildingSystem
+    struct IfcBuildingSystem : IfcSystem, ObjectHelper<IfcBuildingSystem,2> { IfcBuildingSystem() : Object("IfcBuildingSystem") {}
+		Maybe< IfcBuildingSystemTypeEnum::Out > PredefinedType;
+		Maybe< IfcLabel::Out > LongName;
+    };
+
+    // C++ wrapper for IfcBurner
+    struct IfcBurner : IfcEnergyConversionDevice, ObjectHelper<IfcBurner,1> { IfcBurner() : Object("IfcBurner") {}
+		Maybe< IfcBurnerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcBurnerType
+    struct IfcBurnerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBurnerType,1> { IfcBurnerType() : Object("IfcBurnerType") {}
+		IfcBurnerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCShapeProfileDef
+    struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,5> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out Depth;
+		IfcPositiveLengthMeasure::Out Width;
+		IfcPositiveLengthMeasure::Out WallThickness;
+		IfcPositiveLengthMeasure::Out Girth;
+		Maybe< IfcNonNegativeLengthMeasure::Out > InternalFilletRadius;
+    };
+
+    // C++ wrapper for IfcFlowFitting
+    struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {}
+
+    };
+
+    // C++ wrapper for IfcCableCarrierFitting
+    struct IfcCableCarrierFitting : IfcFlowFitting, ObjectHelper<IfcCableCarrierFitting,1> { IfcCableCarrierFitting() : Object("IfcCableCarrierFitting") {}
+		Maybe< IfcCableCarrierFittingTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowFittingType
+    struct IfcFlowFittingType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowFittingType,0> { IfcFlowFittingType() : Object("IfcFlowFittingType") {}
+
+    };
+
+    // C++ wrapper for IfcCableCarrierFittingType
+    struct IfcCableCarrierFittingType : IfcFlowFittingType, ObjectHelper<IfcCableCarrierFittingType,1> { IfcCableCarrierFittingType() : Object("IfcCableCarrierFittingType") {}
+		IfcCableCarrierFittingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowSegment
+    struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {}
+
+    };
+
+    // C++ wrapper for IfcCableCarrierSegment
+    struct IfcCableCarrierSegment : IfcFlowSegment, ObjectHelper<IfcCableCarrierSegment,1> { IfcCableCarrierSegment() : Object("IfcCableCarrierSegment") {}
+		Maybe< IfcCableCarrierSegmentTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowSegmentType
+    struct IfcFlowSegmentType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowSegmentType,0> { IfcFlowSegmentType() : Object("IfcFlowSegmentType") {}
+
+    };
+
+    // C++ wrapper for IfcCableCarrierSegmentType
+    struct IfcCableCarrierSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableCarrierSegmentType,1> { IfcCableCarrierSegmentType() : Object("IfcCableCarrierSegmentType") {}
+		IfcCableCarrierSegmentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCableFitting
+    struct IfcCableFitting : IfcFlowFitting, ObjectHelper<IfcCableFitting,1> { IfcCableFitting() : Object("IfcCableFitting") {}
+		Maybe< IfcCableFittingTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCableFittingType
+    struct IfcCableFittingType : IfcFlowFittingType, ObjectHelper<IfcCableFittingType,1> { IfcCableFittingType() : Object("IfcCableFittingType") {}
+		IfcCableFittingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCableSegment
+    struct IfcCableSegment : IfcFlowSegment, ObjectHelper<IfcCableSegment,1> { IfcCableSegment() : Object("IfcCableSegment") {}
+		Maybe< IfcCableSegmentTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCableSegmentType
+    struct IfcCableSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableSegmentType,1> { IfcCableSegmentType() : Object("IfcCableSegmentType") {}
+		IfcCableSegmentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPoint
+    struct IfcPoint : IfcGeometricRepresentationItem, ObjectHelper<IfcPoint,0> { IfcPoint() : Object("IfcPoint") {}
+
+    };
+
+    // C++ wrapper for IfcCartesianPoint
+    struct IfcCartesianPoint : IfcPoint, ObjectHelper<IfcCartesianPoint,1> { IfcCartesianPoint() : Object("IfcCartesianPoint") {}
+		ListOf< IfcLengthMeasure, 1, 3 >::Out Coordinates;
+    };
+
+    // C++ wrapper for IfcCartesianPointList
+    struct IfcCartesianPointList : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianPointList,0> { IfcCartesianPointList() : Object("IfcCartesianPointList") {}
+
+    };
+
+    // C++ wrapper for IfcCartesianPointList2D
+    struct IfcCartesianPointList2D : IfcCartesianPointList, ObjectHelper<IfcCartesianPointList2D,0> { IfcCartesianPointList2D() : Object("IfcCartesianPointList2D") {}
+
+    };
+
+    // C++ wrapper for IfcCartesianPointList3D
+    struct IfcCartesianPointList3D : IfcCartesianPointList, ObjectHelper<IfcCartesianPointList3D,0> { IfcCartesianPointList3D() : Object("IfcCartesianPointList3D") {}
+
+    };
+
+    // C++ wrapper for IfcCartesianTransformationOperator
+    struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {}
+		Maybe< Lazy< IfcDirection > > Axis1;
+		Maybe< Lazy< IfcDirection > > Axis2;
+		Lazy< IfcCartesianPoint > LocalOrigin;
+		Maybe< IfcReal::Out > Scale;
+    };
+
+    // C++ wrapper for IfcCartesianTransformationOperator2D
+    struct IfcCartesianTransformationOperator2D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator2D,0> { IfcCartesianTransformationOperator2D() : Object("IfcCartesianTransformationOperator2D") {}
+
+    };
+
+    // C++ wrapper for IfcCartesianTransformationOperator2DnonUniform
+    struct IfcCartesianTransformationOperator2DnonUniform : IfcCartesianTransformationOperator2D, ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1> { IfcCartesianTransformationOperator2DnonUniform() : Object("IfcCartesianTransformationOperator2DnonUniform") {}
+		Maybe< IfcReal::Out > Scale2;
+    };
+
+    // C++ wrapper for IfcCartesianTransformationOperator3D
+    struct IfcCartesianTransformationOperator3D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator3D,1> { IfcCartesianTransformationOperator3D() : Object("IfcCartesianTransformationOperator3D") {}
+		Maybe< Lazy< IfcDirection > > Axis3;
+    };
+
+    // C++ wrapper for IfcCartesianTransformationOperator3DnonUniform
+    struct IfcCartesianTransformationOperator3DnonUniform : IfcCartesianTransformationOperator3D, ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2> { IfcCartesianTransformationOperator3DnonUniform() : Object("IfcCartesianTransformationOperator3DnonUniform") {}
+		Maybe< IfcReal::Out > Scale2;
+		Maybe< IfcReal::Out > Scale3;
+    };
+
+    // C++ wrapper for IfcCenterLineProfileDef
+    struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {}
+		IfcPositiveLengthMeasure::Out Thickness;
+    };
+
+    // C++ wrapper for IfcChiller
+    struct IfcChiller : IfcEnergyConversionDevice, ObjectHelper<IfcChiller,1> { IfcChiller() : Object("IfcChiller") {}
+		Maybe< IfcChillerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcChillerType
+    struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {}
+		IfcChillerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcChimney
+    struct IfcChimney : IfcBuildingElement, ObjectHelper<IfcChimney,1> { IfcChimney() : Object("IfcChimney") {}
+		Maybe< IfcChimneyTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcChimneyType
+    struct IfcChimneyType : IfcBuildingElementType, ObjectHelper<IfcChimneyType,1> { IfcChimneyType() : Object("IfcChimneyType") {}
+		IfcChimneyTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcConic
+    struct IfcConic : IfcCurve, ObjectHelper<IfcConic,1> { IfcConic() : Object("IfcConic") {}
+		IfcAxis2Placement::Out Position;
+    };
+
+    // C++ wrapper for IfcCircle
+    struct IfcCircle : IfcConic, ObjectHelper<IfcCircle,1> { IfcCircle() : Object("IfcCircle") {}
+		IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // C++ wrapper for IfcCircleProfileDef
+    struct IfcCircleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCircleProfileDef,1> { IfcCircleProfileDef() : Object("IfcCircleProfileDef") {}
+		IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // C++ wrapper for IfcCircleHollowProfileDef
+    struct IfcCircleHollowProfileDef : IfcCircleProfileDef, ObjectHelper<IfcCircleHollowProfileDef,1> { IfcCircleHollowProfileDef() : Object("IfcCircleHollowProfileDef") {}
+		IfcPositiveLengthMeasure::Out WallThickness;
+    };
+
+    // C++ wrapper for IfcCivilElement
+    struct IfcCivilElement : IfcElement, ObjectHelper<IfcCivilElement,0> { IfcCivilElement() : Object("IfcCivilElement") {}
+
+    };
+
+    // C++ wrapper for IfcCivilElementType
+    struct IfcCivilElementType : IfcElementType, ObjectHelper<IfcCivilElementType,0> { IfcCivilElementType() : Object("IfcCivilElementType") {}
+
+    };
+
+    // C++ wrapper for IfcConnectedFaceSet
+    struct IfcConnectedFaceSet : IfcTopologicalRepresentationItem, ObjectHelper<IfcConnectedFaceSet,1> { IfcConnectedFaceSet() : Object("IfcConnectedFaceSet") {}
+		ListOf< Lazy< IfcFace >, 1, 0 > CfsFaces;
+    };
+
+    // C++ wrapper for IfcClosedShell
+    struct IfcClosedShell : IfcConnectedFaceSet, ObjectHelper<IfcClosedShell,0> { IfcClosedShell() : Object("IfcClosedShell") {}
+
+    };
+
+    // C++ wrapper for IfcCoil
+    struct IfcCoil : IfcEnergyConversionDevice, ObjectHelper<IfcCoil,1> { IfcCoil() : Object("IfcCoil") {}
+		Maybe< IfcCoilTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCoilType
+    struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {}
+		IfcCoilTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcColourSpecification
+    struct IfcColourSpecification : IfcPresentationItem, ObjectHelper<IfcColourSpecification,1> { IfcColourSpecification() : Object("IfcColourSpecification") {}
+		Maybe< IfcLabel::Out > Name;
+    };
+
+    // C++ wrapper for IfcColourRgb
+    struct IfcColourRgb : IfcColourSpecification, ObjectHelper<IfcColourRgb,3> { IfcColourRgb() : Object("IfcColourRgb") {}
+		IfcNormalisedRatioMeasure::Out Red;
+		IfcNormalisedRatioMeasure::Out Green;
+		IfcNormalisedRatioMeasure::Out Blue;
+    };
+
+    // C++ wrapper for IfcColumn
+    struct IfcColumn : IfcBuildingElement, ObjectHelper<IfcColumn,1> { IfcColumn() : Object("IfcColumn") {}
+		Maybe< IfcColumnTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcColumnStandardCase
+    struct IfcColumnStandardCase : IfcColumn, ObjectHelper<IfcColumnStandardCase,0> { IfcColumnStandardCase() : Object("IfcColumnStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcColumnType
+    struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {}
+		IfcColumnTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCommunicationsAppliance
+    struct IfcCommunicationsAppliance : IfcFlowTerminal, ObjectHelper<IfcCommunicationsAppliance,1> { IfcCommunicationsAppliance() : Object("IfcCommunicationsAppliance") {}
+		Maybe< IfcCommunicationsApplianceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCommunicationsApplianceType
+    struct IfcCommunicationsApplianceType : IfcFlowTerminalType, ObjectHelper<IfcCommunicationsApplianceType,1> { IfcCommunicationsApplianceType() : Object("IfcCommunicationsApplianceType") {}
+		IfcCommunicationsApplianceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPropertyAbstraction
+    struct IfcPropertyAbstraction :  ObjectHelper<IfcPropertyAbstraction,0> { IfcPropertyAbstraction() : Object("IfcPropertyAbstraction") {}
+
+    };
+
+    // C++ wrapper for IfcProperty
+    struct IfcProperty : IfcPropertyAbstraction, ObjectHelper<IfcProperty,2> { IfcProperty() : Object("IfcProperty") {}
+		IfcIdentifier::Out Name;
+		Maybe< IfcText::Out > Description;
+    };
+
+    // C++ wrapper for IfcComplexProperty
+    struct IfcComplexProperty : IfcProperty, ObjectHelper<IfcComplexProperty,2> { IfcComplexProperty() : Object("IfcComplexProperty") {}
+		IfcIdentifier::Out UsageName;
+		ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
+    };
+
+    // C++ wrapper for IfcPropertyDefinition
+    struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {}
+
+    };
+
+    // C++ wrapper for IfcCompositeCurveSegment
+    struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {}
+		IfcTransitionCode::Out Transition;
+		IfcBoolean::Out SameSense;
+		Lazy< IfcCurve > ParentCurve;
+    };
+
+    // C++ wrapper for IfcCompositeProfileDef
+    struct IfcCompositeProfileDef : IfcProfileDef, ObjectHelper<IfcCompositeProfileDef,2> { IfcCompositeProfileDef() : Object("IfcCompositeProfileDef") {}
+		ListOf< Lazy< IfcProfileDef >, 2, 0 > Profiles;
+		Maybe< IfcLabel::Out > Label;
+    };
+
+    // C++ wrapper for IfcFlowMovingDevice
+    struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {}
+
+    };
+
+    // C++ wrapper for IfcCompressor
+    struct IfcCompressor : IfcFlowMovingDevice, ObjectHelper<IfcCompressor,1> { IfcCompressor() : Object("IfcCompressor") {}
+		Maybe< IfcCompressorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowMovingDeviceType
+    struct IfcFlowMovingDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowMovingDeviceType,0> { IfcFlowMovingDeviceType() : Object("IfcFlowMovingDeviceType") {}
+
+    };
+
+    // C++ wrapper for IfcCompressorType
+    struct IfcCompressorType : IfcFlowMovingDeviceType, ObjectHelper<IfcCompressorType,1> { IfcCompressorType() : Object("IfcCompressorType") {}
+		IfcCompressorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCondenser
+    struct IfcCondenser : IfcEnergyConversionDevice, ObjectHelper<IfcCondenser,1> { IfcCondenser() : Object("IfcCondenser") {}
+		Maybe< IfcCondenserTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCondenserType
+    struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {}
+		IfcCondenserTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcResource
+    struct IfcResource : IfcObject, ObjectHelper<IfcResource,2> { IfcResource() : Object("IfcResource") {}
+		Maybe< IfcIdentifier::Out > Identification;
+		Maybe< IfcText::Out > LongDescription;
+    };
+
+    // C++ wrapper for IfcConstructionResource
+    struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,3> { IfcConstructionResource() : Object("IfcConstructionResource") {}
+		Maybe< Lazy< NotImplemented > > Usage;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > BaseCosts;
+		Maybe< Lazy< NotImplemented > > BaseQuantity;
+    };
+
+    // C++ wrapper for IfcConstructionEquipmentResource
+    struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,1> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {}
+		Maybe< IfcConstructionEquipmentResourceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTypeResource
+    struct IfcTypeResource : IfcTypeObject, ObjectHelper<IfcTypeResource,3> { IfcTypeResource() : Object("IfcTypeResource") {}
+		Maybe< IfcIdentifier::Out > Identification;
+		Maybe< IfcText::Out > LongDescription;
+		Maybe< IfcLabel::Out > ResourceType;
+    };
+
+    // C++ wrapper for IfcConstructionResourceType
+    struct IfcConstructionResourceType : IfcTypeResource, ObjectHelper<IfcConstructionResourceType,2> { IfcConstructionResourceType() : Object("IfcConstructionResourceType") {}
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > BaseCosts;
+		Maybe< Lazy< NotImplemented > > BaseQuantity;
+    };
+
+    // C++ wrapper for IfcConstructionEquipmentResourceType
+    struct IfcConstructionEquipmentResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionEquipmentResourceType,1> { IfcConstructionEquipmentResourceType() : Object("IfcConstructionEquipmentResourceType") {}
+		IfcConstructionEquipmentResourceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcConstructionMaterialResource
+    struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,1> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {}
+		Maybe< IfcConstructionMaterialResourceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcConstructionMaterialResourceType
+    struct IfcConstructionMaterialResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionMaterialResourceType,1> { IfcConstructionMaterialResourceType() : Object("IfcConstructionMaterialResourceType") {}
+		IfcConstructionMaterialResourceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcConstructionProductResource
+    struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,1> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {}
+		Maybe< IfcConstructionProductResourceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcConstructionProductResourceType
+    struct IfcConstructionProductResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionProductResourceType,1> { IfcConstructionProductResourceType() : Object("IfcConstructionProductResourceType") {}
+		IfcConstructionProductResourceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcContext
+    struct IfcContext : IfcObjectDefinition, ObjectHelper<IfcContext,5> { IfcContext() : Object("IfcContext") {}
+		Maybe< IfcLabel::Out > ObjectType;
+		Maybe< IfcLabel::Out > LongName;
+		Maybe< IfcLabel::Out > Phase;
+		Maybe< ListOf< Lazy< IfcRepresentationContext >, 1, 0 > > RepresentationContexts;
+		Maybe< Lazy< IfcUnitAssignment > > UnitsInContext;
+    };
+
+    // C++ wrapper for IfcNamedUnit
+    struct IfcNamedUnit :  ObjectHelper<IfcNamedUnit,2> { IfcNamedUnit() : Object("IfcNamedUnit") {}
+		Lazy< NotImplemented > Dimensions;
+		IfcUnitEnum::Out UnitType;
+    };
+
+    // C++ wrapper for IfcContextDependentUnit
+    struct IfcContextDependentUnit : IfcNamedUnit, ObjectHelper<IfcContextDependentUnit,1> { IfcContextDependentUnit() : Object("IfcContextDependentUnit") {}
+		IfcLabel::Out Name;
+    };
+
+    // C++ wrapper for IfcController
+    struct IfcController : IfcDistributionControlElement, ObjectHelper<IfcController,1> { IfcController() : Object("IfcController") {}
+		Maybe< IfcControllerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcControllerType
+    struct IfcControllerType : IfcDistributionControlElementType, ObjectHelper<IfcControllerType,1> { IfcControllerType() : Object("IfcControllerType") {}
+		IfcControllerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcConversionBasedUnit
+    struct IfcConversionBasedUnit : IfcNamedUnit, ObjectHelper<IfcConversionBasedUnit,2> { IfcConversionBasedUnit() : Object("IfcConversionBasedUnit") {}
+		IfcLabel::Out Name;
+		Lazy< IfcMeasureWithUnit > ConversionFactor;
+    };
+
+    // C++ wrapper for IfcConversionBasedUnitWithOffset
+    struct IfcConversionBasedUnitWithOffset : IfcConversionBasedUnit, ObjectHelper<IfcConversionBasedUnitWithOffset,1> { IfcConversionBasedUnitWithOffset() : Object("IfcConversionBasedUnitWithOffset") {}
+		IfcReal::Out ConversionOffset;
+    };
+
+    // C++ wrapper for IfcCooledBeam
+    struct IfcCooledBeam : IfcEnergyConversionDevice, ObjectHelper<IfcCooledBeam,1> { IfcCooledBeam() : Object("IfcCooledBeam") {}
+		Maybe< IfcCooledBeamTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCooledBeamType
+    struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {}
+		IfcCooledBeamTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCoolingTower
+    struct IfcCoolingTower : IfcEnergyConversionDevice, ObjectHelper<IfcCoolingTower,1> { IfcCoolingTower() : Object("IfcCoolingTower") {}
+		Maybe< IfcCoolingTowerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCoolingTowerType
+    struct IfcCoolingTowerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoolingTowerType,1> { IfcCoolingTowerType() : Object("IfcCoolingTowerType") {}
+		IfcCoolingTowerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCostItem
+    struct IfcCostItem : IfcControl, ObjectHelper<IfcCostItem,3> { IfcCostItem() : Object("IfcCostItem") {}
+		Maybe< IfcCostItemTypeEnum::Out > PredefinedType;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > CostValues;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > CostQuantities;
+    };
+
+    // C++ wrapper for IfcCostSchedule
+    struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,4> { IfcCostSchedule() : Object("IfcCostSchedule") {}
+		Maybe< IfcCostScheduleTypeEnum::Out > PredefinedType;
+		Maybe< IfcLabel::Out > Status;
+		Maybe< IfcDateTime::Out > SubmittedOn;
+		Maybe< IfcDateTime::Out > UpdateDate;
+    };
+
+    // C++ wrapper for IfcCovering
+    struct IfcCovering : IfcBuildingElement, ObjectHelper<IfcCovering,1> { IfcCovering() : Object("IfcCovering") {}
+		Maybe< IfcCoveringTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCoveringType
+    struct IfcCoveringType : IfcBuildingElementType, ObjectHelper<IfcCoveringType,1> { IfcCoveringType() : Object("IfcCoveringType") {}
+		IfcCoveringTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCrewResource
+    struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,1> { IfcCrewResource() : Object("IfcCrewResource") {}
+		Maybe< IfcCrewResourceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCrewResourceType
+    struct IfcCrewResourceType : IfcConstructionResourceType, ObjectHelper<IfcCrewResourceType,1> { IfcCrewResourceType() : Object("IfcCrewResourceType") {}
+		IfcCrewResourceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCsgSolid
+    struct IfcCsgSolid : IfcSolidModel, ObjectHelper<IfcCsgSolid,1> { IfcCsgSolid() : Object("IfcCsgSolid") {}
+		IfcCsgSelect::Out TreeRootExpression;
+    };
+
+    // C++ wrapper for IfcCurtainWall
+    struct IfcCurtainWall : IfcBuildingElement, ObjectHelper<IfcCurtainWall,1> { IfcCurtainWall() : Object("IfcCurtainWall") {}
+		Maybe< IfcCurtainWallTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcCurtainWallType
+    struct IfcCurtainWallType : IfcBuildingElementType, ObjectHelper<IfcCurtainWallType,1> { IfcCurtainWallType() : Object("IfcCurtainWallType") {}
+		IfcCurtainWallTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCurveBoundedPlane
+    struct IfcCurveBoundedPlane : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedPlane,3> { IfcCurveBoundedPlane() : Object("IfcCurveBoundedPlane") {}
+		Lazy< IfcPlane > BasisSurface;
+		Lazy< IfcCurve > OuterBoundary;
+		ListOf< Lazy< IfcCurve >, 0, 0 > InnerBoundaries;
+    };
+
+    // C++ wrapper for IfcCurveBoundedSurface
+    struct IfcCurveBoundedSurface : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedSurface,3> { IfcCurveBoundedSurface() : Object("IfcCurveBoundedSurface") {}
+		Lazy< IfcSurface > BasisSurface;
+		ListOf< Lazy< IfcBoundaryCurve >, 1, 0 > Boundaries;
+		IfcBoolean::Out ImplicitOuter;
+    };
+
+    // C++ wrapper for IfcPresentationStyle
+    struct IfcPresentationStyle :  ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {}
+		Maybe< IfcLabel::Out > Name;
+    };
+
+    // C++ wrapper for IfcElementarySurface
+    struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {}
+		Lazy< IfcAxis2Placement3D > Position;
+    };
+
+    // C++ wrapper for IfcCylindricalSurface
+    struct IfcCylindricalSurface : IfcElementarySurface, ObjectHelper<IfcCylindricalSurface,1> { IfcCylindricalSurface() : Object("IfcCylindricalSurface") {}
+		IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // C++ wrapper for IfcDamper
+    struct IfcDamper : IfcFlowController, ObjectHelper<IfcDamper,1> { IfcDamper() : Object("IfcDamper") {}
+		Maybe< IfcDamperTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDamperType
+    struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {}
+		IfcDamperTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDerivedProfileDef
+    struct IfcDerivedProfileDef : IfcProfileDef, ObjectHelper<IfcDerivedProfileDef,3> { IfcDerivedProfileDef() : Object("IfcDerivedProfileDef") {}
+		Lazy< IfcProfileDef > ParentProfile;
+		Lazy< IfcCartesianTransformationOperator2D > Operator;
+		Maybe< IfcLabel::Out > Label;
+    };
+
+    // C++ wrapper for IfcDirection
+    struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {}
+		ListOf< IfcReal, 2, 3 >::Out DirectionRatios;
+    };
+
+    // C++ wrapper for IfcDiscreteAccessory
+    struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,1> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {}
+		Maybe< IfcDiscreteAccessoryTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDiscreteAccessoryType
+    struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,1> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {}
+		IfcDiscreteAccessoryTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDistributionChamberElement
+    struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,1> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {}
+		Maybe< IfcDistributionChamberElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDistributionChamberElementType
+    struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {}
+		IfcDistributionChamberElementTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDistributionSystem
+    struct IfcDistributionSystem : IfcSystem, ObjectHelper<IfcDistributionSystem,2> { IfcDistributionSystem() : Object("IfcDistributionSystem") {}
+		Maybe< IfcLabel::Out > LongName;
+		Maybe< IfcDistributionSystemEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDistributionCircuit
+    struct IfcDistributionCircuit : IfcDistributionSystem, ObjectHelper<IfcDistributionCircuit,0> { IfcDistributionCircuit() : Object("IfcDistributionCircuit") {}
+
+    };
+
+    // C++ wrapper for IfcPort
+    struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionPort
+    struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,3> { IfcDistributionPort() : Object("IfcDistributionPort") {}
+		Maybe< IfcFlowDirectionEnum::Out > FlowDirection;
+		Maybe< IfcDistributionPortTypeEnum::Out > PredefinedType;
+		Maybe< IfcDistributionSystemEnum::Out > SystemType;
+    };
+
+    // C++ wrapper for IfcDoor
+    struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,5> { IfcDoor() : Object("IfcDoor") {}
+		Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
+		Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
+		Maybe< IfcDoorTypeEnum::Out > PredefinedType;
+		Maybe< IfcDoorTypeOperationEnum::Out > OperationType;
+		Maybe< IfcLabel::Out > UserDefinedOperationType;
+    };
+
+    // C++ wrapper for IfcPropertySetDefinition
+    struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {}
+
+    };
+
+    // C++ wrapper for IfcDoorStandardCase
+    struct IfcDoorStandardCase : IfcDoor, ObjectHelper<IfcDoorStandardCase,0> { IfcDoorStandardCase() : Object("IfcDoorStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcDoorStyle
+    struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {}
+		IfcDoorStyleOperationEnum::Out OperationType;
+		IfcDoorStyleConstructionEnum::Out ConstructionType;
+		IfcBoolean::Out ParameterTakesPrecedence;
+		IfcBoolean::Out Sizeable;
+    };
+
+    // C++ wrapper for IfcDoorType
+    struct IfcDoorType : IfcBuildingElementType, ObjectHelper<IfcDoorType,4> { IfcDoorType() : Object("IfcDoorType") {}
+		IfcDoorTypeEnum::Out PredefinedType;
+		IfcDoorTypeOperationEnum::Out OperationType;
+		Maybe< IfcBoolean::Out > ParameterTakesPrecedence;
+		Maybe< IfcLabel::Out > UserDefinedOperationType;
+    };
+
+    // C++ wrapper for IfcDuctFitting
+    struct IfcDuctFitting : IfcFlowFitting, ObjectHelper<IfcDuctFitting,1> { IfcDuctFitting() : Object("IfcDuctFitting") {}
+		Maybe< IfcDuctFittingTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDuctFittingType
+    struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {}
+		IfcDuctFittingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDuctSegment
+    struct IfcDuctSegment : IfcFlowSegment, ObjectHelper<IfcDuctSegment,1> { IfcDuctSegment() : Object("IfcDuctSegment") {}
+		Maybe< IfcDuctSegmentTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcDuctSegmentType
+    struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {}
+		IfcDuctSegmentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowTreatmentDevice
+    struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {}
+
+    };
+
+    // C++ wrapper for IfcDuctSilencer
+    struct IfcDuctSilencer : IfcFlowTreatmentDevice, ObjectHelper<IfcDuctSilencer,1> { IfcDuctSilencer() : Object("IfcDuctSilencer") {}
+		Maybe< IfcDuctSilencerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowTreatmentDeviceType
+    struct IfcFlowTreatmentDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTreatmentDeviceType,0> { IfcFlowTreatmentDeviceType() : Object("IfcFlowTreatmentDeviceType") {}
+
+    };
+
+    // C++ wrapper for IfcDuctSilencerType
+    struct IfcDuctSilencerType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcDuctSilencerType,1> { IfcDuctSilencerType() : Object("IfcDuctSilencerType") {}
+		IfcDuctSilencerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcEdge
+    struct IfcEdge : IfcTopologicalRepresentationItem, ObjectHelper<IfcEdge,2> { IfcEdge() : Object("IfcEdge") {}
+		Lazy< IfcVertex > EdgeStart;
+		Lazy< IfcVertex > EdgeEnd;
+    };
+
+    // C++ wrapper for IfcEdgeCurve
+    struct IfcEdgeCurve : IfcEdge, ObjectHelper<IfcEdgeCurve,2> { IfcEdgeCurve() : Object("IfcEdgeCurve") {}
+		Lazy< IfcCurve > EdgeGeometry;
+		IfcBoolean::Out SameSense;
+    };
+
+    // C++ wrapper for IfcLoop
+    struct IfcLoop : IfcTopologicalRepresentationItem, ObjectHelper<IfcLoop,0> { IfcLoop() : Object("IfcLoop") {}
+
+    };
+
+    // C++ wrapper for IfcEdgeLoop
+    struct IfcEdgeLoop : IfcLoop, ObjectHelper<IfcEdgeLoop,1> { IfcEdgeLoop() : Object("IfcEdgeLoop") {}
+		ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
+    };
+
+    // C++ wrapper for IfcElectricAppliance
+    struct IfcElectricAppliance : IfcFlowTerminal, ObjectHelper<IfcElectricAppliance,1> { IfcElectricAppliance() : Object("IfcElectricAppliance") {}
+		Maybe< IfcElectricApplianceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricApplianceType
+    struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {}
+		IfcElectricApplianceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricDistributionBoard
+    struct IfcElectricDistributionBoard : IfcFlowController, ObjectHelper<IfcElectricDistributionBoard,1> { IfcElectricDistributionBoard() : Object("IfcElectricDistributionBoard") {}
+		Maybe< IfcElectricDistributionBoardTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricDistributionBoardType
+    struct IfcElectricDistributionBoardType : IfcFlowControllerType, ObjectHelper<IfcElectricDistributionBoardType,1> { IfcElectricDistributionBoardType() : Object("IfcElectricDistributionBoardType") {}
+		IfcElectricDistributionBoardTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowStorageDevice
+    struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {}
+
+    };
+
+    // C++ wrapper for IfcElectricFlowStorageDevice
+    struct IfcElectricFlowStorageDevice : IfcFlowStorageDevice, ObjectHelper<IfcElectricFlowStorageDevice,1> { IfcElectricFlowStorageDevice() : Object("IfcElectricFlowStorageDevice") {}
+		Maybe< IfcElectricFlowStorageDeviceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowStorageDeviceType
+    struct IfcFlowStorageDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowStorageDeviceType,0> { IfcFlowStorageDeviceType() : Object("IfcFlowStorageDeviceType") {}
+
+    };
+
+    // C++ wrapper for IfcElectricFlowStorageDeviceType
+    struct IfcElectricFlowStorageDeviceType : IfcFlowStorageDeviceType, ObjectHelper<IfcElectricFlowStorageDeviceType,1> { IfcElectricFlowStorageDeviceType() : Object("IfcElectricFlowStorageDeviceType") {}
+		IfcElectricFlowStorageDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricGenerator
+    struct IfcElectricGenerator : IfcEnergyConversionDevice, ObjectHelper<IfcElectricGenerator,1> { IfcElectricGenerator() : Object("IfcElectricGenerator") {}
+		Maybe< IfcElectricGeneratorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricGeneratorType
+    struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {}
+		IfcElectricGeneratorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricMotor
+    struct IfcElectricMotor : IfcEnergyConversionDevice, ObjectHelper<IfcElectricMotor,1> { IfcElectricMotor() : Object("IfcElectricMotor") {}
+		Maybe< IfcElectricMotorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricMotorType
+    struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {}
+		IfcElectricMotorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricTimeControl
+    struct IfcElectricTimeControl : IfcFlowController, ObjectHelper<IfcElectricTimeControl,1> { IfcElectricTimeControl() : Object("IfcElectricTimeControl") {}
+		Maybe< IfcElectricTimeControlTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricTimeControlType
+    struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {}
+		IfcElectricTimeControlTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElementAssembly
+    struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {}
+		Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace;
+		Maybe< IfcElementAssemblyTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcElementAssemblyType
+    struct IfcElementAssemblyType : IfcElementType, ObjectHelper<IfcElementAssemblyType,1> { IfcElementAssemblyType() : Object("IfcElementAssemblyType") {}
+		IfcElementAssemblyTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcQuantitySet
+    struct IfcQuantitySet : IfcPropertySetDefinition, ObjectHelper<IfcQuantitySet,0> { IfcQuantitySet() : Object("IfcQuantitySet") {}
+
+    };
+
+    // C++ wrapper for IfcElementQuantity
+    struct IfcElementQuantity : IfcQuantitySet, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {}
+		Maybe< IfcLabel::Out > MethodOfMeasurement;
+		ListOf< Lazy< NotImplemented >, 1, 0 > Quantities;
+    };
+
+    // C++ wrapper for IfcEllipse
+    struct IfcEllipse : IfcConic, ObjectHelper<IfcEllipse,2> { IfcEllipse() : Object("IfcEllipse") {}
+		IfcPositiveLengthMeasure::Out SemiAxis1;
+		IfcPositiveLengthMeasure::Out SemiAxis2;
+    };
+
+    // C++ wrapper for IfcEllipseProfileDef
+    struct IfcEllipseProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcEllipseProfileDef,2> { IfcEllipseProfileDef() : Object("IfcEllipseProfileDef") {}
+		IfcPositiveLengthMeasure::Out SemiAxis1;
+		IfcPositiveLengthMeasure::Out SemiAxis2;
+    };
+
+    // C++ wrapper for IfcEngine
+    struct IfcEngine : IfcEnergyConversionDevice, ObjectHelper<IfcEngine,1> { IfcEngine() : Object("IfcEngine") {}
+		Maybe< IfcEngineTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcEngineType
+    struct IfcEngineType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEngineType,1> { IfcEngineType() : Object("IfcEngineType") {}
+		IfcEngineTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcEvaporativeCooler
+    struct IfcEvaporativeCooler : IfcEnergyConversionDevice, ObjectHelper<IfcEvaporativeCooler,1> { IfcEvaporativeCooler() : Object("IfcEvaporativeCooler") {}
+		Maybe< IfcEvaporativeCoolerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcEvaporativeCoolerType
+    struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {}
+		IfcEvaporativeCoolerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcEvaporator
+    struct IfcEvaporator : IfcEnergyConversionDevice, ObjectHelper<IfcEvaporator,1> { IfcEvaporator() : Object("IfcEvaporator") {}
+		Maybe< IfcEvaporatorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcEvaporatorType
+    struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {}
+		IfcEvaporatorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProcess
+    struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,2> { IfcProcess() : Object("IfcProcess") {}
+		Maybe< IfcIdentifier::Out > Identification;
+		Maybe< IfcText::Out > LongDescription;
+    };
+
+    // C++ wrapper for IfcEvent
+    struct IfcEvent : IfcProcess, ObjectHelper<IfcEvent,4> { IfcEvent() : Object("IfcEvent") {}
+		Maybe< IfcEventTypeEnum::Out > PredefinedType;
+		Maybe< IfcEventTriggerTypeEnum::Out > EventTriggerType;
+		Maybe< IfcLabel::Out > UserDefinedEventTriggerType;
+		Maybe< Lazy< NotImplemented > > EventOccurenceTime;
+    };
+
+    // C++ wrapper for IfcTypeProcess
+    struct IfcTypeProcess : IfcTypeObject, ObjectHelper<IfcTypeProcess,3> { IfcTypeProcess() : Object("IfcTypeProcess") {}
+		Maybe< IfcIdentifier::Out > Identification;
+		Maybe< IfcText::Out > LongDescription;
+		Maybe< IfcLabel::Out > ProcessType;
+    };
+
+    // C++ wrapper for IfcEventType
+    struct IfcEventType : IfcTypeProcess, ObjectHelper<IfcEventType,3> { IfcEventType() : Object("IfcEventType") {}
+		IfcEventTypeEnum::Out PredefinedType;
+		IfcEventTriggerTypeEnum::Out EventTriggerType;
+		Maybe< IfcLabel::Out > UserDefinedEventTriggerType;
+    };
+
+    // C++ wrapper for IfcExternalSpatialStructureElement
+    struct IfcExternalSpatialStructureElement : IfcSpatialElement, ObjectHelper<IfcExternalSpatialStructureElement,0> { IfcExternalSpatialStructureElement() : Object("IfcExternalSpatialStructureElement") {}
+
+    };
+
+    // C++ wrapper for IfcExternalSpatialElement
+    struct IfcExternalSpatialElement : IfcExternalSpatialStructureElement, ObjectHelper<IfcExternalSpatialElement,1> { IfcExternalSpatialElement() : Object("IfcExternalSpatialElement") {}
+		Maybe< IfcExternalSpatialElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSweptAreaSolid
+    struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {}
+		Lazy< IfcProfileDef > SweptArea;
+		Maybe< Lazy< IfcAxis2Placement3D > > Position;
+    };
+
+    // C++ wrapper for IfcExtrudedAreaSolid
+    struct IfcExtrudedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcExtrudedAreaSolid,2> { IfcExtrudedAreaSolid() : Object("IfcExtrudedAreaSolid") {}
+		Lazy< IfcDirection > ExtrudedDirection;
+		IfcPositiveLengthMeasure::Out Depth;
+    };
+
+    // C++ wrapper for IfcExtrudedAreaSolidTapered
+    struct IfcExtrudedAreaSolidTapered : IfcExtrudedAreaSolid, ObjectHelper<IfcExtrudedAreaSolidTapered,1> { IfcExtrudedAreaSolidTapered() : Object("IfcExtrudedAreaSolidTapered") {}
+		Lazy< IfcProfileDef > EndSweptArea;
+    };
+
+    // C++ wrapper for IfcFaceBasedSurfaceModel
+    struct IfcFaceBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcFaceBasedSurfaceModel,1> { IfcFaceBasedSurfaceModel() : Object("IfcFaceBasedSurfaceModel") {}
+		ListOf< Lazy< IfcConnectedFaceSet >, 1, 0 > FbsmFaces;
+    };
+
+    // C++ wrapper for IfcFaceBound
+    struct IfcFaceBound : IfcTopologicalRepresentationItem, ObjectHelper<IfcFaceBound,2> { IfcFaceBound() : Object("IfcFaceBound") {}
+		Lazy< IfcLoop > Bound;
+		IfcBoolean::Out Orientation;
+    };
+
+    // C++ wrapper for IfcFaceOuterBound
+    struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {}
+
+    };
+
+    // C++ wrapper for IfcFacetedBrep
+    struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {}
+
+    };
+
+    // C++ wrapper for IfcFacetedBrepWithVoids
+    struct IfcFacetedBrepWithVoids : IfcFacetedBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {}
+		ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
+    };
+
+    // C++ wrapper for IfcFan
+    struct IfcFan : IfcFlowMovingDevice, ObjectHelper<IfcFan,1> { IfcFan() : Object("IfcFan") {}
+		Maybe< IfcFanTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFanType
+    struct IfcFanType : IfcFlowMovingDeviceType, ObjectHelper<IfcFanType,1> { IfcFanType() : Object("IfcFanType") {}
+		IfcFanTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFastener
+    struct IfcFastener : IfcElementComponent, ObjectHelper<IfcFastener,1> { IfcFastener() : Object("IfcFastener") {}
+		Maybe< IfcFastenerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFastenerType
+    struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,1> { IfcFastenerType() : Object("IfcFastenerType") {}
+		IfcFastenerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFeatureElement
+    struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {}
+
+    };
+
+    // C++ wrapper for IfcFeatureElementAddition
+    struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {}
+
+    };
+
+    // C++ wrapper for IfcFeatureElementSubtraction
+    struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {}
+
+    };
+
+    // C++ wrapper for IfcFillAreaStyleHatching
+    struct IfcFillAreaStyleHatching : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleHatching,5> { IfcFillAreaStyleHatching() : Object("IfcFillAreaStyleHatching") {}
+		Lazy< NotImplemented > HatchLineAppearance;
+		IfcHatchLineDistanceSelect::Out StartOfNextHatchLine;
+		Maybe< Lazy< IfcCartesianPoint > > PointOfReferenceHatchLine;
+		Maybe< Lazy< IfcCartesianPoint > > PatternStart;
+		IfcPlaneAngleMeasure::Out HatchLineAngle;
+    };
+
+    // C++ wrapper for IfcFillAreaStyleTiles
+    struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {}
+		ListOf< Lazy< IfcVector >, 2, 2 > TilingPattern;
+		ListOf< Lazy< IfcStyledItem >, 1, 0 > Tiles;
+		IfcPositiveRatioMeasure::Out TilingScale;
+    };
+
+    // C++ wrapper for IfcFilter
+    struct IfcFilter : IfcFlowTreatmentDevice, ObjectHelper<IfcFilter,1> { IfcFilter() : Object("IfcFilter") {}
+		Maybe< IfcFilterTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFilterType
+    struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {}
+		IfcFilterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFireSuppressionTerminal
+    struct IfcFireSuppressionTerminal : IfcFlowTerminal, ObjectHelper<IfcFireSuppressionTerminal,1> { IfcFireSuppressionTerminal() : Object("IfcFireSuppressionTerminal") {}
+		Maybe< IfcFireSuppressionTerminalTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFireSuppressionTerminalType
+    struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {}
+		IfcFireSuppressionTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFixedReferenceSweptAreaSolid
+    struct IfcFixedReferenceSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcFixedReferenceSweptAreaSolid,4> { IfcFixedReferenceSweptAreaSolid() : Object("IfcFixedReferenceSweptAreaSolid") {}
+		Lazy< IfcCurve > Directrix;
+		Maybe< IfcParameterValue::Out > StartParam;
+		Maybe< IfcParameterValue::Out > EndParam;
+		Lazy< IfcDirection > FixedReference;
+    };
+
+    // C++ wrapper for IfcFlowInstrument
+    struct IfcFlowInstrument : IfcDistributionControlElement, ObjectHelper<IfcFlowInstrument,1> { IfcFlowInstrument() : Object("IfcFlowInstrument") {}
+		Maybe< IfcFlowInstrumentTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowInstrumentType
+    struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {}
+		IfcFlowInstrumentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowMeter
+    struct IfcFlowMeter : IfcFlowController, ObjectHelper<IfcFlowMeter,1> { IfcFlowMeter() : Object("IfcFlowMeter") {}
+		Maybe< IfcFlowMeterTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowMeterType
+    struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {}
+		IfcFlowMeterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFooting
+    struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {}
+		Maybe< IfcFootingTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFootingType
+    struct IfcFootingType : IfcBuildingElementType, ObjectHelper<IfcFootingType,1> { IfcFootingType() : Object("IfcFootingType") {}
+		IfcFootingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFurnishingElement
+    struct IfcFurnishingElement : IfcElement, ObjectHelper<IfcFurnishingElement,0> { IfcFurnishingElement() : Object("IfcFurnishingElement") {}
+
+    };
+
+    // C++ wrapper for IfcFurnishingElementType
+    struct IfcFurnishingElementType : IfcElementType, ObjectHelper<IfcFurnishingElementType,0> { IfcFurnishingElementType() : Object("IfcFurnishingElementType") {}
+
+    };
+
+    // C++ wrapper for IfcFurniture
+    struct IfcFurniture : IfcFurnishingElement, ObjectHelper<IfcFurniture,1> { IfcFurniture() : Object("IfcFurniture") {}
+		Maybe< IfcFurnitureTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcFurnitureType
+    struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,2> { IfcFurnitureType() : Object("IfcFurnitureType") {}
+		IfcAssemblyPlaceEnum::Out AssemblyPlace;
+		Maybe< IfcFurnitureTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcGeographicElement
+    struct IfcGeographicElement : IfcElement, ObjectHelper<IfcGeographicElement,1> { IfcGeographicElement() : Object("IfcGeographicElement") {}
+		Maybe< IfcGeographicElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcGeographicElementType
+    struct IfcGeographicElementType : IfcElementType, ObjectHelper<IfcGeographicElementType,1> { IfcGeographicElementType() : Object("IfcGeographicElementType") {}
+		IfcGeographicElementTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcGeometricSet
+    struct IfcGeometricSet : IfcGeometricRepresentationItem, ObjectHelper<IfcGeometricSet,1> { IfcGeometricSet() : Object("IfcGeometricSet") {}
+		ListOf< IfcGeometricSetSelect, 1, 0 >::Out Elements;
+    };
+
+    // C++ wrapper for IfcGeometricCurveSet
+    struct IfcGeometricCurveSet : IfcGeometricSet, ObjectHelper<IfcGeometricCurveSet,0> { IfcGeometricCurveSet() : Object("IfcGeometricCurveSet") {}
+
+    };
+
+    // C++ wrapper for IfcRepresentationContext
+    struct IfcRepresentationContext :  ObjectHelper<IfcRepresentationContext,2> { IfcRepresentationContext() : Object("IfcRepresentationContext") {}
+		Maybe< IfcLabel::Out > ContextIdentifier;
+		Maybe< IfcLabel::Out > ContextType;
+    };
+
+    // C++ wrapper for IfcGeometricRepresentationContext
+    struct IfcGeometricRepresentationContext : IfcRepresentationContext, ObjectHelper<IfcGeometricRepresentationContext,4> { IfcGeometricRepresentationContext() : Object("IfcGeometricRepresentationContext") {}
+		IfcDimensionCount::Out CoordinateSpaceDimension;
+		Maybe< IfcReal::Out > Precision;
+		IfcAxis2Placement::Out WorldCoordinateSystem;
+		Maybe< Lazy< IfcDirection > > TrueNorth;
+    };
+
+    // C++ wrapper for IfcGeometricRepresentationSubContext
+    struct IfcGeometricRepresentationSubContext : IfcGeometricRepresentationContext, ObjectHelper<IfcGeometricRepresentationSubContext,4> { IfcGeometricRepresentationSubContext() : Object("IfcGeometricRepresentationSubContext") {}
+		Lazy< IfcGeometricRepresentationContext > ParentContext;
+		Maybe< IfcPositiveRatioMeasure::Out > TargetScale;
+		IfcGeometricProjectionEnum::Out TargetView;
+		Maybe< IfcLabel::Out > UserDefinedTargetView;
+    };
+
+    // C++ wrapper for IfcGrid
+    struct IfcGrid : IfcProduct, ObjectHelper<IfcGrid,4> { IfcGrid() : Object("IfcGrid") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > UAxes;
+		ListOf< Lazy< NotImplemented >, 1, 0 > VAxes;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes;
+		Maybe< IfcGridTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcObjectPlacement
+    struct IfcObjectPlacement :  ObjectHelper<IfcObjectPlacement,0> { IfcObjectPlacement() : Object("IfcObjectPlacement") {}
+
+    };
+
+    // C++ wrapper for IfcGridPlacement
+    struct IfcGridPlacement : IfcObjectPlacement, ObjectHelper<IfcGridPlacement,2> { IfcGridPlacement() : Object("IfcGridPlacement") {}
+		Lazy< NotImplemented > PlacementLocation;
+		Maybe< IfcGridPlacementDirectionSelect::Out > PlacementRefDirection;
+    };
+
+    // C++ wrapper for IfcHeatExchanger
+    struct IfcHeatExchanger : IfcEnergyConversionDevice, ObjectHelper<IfcHeatExchanger,1> { IfcHeatExchanger() : Object("IfcHeatExchanger") {}
+		Maybe< IfcHeatExchangerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcHeatExchangerType
+    struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {}
+		IfcHeatExchangerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcHumidifier
+    struct IfcHumidifier : IfcEnergyConversionDevice, ObjectHelper<IfcHumidifier,1> { IfcHumidifier() : Object("IfcHumidifier") {}
+		Maybe< IfcHumidifierTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcHumidifierType
+    struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {}
+		IfcHumidifierTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcIShapeProfileDef
+    struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,7> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out OverallWidth;
+		IfcPositiveLengthMeasure::Out OverallDepth;
+		IfcPositiveLengthMeasure::Out WebThickness;
+		IfcPositiveLengthMeasure::Out FlangeThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FlangeEdgeRadius;
+		Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
+    };
+
+    // C++ wrapper for IfcIndexedPolyCurve
+    struct IfcIndexedPolyCurve : IfcBoundedCurve, ObjectHelper<IfcIndexedPolyCurve,3> { IfcIndexedPolyCurve() : Object("IfcIndexedPolyCurve") {}
+		Lazy< IfcCartesianPointList > Points;
+		Maybe< ListOf< IfcSegmentIndexSelect, 1, 0 >::Out > Segments;
+		Maybe< IfcBoolean::Out > SelfIntersect;
+    };
+
+    // C++ wrapper for IfcTessellatedItem
+    struct IfcTessellatedItem : IfcGeometricRepresentationItem, ObjectHelper<IfcTessellatedItem,0> { IfcTessellatedItem() : Object("IfcTessellatedItem") {}
+
+    };
+
+    // C++ wrapper for IfcIndexedPolygonalFace
+    struct IfcIndexedPolygonalFace : IfcTessellatedItem, ObjectHelper<IfcIndexedPolygonalFace,1> { IfcIndexedPolygonalFace() : Object("IfcIndexedPolygonalFace") {}
+		ListOf< IfcPositiveInteger, 3, 0 >::Out CoordIndex;
+    };
+
+    // C++ wrapper for IfcIndexedPolygonalFaceWithVoids
+    struct IfcIndexedPolygonalFaceWithVoids : IfcIndexedPolygonalFace, ObjectHelper<IfcIndexedPolygonalFaceWithVoids,0> { IfcIndexedPolygonalFaceWithVoids() : Object("IfcIndexedPolygonalFaceWithVoids") {}
+
+    };
+
+    // C++ wrapper for IfcInterceptor
+    struct IfcInterceptor : IfcFlowTreatmentDevice, ObjectHelper<IfcInterceptor,1> { IfcInterceptor() : Object("IfcInterceptor") {}
+		Maybe< IfcInterceptorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcInterceptorType
+    struct IfcInterceptorType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcInterceptorType,1> { IfcInterceptorType() : Object("IfcInterceptorType") {}
+		IfcInterceptorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSurfaceCurve
+    struct IfcSurfaceCurve : IfcCurve, ObjectHelper<IfcSurfaceCurve,3> { IfcSurfaceCurve() : Object("IfcSurfaceCurve") {}
+		Lazy< IfcCurve > Curve3D;
+		ListOf< Lazy< IfcPcurve >, 1, 2 > AssociatedGeometry;
+		IfcPreferredSurfaceCurveRepresentation::Out MasterRepresentation;
+    };
+
+    // C++ wrapper for IfcIntersectionCurve
+    struct IfcIntersectionCurve : IfcSurfaceCurve, ObjectHelper<IfcIntersectionCurve,0> { IfcIntersectionCurve() : Object("IfcIntersectionCurve") {}
+
+    };
+
+    // C++ wrapper for IfcInventory
+    struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {}
+		Maybe< IfcInventoryTypeEnum::Out > PredefinedType;
+		Maybe< IfcActorSelect::Out > Jurisdiction;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > ResponsiblePersons;
+		Maybe< IfcDate::Out > LastUpdateDate;
+		Maybe< Lazy< NotImplemented > > CurrentValue;
+		Maybe< Lazy< NotImplemented > > OriginalValue;
+    };
+
+    // C++ wrapper for IfcJunctionBox
+    struct IfcJunctionBox : IfcFlowFitting, ObjectHelper<IfcJunctionBox,1> { IfcJunctionBox() : Object("IfcJunctionBox") {}
+		Maybe< IfcJunctionBoxTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcJunctionBoxType
+    struct IfcJunctionBoxType : IfcFlowFittingType, ObjectHelper<IfcJunctionBoxType,1> { IfcJunctionBoxType() : Object("IfcJunctionBoxType") {}
+		IfcJunctionBoxTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcLShapeProfileDef
+    struct IfcLShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcLShapeProfileDef,6> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out Depth;
+		Maybe< IfcPositiveLengthMeasure::Out > Width;
+		IfcPositiveLengthMeasure::Out Thickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
+		Maybe< IfcPlaneAngleMeasure::Out > LegSlope;
+    };
+
+    // C++ wrapper for IfcLaborResource
+    struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {}
+		Maybe< IfcLaborResourceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcLaborResourceType
+    struct IfcLaborResourceType : IfcConstructionResourceType, ObjectHelper<IfcLaborResourceType,1> { IfcLaborResourceType() : Object("IfcLaborResourceType") {}
+		IfcLaborResourceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcLamp
+    struct IfcLamp : IfcFlowTerminal, ObjectHelper<IfcLamp,1> { IfcLamp() : Object("IfcLamp") {}
+		Maybe< IfcLampTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcLampType
+    struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {}
+		IfcLampTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcLightFixture
+    struct IfcLightFixture : IfcFlowTerminal, ObjectHelper<IfcLightFixture,1> { IfcLightFixture() : Object("IfcLightFixture") {}
+		Maybe< IfcLightFixtureTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcLightFixtureType
+    struct IfcLightFixtureType : IfcFlowTerminalType, ObjectHelper<IfcLightFixtureType,1> { IfcLightFixtureType() : Object("IfcLightFixtureType") {}
+		IfcLightFixtureTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcLightSource
+    struct IfcLightSource : IfcGeometricRepresentationItem, ObjectHelper<IfcLightSource,4> { IfcLightSource() : Object("IfcLightSource") {}
+		Maybe< IfcLabel::Out > Name;
+		Lazy< IfcColourRgb > LightColour;
+		Maybe< IfcNormalisedRatioMeasure::Out > AmbientIntensity;
+		Maybe< IfcNormalisedRatioMeasure::Out > Intensity;
+    };
+
+    // C++ wrapper for IfcLightSourceAmbient
+    struct IfcLightSourceAmbient : IfcLightSource, ObjectHelper<IfcLightSourceAmbient,0> { IfcLightSourceAmbient() : Object("IfcLightSourceAmbient") {}
+
+    };
+
+    // C++ wrapper for IfcLightSourceDirectional
+    struct IfcLightSourceDirectional : IfcLightSource, ObjectHelper<IfcLightSourceDirectional,1> { IfcLightSourceDirectional() : Object("IfcLightSourceDirectional") {}
+		Lazy< IfcDirection > Orientation;
+    };
+
+    // C++ wrapper for IfcLightSourceGoniometric
+    struct IfcLightSourceGoniometric : IfcLightSource, ObjectHelper<IfcLightSourceGoniometric,6> { IfcLightSourceGoniometric() : Object("IfcLightSourceGoniometric") {}
+		Lazy< IfcAxis2Placement3D > Position;
+		Maybe< Lazy< IfcColourRgb > > ColourAppearance;
+		IfcThermodynamicTemperatureMeasure::Out ColourTemperature;
+		IfcLuminousFluxMeasure::Out LuminousFlux;
+		IfcLightEmissionSourceEnum::Out LightEmissionSource;
+		IfcLightDistributionDataSourceSelect::Out LightDistributionDataSource;
+    };
+
+    // C++ wrapper for IfcLightSourcePositional
+    struct IfcLightSourcePositional : IfcLightSource, ObjectHelper<IfcLightSourcePositional,5> { IfcLightSourcePositional() : Object("IfcLightSourcePositional") {}
+		Lazy< IfcCartesianPoint > Position;
+		IfcPositiveLengthMeasure::Out Radius;
+		IfcReal::Out ConstantAttenuation;
+		IfcReal::Out DistanceAttenuation;
+		IfcReal::Out QuadricAttenuation;
+    };
+
+    // C++ wrapper for IfcLightSourceSpot
+    struct IfcLightSourceSpot : IfcLightSourcePositional, ObjectHelper<IfcLightSourceSpot,4> { IfcLightSourceSpot() : Object("IfcLightSourceSpot") {}
+		Lazy< IfcDirection > Orientation;
+		Maybe< IfcReal::Out > ConcentrationExponent;
+		IfcPositivePlaneAngleMeasure::Out SpreadAngle;
+		IfcPositivePlaneAngleMeasure::Out BeamWidthAngle;
+    };
+
+    // C++ wrapper for IfcLine
+    struct IfcLine : IfcCurve, ObjectHelper<IfcLine,2> { IfcLine() : Object("IfcLine") {}
+		Lazy< IfcCartesianPoint > Pnt;
+		Lazy< IfcVector > Dir;
+    };
+
+    // C++ wrapper for IfcLocalPlacement
+    struct IfcLocalPlacement : IfcObjectPlacement, ObjectHelper<IfcLocalPlacement,2> { IfcLocalPlacement() : Object("IfcLocalPlacement") {}
+		Maybe< Lazy< IfcObjectPlacement > > PlacementRelTo;
+		IfcAxis2Placement::Out RelativePlacement;
+    };
+
+    // C++ wrapper for IfcMappedItem
+    struct IfcMappedItem : IfcRepresentationItem, ObjectHelper<IfcMappedItem,2> { IfcMappedItem() : Object("IfcMappedItem") {}
+		Lazy< IfcRepresentationMap > MappingSource;
+		Lazy< IfcCartesianTransformationOperator > MappingTarget;
+    };
+
+    // C++ wrapper for IfcProductRepresentation
+    struct IfcProductRepresentation :  ObjectHelper<IfcProductRepresentation,3> { IfcProductRepresentation() : Object("IfcProductRepresentation") {}
+		Maybe< IfcLabel::Out > Name;
+		Maybe< IfcText::Out > Description;
+		ListOf< Lazy< IfcRepresentation >, 1, 0 > Representations;
+    };
+
+    // C++ wrapper for IfcMaterialDefinitionRepresentation
+    struct IfcMaterialDefinitionRepresentation : IfcProductRepresentation, ObjectHelper<IfcMaterialDefinitionRepresentation,1> { IfcMaterialDefinitionRepresentation() : Object("IfcMaterialDefinitionRepresentation") {}
+		Lazy< NotImplemented > RepresentedMaterial;
+    };
+
+    // C++ wrapper for IfcMeasureWithUnit
+    struct IfcMeasureWithUnit :  ObjectHelper<IfcMeasureWithUnit,2> { IfcMeasureWithUnit() : Object("IfcMeasureWithUnit") {}
+		IfcValue::Out ValueComponent;
+		IfcUnit::Out UnitComponent;
+    };
+
+    // C++ wrapper for IfcMechanicalFastener
+    struct IfcMechanicalFastener : IfcElementComponent, ObjectHelper<IfcMechanicalFastener,3> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {}
+		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+		Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
+		Maybe< IfcMechanicalFastenerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcMechanicalFastenerType
+    struct IfcMechanicalFastenerType : IfcElementComponentType, ObjectHelper<IfcMechanicalFastenerType,3> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {}
+		IfcMechanicalFastenerTypeEnum::Out PredefinedType;
+		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+		Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
+    };
+
+    // C++ wrapper for IfcMedicalDevice
+    struct IfcMedicalDevice : IfcFlowTerminal, ObjectHelper<IfcMedicalDevice,1> { IfcMedicalDevice() : Object("IfcMedicalDevice") {}
+		Maybe< IfcMedicalDeviceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcMedicalDeviceType
+    struct IfcMedicalDeviceType : IfcFlowTerminalType, ObjectHelper<IfcMedicalDeviceType,1> { IfcMedicalDeviceType() : Object("IfcMedicalDeviceType") {}
+		IfcMedicalDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcMember
+    struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,1> { IfcMember() : Object("IfcMember") {}
+		Maybe< IfcMemberTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcMemberStandardCase
+    struct IfcMemberStandardCase : IfcMember, ObjectHelper<IfcMemberStandardCase,0> { IfcMemberStandardCase() : Object("IfcMemberStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcMemberType
+    struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {}
+		IfcMemberTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcMirroredProfileDef
+    struct IfcMirroredProfileDef : IfcDerivedProfileDef, ObjectHelper<IfcMirroredProfileDef,0> { IfcMirroredProfileDef() : Object("IfcMirroredProfileDef") {}
+
+    };
+
+    // C++ wrapper for IfcMotorConnection
+    struct IfcMotorConnection : IfcEnergyConversionDevice, ObjectHelper<IfcMotorConnection,1> { IfcMotorConnection() : Object("IfcMotorConnection") {}
+		Maybe< IfcMotorConnectionTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcMotorConnectionType
+    struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {}
+		IfcMotorConnectionTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcOccupant
+    struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {}
+		Maybe< IfcOccupantTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcOffsetCurve2D
+    struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {}
+		Lazy< IfcCurve > BasisCurve;
+		IfcLengthMeasure::Out Distance;
+		IfcLogical::Out SelfIntersect;
+    };
+
+    // C++ wrapper for IfcOffsetCurve3D
+    struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {}
+		Lazy< IfcCurve > BasisCurve;
+		IfcLengthMeasure::Out Distance;
+		IfcLogical::Out SelfIntersect;
+		Lazy< IfcDirection > RefDirection;
+    };
+
+    // C++ wrapper for IfcOpenShell
+    struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {}
+
+    };
+
+    // C++ wrapper for IfcOpeningElement
+    struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,1> { IfcOpeningElement() : Object("IfcOpeningElement") {}
+		Maybe< IfcOpeningElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcOpeningStandardCase
+    struct IfcOpeningStandardCase : IfcOpeningElement, ObjectHelper<IfcOpeningStandardCase,0> { IfcOpeningStandardCase() : Object("IfcOpeningStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcOrientedEdge
+    struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {}
+		Lazy< IfcEdge > EdgeElement;
+		IfcBoolean::Out Orientation;
+    };
+
+    // C++ wrapper for IfcOuterBoundaryCurve
+    struct IfcOuterBoundaryCurve : IfcBoundaryCurve, ObjectHelper<IfcOuterBoundaryCurve,0> { IfcOuterBoundaryCurve() : Object("IfcOuterBoundaryCurve") {}
+
+    };
+
+    // C++ wrapper for IfcOutlet
+    struct IfcOutlet : IfcFlowTerminal, ObjectHelper<IfcOutlet,1> { IfcOutlet() : Object("IfcOutlet") {}
+		Maybe< IfcOutletTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcOutletType
+    struct IfcOutletType : IfcFlowTerminalType, ObjectHelper<IfcOutletType,1> { IfcOutletType() : Object("IfcOutletType") {}
+		IfcOutletTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPath
+    struct IfcPath : IfcTopologicalRepresentationItem, ObjectHelper<IfcPath,1> { IfcPath() : Object("IfcPath") {}
+		ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
+    };
+
+    // C++ wrapper for IfcPcurve
+    struct IfcPcurve : IfcCurve, ObjectHelper<IfcPcurve,2> { IfcPcurve() : Object("IfcPcurve") {}
+		Lazy< IfcSurface > BasisSurface;
+		Lazy< IfcCurve > ReferenceCurve;
+    };
+
+    // C++ wrapper for IfcPerformanceHistory
+    struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,2> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {}
+		IfcLabel::Out LifeCyclePhase;
+		Maybe< IfcPerformanceHistoryTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcPermit
+    struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,3> { IfcPermit() : Object("IfcPermit") {}
+		Maybe< IfcPermitTypeEnum::Out > PredefinedType;
+		Maybe< IfcLabel::Out > Status;
+		Maybe< IfcText::Out > LongDescription;
+    };
+
+    // C++ wrapper for IfcPile
+    struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {}
+		Maybe< IfcPileTypeEnum::Out > PredefinedType;
+		Maybe< IfcPileConstructionEnum::Out > ConstructionType;
+    };
+
+    // C++ wrapper for IfcPileType
+    struct IfcPileType : IfcBuildingElementType, ObjectHelper<IfcPileType,1> { IfcPileType() : Object("IfcPileType") {}
+		IfcPileTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPipeFitting
+    struct IfcPipeFitting : IfcFlowFitting, ObjectHelper<IfcPipeFitting,1> { IfcPipeFitting() : Object("IfcPipeFitting") {}
+		Maybe< IfcPipeFittingTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcPipeFittingType
+    struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {}
+		IfcPipeFittingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPipeSegment
+    struct IfcPipeSegment : IfcFlowSegment, ObjectHelper<IfcPipeSegment,1> { IfcPipeSegment() : Object("IfcPipeSegment") {}
+		Maybe< IfcPipeSegmentTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcPipeSegmentType
+    struct IfcPipeSegmentType : IfcFlowSegmentType, ObjectHelper<IfcPipeSegmentType,1> { IfcPipeSegmentType() : Object("IfcPipeSegmentType") {}
+		IfcPipeSegmentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPlanarExtent
+    struct IfcPlanarExtent : IfcGeometricRepresentationItem, ObjectHelper<IfcPlanarExtent,2> { IfcPlanarExtent() : Object("IfcPlanarExtent") {}
+		IfcLengthMeasure::Out SizeInX;
+		IfcLengthMeasure::Out SizeInY;
+    };
+
+    // C++ wrapper for IfcPlanarBox
+    struct IfcPlanarBox : IfcPlanarExtent, ObjectHelper<IfcPlanarBox,1> { IfcPlanarBox() : Object("IfcPlanarBox") {}
+		IfcAxis2Placement::Out Placement;
+    };
+
+    // C++ wrapper for IfcPlane
+    struct IfcPlane : IfcElementarySurface, ObjectHelper<IfcPlane,0> { IfcPlane() : Object("IfcPlane") {}
+
+    };
+
+    // C++ wrapper for IfcPlate
+    struct IfcPlate : IfcBuildingElement, ObjectHelper<IfcPlate,1> { IfcPlate() : Object("IfcPlate") {}
+		Maybe< IfcPlateTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcPlateStandardCase
+    struct IfcPlateStandardCase : IfcPlate, ObjectHelper<IfcPlateStandardCase,0> { IfcPlateStandardCase() : Object("IfcPlateStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcPlateType
+    struct IfcPlateType : IfcBuildingElementType, ObjectHelper<IfcPlateType,1> { IfcPlateType() : Object("IfcPlateType") {}
+		IfcPlateTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcPointOnCurve
+    struct IfcPointOnCurve : IfcPoint, ObjectHelper<IfcPointOnCurve,2> { IfcPointOnCurve() : Object("IfcPointOnCurve") {}
+		Lazy< IfcCurve > BasisCurve;
+		IfcParameterValue::Out PointParameter;
+    };
+
+    // C++ wrapper for IfcPointOnSurface
+    struct IfcPointOnSurface : IfcPoint, ObjectHelper<IfcPointOnSurface,3> { IfcPointOnSurface() : Object("IfcPointOnSurface") {}
+		Lazy< IfcSurface > BasisSurface;
+		IfcParameterValue::Out PointParameterU;
+		IfcParameterValue::Out PointParameterV;
+    };
+
+    // C++ wrapper for IfcPolyLoop
+    struct IfcPolyLoop : IfcLoop, ObjectHelper<IfcPolyLoop,1> { IfcPolyLoop() : Object("IfcPolyLoop") {}
+		ListOf< Lazy< IfcCartesianPoint >, 3, 0 > Polygon;
+    };
+
+    // C++ wrapper for IfcPolygonalBoundedHalfSpace
+    struct IfcPolygonalBoundedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcPolygonalBoundedHalfSpace,2> { IfcPolygonalBoundedHalfSpace() : Object("IfcPolygonalBoundedHalfSpace") {}
+		Lazy< IfcAxis2Placement3D > Position;
+		Lazy< IfcBoundedCurve > PolygonalBoundary;
+    };
+
+    // C++ wrapper for IfcTessellatedFaceSet
+    struct IfcTessellatedFaceSet : IfcTessellatedItem, ObjectHelper<IfcTessellatedFaceSet,1> { IfcTessellatedFaceSet() : Object("IfcTessellatedFaceSet") {}
+		Lazy< IfcCartesianPointList3D > Coordinates;
+    };
+
+    // C++ wrapper for IfcPolygonalFaceSet
+    struct IfcPolygonalFaceSet : IfcTessellatedFaceSet, ObjectHelper<IfcPolygonalFaceSet,3> { IfcPolygonalFaceSet() : Object("IfcPolygonalFaceSet") {}
+		Maybe< IfcBoolean::Out > Closed;
+		ListOf< Lazy< IfcIndexedPolygonalFace >, 1, 0 > Faces;
+		Maybe< ListOf< IfcPositiveInteger, 1, 0 >::Out > PnIndex;
+    };
+
+    // C++ wrapper for IfcPolyline
+    struct IfcPolyline : IfcBoundedCurve, ObjectHelper<IfcPolyline,1> { IfcPolyline() : Object("IfcPolyline") {}
+		ListOf< Lazy< IfcCartesianPoint >, 2, 0 > Points;
+    };
+
+    // C++ wrapper for IfcPresentationStyleAssignment
+    struct IfcPresentationStyleAssignment :  ObjectHelper<IfcPresentationStyleAssignment,1> { IfcPresentationStyleAssignment() : Object("IfcPresentationStyleAssignment") {}
+		ListOf< IfcPresentationStyleSelect, 1, 0 >::Out Styles;
+    };
+
+    // C++ wrapper for IfcProcedure
+    struct IfcProcedure : IfcProcess, ObjectHelper<IfcProcedure,1> { IfcProcedure() : Object("IfcProcedure") {}
+		Maybe< IfcProcedureTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcProcedureType
+    struct IfcProcedureType : IfcTypeProcess, ObjectHelper<IfcProcedureType,1> { IfcProcedureType() : Object("IfcProcedureType") {}
+		IfcProcedureTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProductDefinitionShape
+    struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {}
+
+    };
+
+    // C++ wrapper for IfcProject
+    struct IfcProject : IfcContext, ObjectHelper<IfcProject,0> { IfcProject() : Object("IfcProject") {}
+
+    };
+
+    // C++ wrapper for IfcProjectLibrary
+    struct IfcProjectLibrary : IfcContext, ObjectHelper<IfcProjectLibrary,0> { IfcProjectLibrary() : Object("IfcProjectLibrary") {}
+
+    };
+
+    // C++ wrapper for IfcProjectOrder
+    struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {}
+		Maybe< IfcProjectOrderTypeEnum::Out > PredefinedType;
+		Maybe< IfcLabel::Out > Status;
+		Maybe< IfcText::Out > LongDescription;
+    };
+
+    // C++ wrapper for IfcProjectionElement
+    struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,1> { IfcProjectionElement() : Object("IfcProjectionElement") {}
+		Maybe< IfcProjectionElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSimpleProperty
+    struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {}
+
+    };
+
+    // C++ wrapper for IfcPropertyBoundedValue
+    struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,4> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {}
+		Maybe< IfcValue::Out > UpperBoundValue;
+		Maybe< IfcValue::Out > LowerBoundValue;
+		Maybe< IfcUnit::Out > Unit;
+		Maybe< IfcValue::Out > SetPointValue;
+    };
+
+    // C++ wrapper for IfcPropertyEnumeratedValue
+    struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {}
+		Maybe< ListOf< IfcValue, 1, 0 >::Out > EnumerationValues;
+		Maybe< Lazy< NotImplemented > > EnumerationReference;
+    };
+
+    // C++ wrapper for IfcPropertyListValue
+    struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {}
+		Maybe< ListOf< IfcValue, 1, 0 >::Out > ListValues;
+		Maybe< IfcUnit::Out > Unit;
+    };
+
+    // C++ wrapper for IfcPropertyReferenceValue
+    struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {}
+		Maybe< IfcText::Out > UsageName;
+		Maybe< IfcObjectReferenceSelect::Out > PropertyReference;
+    };
+
+    // C++ wrapper for IfcPropertySet
+    struct IfcPropertySet : IfcPropertySetDefinition, ObjectHelper<IfcPropertySet,1> { IfcPropertySet() : Object("IfcPropertySet") {}
+		ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
+    };
+
+    // C++ wrapper for IfcPropertySingleValue
+    struct IfcPropertySingleValue : IfcSimpleProperty, ObjectHelper<IfcPropertySingleValue,2> { IfcPropertySingleValue() : Object("IfcPropertySingleValue") {}
+		Maybe< IfcValue::Out > NominalValue;
+		Maybe< IfcUnit::Out > Unit;
+    };
+
+    // C++ wrapper for IfcPropertyTableValue
+    struct IfcPropertyTableValue : IfcSimpleProperty, ObjectHelper<IfcPropertyTableValue,6> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {}
+		Maybe< ListOf< IfcValue, 1, 0 >::Out > DefiningValues;
+		Maybe< ListOf< IfcValue, 1, 0 >::Out > DefinedValues;
+		Maybe< IfcText::Out > Expression;
+		Maybe< IfcUnit::Out > DefiningUnit;
+		Maybe< IfcUnit::Out > DefinedUnit;
+		Maybe< IfcCurveInterpolationEnum::Out > CurveInterpolation;
+    };
+
+    // C++ wrapper for IfcProtectiveDevice
+    struct IfcProtectiveDevice : IfcFlowController, ObjectHelper<IfcProtectiveDevice,1> { IfcProtectiveDevice() : Object("IfcProtectiveDevice") {}
+		Maybe< IfcProtectiveDeviceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcProtectiveDeviceTrippingUnit
+    struct IfcProtectiveDeviceTrippingUnit : IfcDistributionControlElement, ObjectHelper<IfcProtectiveDeviceTrippingUnit,1> { IfcProtectiveDeviceTrippingUnit() : Object("IfcProtectiveDeviceTrippingUnit") {}
+		Maybe< IfcProtectiveDeviceTrippingUnitTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcProtectiveDeviceTrippingUnitType
+    struct IfcProtectiveDeviceTrippingUnitType : IfcDistributionControlElementType, ObjectHelper<IfcProtectiveDeviceTrippingUnitType,1> { IfcProtectiveDeviceTrippingUnitType() : Object("IfcProtectiveDeviceTrippingUnitType") {}
+		IfcProtectiveDeviceTrippingUnitTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProtectiveDeviceType
+    struct IfcProtectiveDeviceType : IfcFlowControllerType, ObjectHelper<IfcProtectiveDeviceType,1> { IfcProtectiveDeviceType() : Object("IfcProtectiveDeviceType") {}
+		IfcProtectiveDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProxy
+    struct IfcProxy : IfcProduct, ObjectHelper<IfcProxy,2> { IfcProxy() : Object("IfcProxy") {}
+		IfcObjectTypeEnum::Out ProxyType;
+		Maybe< IfcLabel::Out > Tag;
+    };
+
+    // C++ wrapper for IfcPump
+    struct IfcPump : IfcFlowMovingDevice, ObjectHelper<IfcPump,1> { IfcPump() : Object("IfcPump") {}
+		Maybe< IfcPumpTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcPumpType
+    struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {}
+		IfcPumpTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRailing
+    struct IfcRailing : IfcBuildingElement, ObjectHelper<IfcRailing,1> { IfcRailing() : Object("IfcRailing") {}
+		Maybe< IfcRailingTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcRailingType
+    struct IfcRailingType : IfcBuildingElementType, ObjectHelper<IfcRailingType,1> { IfcRailingType() : Object("IfcRailingType") {}
+		IfcRailingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRamp
+    struct IfcRamp : IfcBuildingElement, ObjectHelper<IfcRamp,1> { IfcRamp() : Object("IfcRamp") {}
+		Maybe< IfcRampTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcRampFlight
+    struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,1> { IfcRampFlight() : Object("IfcRampFlight") {}
+		Maybe< IfcRampFlightTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcRampFlightType
+    struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {}
+		IfcRampFlightTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRampType
+    struct IfcRampType : IfcBuildingElementType, ObjectHelper<IfcRampType,1> { IfcRampType() : Object("IfcRampType") {}
+		IfcRampTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRationalBSplineCurveWithKnots
+    struct IfcRationalBSplineCurveWithKnots : IfcBSplineCurveWithKnots, ObjectHelper<IfcRationalBSplineCurveWithKnots,1> { IfcRationalBSplineCurveWithKnots() : Object("IfcRationalBSplineCurveWithKnots") {}
+		ListOf< IfcReal, 2, 0 >::Out WeightsData;
+    };
+
+    // C++ wrapper for IfcRationalBSplineSurfaceWithKnots
+    struct IfcRationalBSplineSurfaceWithKnots : IfcBSplineSurfaceWithKnots, ObjectHelper<IfcRationalBSplineSurfaceWithKnots,0> { IfcRationalBSplineSurfaceWithKnots() : Object("IfcRationalBSplineSurfaceWithKnots") {}
+
+    };
+
+    // C++ wrapper for IfcRectangleProfileDef
+    struct IfcRectangleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcRectangleProfileDef,2> { IfcRectangleProfileDef() : Object("IfcRectangleProfileDef") {}
+		IfcPositiveLengthMeasure::Out XDim;
+		IfcPositiveLengthMeasure::Out YDim;
+    };
+
+    // C++ wrapper for IfcRectangleHollowProfileDef
+    struct IfcRectangleHollowProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRectangleHollowProfileDef,3> { IfcRectangleHollowProfileDef() : Object("IfcRectangleHollowProfileDef") {}
+		IfcPositiveLengthMeasure::Out WallThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > InnerFilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > OuterFilletRadius;
+    };
+
+    // C++ wrapper for IfcRectangularPyramid
+    struct IfcRectangularPyramid : IfcCsgPrimitive3D, ObjectHelper<IfcRectangularPyramid,3> { IfcRectangularPyramid() : Object("IfcRectangularPyramid") {}
+		IfcPositiveLengthMeasure::Out XLength;
+		IfcPositiveLengthMeasure::Out YLength;
+		IfcPositiveLengthMeasure::Out Height;
+    };
+
+    // C++ wrapper for IfcRectangularTrimmedSurface
+    struct IfcRectangularTrimmedSurface : IfcBoundedSurface, ObjectHelper<IfcRectangularTrimmedSurface,7> { IfcRectangularTrimmedSurface() : Object("IfcRectangularTrimmedSurface") {}
+		Lazy< IfcSurface > BasisSurface;
+		IfcParameterValue::Out U1;
+		IfcParameterValue::Out V1;
+		IfcParameterValue::Out U2;
+		IfcParameterValue::Out V2;
+		IfcBoolean::Out Usense;
+		IfcBoolean::Out Vsense;
+    };
+
+    // C++ wrapper for IfcReinforcingElement
+    struct IfcReinforcingElement : IfcElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {}
+		Maybe< IfcLabel::Out > SteelGrade;
+    };
+
+    // C++ wrapper for IfcReinforcingBar
+    struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {}
+		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
+		Maybe< IfcPositiveLengthMeasure::Out > BarLength;
+		Maybe< IfcReinforcingBarTypeEnum::Out > PredefinedType;
+		Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
+    };
+
+    // C++ wrapper for IfcReinforcingElementType
+    struct IfcReinforcingElementType : IfcElementComponentType, ObjectHelper<IfcReinforcingElementType,0> { IfcReinforcingElementType() : Object("IfcReinforcingElementType") {}
+
+    };
+
+    // C++ wrapper for IfcReinforcingBarType
+    struct IfcReinforcingBarType : IfcReinforcingElementType, ObjectHelper<IfcReinforcingBarType,7> { IfcReinforcingBarType() : Object("IfcReinforcingBarType") {}
+		IfcReinforcingBarTypeEnum::Out PredefinedType;
+		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
+		Maybe< IfcPositiveLengthMeasure::Out > BarLength;
+		Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
+		Maybe< IfcLabel::Out > BendingShapeCode;
+		Maybe< ListOf< IfcBendingParameterSelect, 1, 0 >::Out > BendingParameters;
+    };
+
+    // C++ wrapper for IfcReinforcingMesh
+    struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,9> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {}
+		Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
+		Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
+		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarNominalDiameter;
+		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarNominalDiameter;
+		Maybe< IfcAreaMeasure::Out > LongitudinalBarCrossSectionArea;
+		Maybe< IfcAreaMeasure::Out > TransverseBarCrossSectionArea;
+		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarSpacing;
+		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarSpacing;
+		Maybe< IfcReinforcingMeshTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcReinforcingMeshType
+    struct IfcReinforcingMeshType : IfcReinforcingElementType, ObjectHelper<IfcReinforcingMeshType,11> { IfcReinforcingMeshType() : Object("IfcReinforcingMeshType") {}
+		IfcReinforcingMeshTypeEnum::Out PredefinedType;
+		Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
+		Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
+		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarNominalDiameter;
+		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarNominalDiameter;
+		Maybe< IfcAreaMeasure::Out > LongitudinalBarCrossSectionArea;
+		Maybe< IfcAreaMeasure::Out > TransverseBarCrossSectionArea;
+		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarSpacing;
+		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarSpacing;
+		Maybe< IfcLabel::Out > BendingShapeCode;
+		Maybe< ListOf< IfcBendingParameterSelect, 1, 0 >::Out > BendingParameters;
+    };
+
+    // C++ wrapper for IfcRelationship
+    struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {}
+
+    };
+
+    // C++ wrapper for IfcRelDecomposes
+    struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,0> { IfcRelDecomposes() : Object("IfcRelDecomposes") {}
+
+    };
+
+    // C++ wrapper for IfcRelAggregates
+    struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,2> { IfcRelAggregates() : Object("IfcRelAggregates") {}
+		Lazy< IfcObjectDefinition > RelatingObject;
+		ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
+    };
+
+    // C++ wrapper for IfcRelConnects
+    struct IfcRelConnects : IfcRelationship, ObjectHelper<IfcRelConnects,0> { IfcRelConnects() : Object("IfcRelConnects") {}
+
+    };
+
+    // C++ wrapper for IfcRelContainedInSpatialStructure
+    struct IfcRelContainedInSpatialStructure : IfcRelConnects, ObjectHelper<IfcRelContainedInSpatialStructure,2> { IfcRelContainedInSpatialStructure() : Object("IfcRelContainedInSpatialStructure") {}
+		ListOf< Lazy< IfcProduct >, 1, 0 > RelatedElements;
+		Lazy< IfcSpatialElement > RelatingStructure;
+    };
+
+    // C++ wrapper for IfcRelDefines
+    struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,0> { IfcRelDefines() : Object("IfcRelDefines") {}
+
+    };
+
+    // C++ wrapper for IfcRelDefinesByProperties
+    struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,2> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {}
+		ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
+		IfcPropertySetDefinitionSelect::Out RelatingPropertyDefinition;
+    };
+
+    // C++ wrapper for IfcRelFillsElement
+    struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {}
+		Lazy< IfcOpeningElement > RelatingOpeningElement;
+		Lazy< IfcElement > RelatedBuildingElement;
+    };
+
+    // C++ wrapper for IfcRelVoidsElement
+    struct IfcRelVoidsElement : IfcRelDecomposes, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {}
+		Lazy< IfcElement > RelatingBuildingElement;
+		Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement;
+    };
+
+    // C++ wrapper for IfcReparametrisedCompositeCurveSegment
+    struct IfcReparametrisedCompositeCurveSegment : IfcCompositeCurveSegment, ObjectHelper<IfcReparametrisedCompositeCurveSegment,1> { IfcReparametrisedCompositeCurveSegment() : Object("IfcReparametrisedCompositeCurveSegment") {}
+		IfcParameterValue::Out ParamLength;
+    };
+
+    // C++ wrapper for IfcRepresentation
+    struct IfcRepresentation :  ObjectHelper<IfcRepresentation,4> { IfcRepresentation() : Object("IfcRepresentation") {}
+		Lazy< IfcRepresentationContext > ContextOfItems;
+		Maybe< IfcLabel::Out > RepresentationIdentifier;
+		Maybe< IfcLabel::Out > RepresentationType;
+		ListOf< Lazy< IfcRepresentationItem >, 1, 0 > Items;
+    };
+
+    // C++ wrapper for IfcRepresentationMap
+    struct IfcRepresentationMap :  ObjectHelper<IfcRepresentationMap,2> { IfcRepresentationMap() : Object("IfcRepresentationMap") {}
+		IfcAxis2Placement::Out MappingOrigin;
+		Lazy< IfcRepresentation > MappedRepresentation;
+    };
+
+    // C++ wrapper for IfcRevolvedAreaSolid
+    struct IfcRevolvedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcRevolvedAreaSolid,2> { IfcRevolvedAreaSolid() : Object("IfcRevolvedAreaSolid") {}
+		Lazy< IfcAxis1Placement > Axis;
+		IfcPlaneAngleMeasure::Out Angle;
+    };
+
+    // C++ wrapper for IfcRevolvedAreaSolidTapered
+    struct IfcRevolvedAreaSolidTapered : IfcRevolvedAreaSolid, ObjectHelper<IfcRevolvedAreaSolidTapered,1> { IfcRevolvedAreaSolidTapered() : Object("IfcRevolvedAreaSolidTapered") {}
+		Lazy< IfcProfileDef > EndSweptArea;
+    };
+
+    // C++ wrapper for IfcRightCircularCone
+    struct IfcRightCircularCone : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCone,2> { IfcRightCircularCone() : Object("IfcRightCircularCone") {}
+		IfcPositiveLengthMeasure::Out Height;
+		IfcPositiveLengthMeasure::Out BottomRadius;
+    };
+
+    // C++ wrapper for IfcRightCircularCylinder
+    struct IfcRightCircularCylinder : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCylinder,2> { IfcRightCircularCylinder() : Object("IfcRightCircularCylinder") {}
+		IfcPositiveLengthMeasure::Out Height;
+		IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // C++ wrapper for IfcRoof
+    struct IfcRoof : IfcBuildingElement, ObjectHelper<IfcRoof,1> { IfcRoof() : Object("IfcRoof") {}
+		Maybe< IfcRoofTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcRoofType
+    struct IfcRoofType : IfcBuildingElementType, ObjectHelper<IfcRoofType,1> { IfcRoofType() : Object("IfcRoofType") {}
+		IfcRoofTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRoundedRectangleProfileDef
+    struct IfcRoundedRectangleProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRoundedRectangleProfileDef,1> { IfcRoundedRectangleProfileDef() : Object("IfcRoundedRectangleProfileDef") {}
+		IfcPositiveLengthMeasure::Out RoundingRadius;
+    };
+
+    // C++ wrapper for IfcSIUnit
+    struct IfcSIUnit : IfcNamedUnit, ObjectHelper<IfcSIUnit,2> { IfcSIUnit() : Object("IfcSIUnit") {}
+		Maybe< IfcSIPrefix::Out > Prefix;
+		IfcSIUnitName::Out Name;
+    };
+
+    // C++ wrapper for IfcSanitaryTerminal
+    struct IfcSanitaryTerminal : IfcFlowTerminal, ObjectHelper<IfcSanitaryTerminal,1> { IfcSanitaryTerminal() : Object("IfcSanitaryTerminal") {}
+		Maybe< IfcSanitaryTerminalTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSanitaryTerminalType
+    struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {}
+		IfcSanitaryTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSeamCurve
+    struct IfcSeamCurve : IfcSurfaceCurve, ObjectHelper<IfcSeamCurve,0> { IfcSeamCurve() : Object("IfcSeamCurve") {}
+
+    };
+
+    // C++ wrapper for IfcSectionedSpine
+    struct IfcSectionedSpine : IfcGeometricRepresentationItem, ObjectHelper<IfcSectionedSpine,3> { IfcSectionedSpine() : Object("IfcSectionedSpine") {}
+		Lazy< IfcCompositeCurve > SpineCurve;
+		ListOf< Lazy< IfcProfileDef >, 2, 0 > CrossSections;
+		ListOf< Lazy< IfcAxis2Placement3D >, 2, 0 > CrossSectionPositions;
+    };
+
+    // C++ wrapper for IfcSensor
+    struct IfcSensor : IfcDistributionControlElement, ObjectHelper<IfcSensor,1> { IfcSensor() : Object("IfcSensor") {}
+		Maybe< IfcSensorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSensorType
+    struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {}
+		IfcSensorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcShadingDevice
+    struct IfcShadingDevice : IfcBuildingElement, ObjectHelper<IfcShadingDevice,1> { IfcShadingDevice() : Object("IfcShadingDevice") {}
+		Maybe< IfcShadingDeviceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcShadingDeviceType
+    struct IfcShadingDeviceType : IfcBuildingElementType, ObjectHelper<IfcShadingDeviceType,1> { IfcShadingDeviceType() : Object("IfcShadingDeviceType") {}
+		IfcShadingDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcShapeModel
+    struct IfcShapeModel : IfcRepresentation, ObjectHelper<IfcShapeModel,0> { IfcShapeModel() : Object("IfcShapeModel") {}
+
+    };
+
+    // C++ wrapper for IfcShapeRepresentation
+    struct IfcShapeRepresentation : IfcShapeModel, ObjectHelper<IfcShapeRepresentation,0> { IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
+
+    };
+
+    // C++ wrapper for IfcShellBasedSurfaceModel
+    struct IfcShellBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcShellBasedSurfaceModel,1> { IfcShellBasedSurfaceModel() : Object("IfcShellBasedSurfaceModel") {}
+		ListOf< IfcShell, 1, 0 >::Out SbsmBoundary;
+    };
+
+    // C++ wrapper for IfcSite
+    struct IfcSite : IfcSpatialStructureElement, ObjectHelper<IfcSite,5> { IfcSite() : Object("IfcSite") {}
+		Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLatitude;
+		Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLongitude;
+		Maybe< IfcLengthMeasure::Out > RefElevation;
+		Maybe< IfcLabel::Out > LandTitleNumber;
+		Maybe< Lazy< NotImplemented > > SiteAddress;
+    };
+
+    // C++ wrapper for IfcSlab
+    struct IfcSlab : IfcBuildingElement, ObjectHelper<IfcSlab,1> { IfcSlab() : Object("IfcSlab") {}
+		Maybe< IfcSlabTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSlabElementedCase
+    struct IfcSlabElementedCase : IfcSlab, ObjectHelper<IfcSlabElementedCase,0> { IfcSlabElementedCase() : Object("IfcSlabElementedCase") {}
+
+    };
+
+    // C++ wrapper for IfcSlabStandardCase
+    struct IfcSlabStandardCase : IfcSlab, ObjectHelper<IfcSlabStandardCase,0> { IfcSlabStandardCase() : Object("IfcSlabStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcSlabType
+    struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {}
+		IfcSlabTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSolarDevice
+    struct IfcSolarDevice : IfcEnergyConversionDevice, ObjectHelper<IfcSolarDevice,1> { IfcSolarDevice() : Object("IfcSolarDevice") {}
+		Maybe< IfcSolarDeviceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSolarDeviceType
+    struct IfcSolarDeviceType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSolarDeviceType,1> { IfcSolarDeviceType() : Object("IfcSolarDeviceType") {}
+		IfcSolarDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSpace
+    struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {}
+		Maybe< IfcSpaceTypeEnum::Out > PredefinedType;
+		Maybe< IfcLengthMeasure::Out > ElevationWithFlooring;
+    };
+
+    // C++ wrapper for IfcSpaceHeater
+    struct IfcSpaceHeater : IfcFlowTerminal, ObjectHelper<IfcSpaceHeater,1> { IfcSpaceHeater() : Object("IfcSpaceHeater") {}
+		Maybe< IfcSpaceHeaterTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSpaceHeaterType
+    struct IfcSpaceHeaterType : IfcFlowTerminalType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {}
+		IfcSpaceHeaterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSpatialElementType
+    struct IfcSpatialElementType : IfcTypeProduct, ObjectHelper<IfcSpatialElementType,1> { IfcSpatialElementType() : Object("IfcSpatialElementType") {}
+		Maybe< IfcLabel::Out > ElementType;
+    };
+
+    // C++ wrapper for IfcSpatialStructureElementType
+    struct IfcSpatialStructureElementType : IfcSpatialElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {}
+
+    };
+
+    // C++ wrapper for IfcSpaceType
+    struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,2> { IfcSpaceType() : Object("IfcSpaceType") {}
+		IfcSpaceTypeEnum::Out PredefinedType;
+		Maybe< IfcLabel::Out > LongName;
+    };
+
+    // C++ wrapper for IfcSpatialZone
+    struct IfcSpatialZone : IfcSpatialElement, ObjectHelper<IfcSpatialZone,1> { IfcSpatialZone() : Object("IfcSpatialZone") {}
+		Maybe< IfcSpatialZoneTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSpatialZoneType
+    struct IfcSpatialZoneType : IfcSpatialElementType, ObjectHelper<IfcSpatialZoneType,2> { IfcSpatialZoneType() : Object("IfcSpatialZoneType") {}
+		IfcSpatialZoneTypeEnum::Out PredefinedType;
+		Maybe< IfcLabel::Out > LongName;
+    };
+
+    // C++ wrapper for IfcSphere
+    struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {}
+		IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // C++ wrapper for IfcSphericalSurface
+    struct IfcSphericalSurface : IfcElementarySurface, ObjectHelper<IfcSphericalSurface,1> { IfcSphericalSurface() : Object("IfcSphericalSurface") {}
+		IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // C++ wrapper for IfcStackTerminal
+    struct IfcStackTerminal : IfcFlowTerminal, ObjectHelper<IfcStackTerminal,1> { IfcStackTerminal() : Object("IfcStackTerminal") {}
+		Maybe< IfcStackTerminalTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcStackTerminalType
+    struct IfcStackTerminalType : IfcFlowTerminalType, ObjectHelper<IfcStackTerminalType,1> { IfcStackTerminalType() : Object("IfcStackTerminalType") {}
+		IfcStackTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStair
+    struct IfcStair : IfcBuildingElement, ObjectHelper<IfcStair,1> { IfcStair() : Object("IfcStair") {}
+		Maybe< IfcStairTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcStairFlight
+    struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,5> { IfcStairFlight() : Object("IfcStairFlight") {}
+		Maybe< IfcInteger::Out > NumberOfRisers;
+		Maybe< IfcInteger::Out > NumberOfTreads;
+		Maybe< IfcPositiveLengthMeasure::Out > RiserHeight;
+		Maybe< IfcPositiveLengthMeasure::Out > TreadLength;
+		Maybe< IfcStairFlightTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcStairFlightType
+    struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {}
+		IfcStairFlightTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStairType
+    struct IfcStairType : IfcBuildingElementType, ObjectHelper<IfcStairType,1> { IfcStairType() : Object("IfcStairType") {}
+		IfcStairTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStructuralActivity
+    struct IfcStructuralActivity : IfcProduct, ObjectHelper<IfcStructuralActivity,2> { IfcStructuralActivity() : Object("IfcStructuralActivity") {}
+		Lazy< NotImplemented > AppliedLoad;
+		IfcGlobalOrLocalEnum::Out GlobalOrLocal;
+    };
+
+    // C++ wrapper for IfcStructuralAction
+    struct IfcStructuralAction : IfcStructuralActivity, ObjectHelper<IfcStructuralAction,1> { IfcStructuralAction() : Object("IfcStructuralAction") {}
+		Maybe< IfcBoolean::Out > DestabilizingLoad;
+    };
+
+    // C++ wrapper for IfcStructuralAnalysisModel
+    struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,5> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {}
+		IfcAnalysisModelTypeEnum::Out PredefinedType;
+		Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane;
+		Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy;
+		Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults;
+		Maybe< Lazy< IfcObjectPlacement > > SharedPlacement;
+    };
+
+    // C++ wrapper for IfcStructuralItem
+    struct IfcStructuralItem : IfcProduct, ObjectHelper<IfcStructuralItem,0> { IfcStructuralItem() : Object("IfcStructuralItem") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralConnection
+    struct IfcStructuralConnection : IfcStructuralItem, ObjectHelper<IfcStructuralConnection,1> { IfcStructuralConnection() : Object("IfcStructuralConnection") {}
+		Maybe< Lazy< NotImplemented > > AppliedCondition;
+    };
+
+    // C++ wrapper for IfcStructuralCurveAction
+    struct IfcStructuralCurveAction : IfcStructuralAction, ObjectHelper<IfcStructuralCurveAction,2> { IfcStructuralCurveAction() : Object("IfcStructuralCurveAction") {}
+		Maybe< IfcProjectedOrTrueLengthEnum::Out > ProjectedOrTrue;
+		IfcStructuralCurveActivityTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStructuralCurveConnection
+    struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,1> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {}
+		Lazy< IfcDirection > Axis;
+    };
+
+    // C++ wrapper for IfcStructuralMember
+    struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralCurveMember
+    struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,2> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {}
+		IfcStructuralCurveMemberTypeEnum::Out PredefinedType;
+		Lazy< IfcDirection > Axis;
+    };
+
+    // C++ wrapper for IfcStructuralCurveMemberVarying
+    struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralReaction
+    struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralCurveReaction
+    struct IfcStructuralCurveReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralCurveReaction,1> { IfcStructuralCurveReaction() : Object("IfcStructuralCurveReaction") {}
+		IfcStructuralCurveActivityTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStructuralLinearAction
+    struct IfcStructuralLinearAction : IfcStructuralCurveAction, ObjectHelper<IfcStructuralLinearAction,0> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralLoadGroup
+    struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {}
+		IfcLoadGroupTypeEnum::Out PredefinedType;
+		IfcActionTypeEnum::Out ActionType;
+		IfcActionSourceTypeEnum::Out ActionSource;
+		Maybe< IfcRatioMeasure::Out > Coefficient;
+		Maybe< IfcLabel::Out > Purpose;
+    };
+
+    // C++ wrapper for IfcStructuralLoadCase
+    struct IfcStructuralLoadCase : IfcStructuralLoadGroup, ObjectHelper<IfcStructuralLoadCase,1> { IfcStructuralLoadCase() : Object("IfcStructuralLoadCase") {}
+		Maybe< ListOf< IfcRatioMeasure, 3, 3 >::Out > SelfWeightCoefficients;
+    };
+
+    // C++ wrapper for IfcStructuralSurfaceAction
+    struct IfcStructuralSurfaceAction : IfcStructuralAction, ObjectHelper<IfcStructuralSurfaceAction,2> { IfcStructuralSurfaceAction() : Object("IfcStructuralSurfaceAction") {}
+		Maybe< IfcProjectedOrTrueLengthEnum::Out > ProjectedOrTrue;
+		IfcStructuralSurfaceActivityTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStructuralPlanarAction
+    struct IfcStructuralPlanarAction : IfcStructuralSurfaceAction, ObjectHelper<IfcStructuralPlanarAction,0> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralPointAction
+    struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralPointConnection
+    struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,1> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {}
+		Maybe< Lazy< IfcAxis2Placement3D > > ConditionCoordinateSystem;
+    };
+
+    // C++ wrapper for IfcStructuralPointReaction
+    struct IfcStructuralPointReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralPointReaction,0> { IfcStructuralPointReaction() : Object("IfcStructuralPointReaction") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralResultGroup
+    struct IfcStructuralResultGroup : IfcGroup, ObjectHelper<IfcStructuralResultGroup,3> { IfcStructuralResultGroup() : Object("IfcStructuralResultGroup") {}
+		IfcAnalysisTheoryTypeEnum::Out TheoryType;
+		Maybe< Lazy< IfcStructuralLoadGroup > > ResultForLoadGroup;
+		IfcBoolean::Out IsLinear;
+    };
+
+    // C++ wrapper for IfcStructuralSurfaceConnection
+    struct IfcStructuralSurfaceConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralSurfaceConnection,0> { IfcStructuralSurfaceConnection() : Object("IfcStructuralSurfaceConnection") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralSurfaceMember
+    struct IfcStructuralSurfaceMember : IfcStructuralMember, ObjectHelper<IfcStructuralSurfaceMember,2> { IfcStructuralSurfaceMember() : Object("IfcStructuralSurfaceMember") {}
+		IfcStructuralSurfaceMemberTypeEnum::Out PredefinedType;
+		Maybe< IfcPositiveLengthMeasure::Out > Thickness;
+    };
+
+    // C++ wrapper for IfcStructuralSurfaceMemberVarying
+    struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,0> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralSurfaceReaction
+    struct IfcStructuralSurfaceReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralSurfaceReaction,1> { IfcStructuralSurfaceReaction() : Object("IfcStructuralSurfaceReaction") {}
+		IfcStructuralSurfaceActivityTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStyleModel
+    struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {}
+
+    };
+
+    // C++ wrapper for IfcStyledItem
+    struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {}
+		Maybe< Lazy< IfcRepresentationItem > > Item;
+		ListOf< IfcStyleAssignmentSelect, 1, 0 >::Out Styles;
+		Maybe< IfcLabel::Out > Name;
+    };
+
+    // C++ wrapper for IfcStyledRepresentation
+    struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {}
+
+    };
+
+    // C++ wrapper for IfcSubContractResource
+    struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,1> { IfcSubContractResource() : Object("IfcSubContractResource") {}
+		Maybe< IfcSubContractResourceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSubContractResourceType
+    struct IfcSubContractResourceType : IfcConstructionResourceType, ObjectHelper<IfcSubContractResourceType,1> { IfcSubContractResourceType() : Object("IfcSubContractResourceType") {}
+		IfcSubContractResourceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSubedge
+    struct IfcSubedge : IfcEdge, ObjectHelper<IfcSubedge,1> { IfcSubedge() : Object("IfcSubedge") {}
+		Lazy< IfcEdge > ParentEdge;
+    };
+
+    // C++ wrapper for IfcSurfaceCurveSweptAreaSolid
+    struct IfcSurfaceCurveSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4> { IfcSurfaceCurveSweptAreaSolid() : Object("IfcSurfaceCurveSweptAreaSolid") {}
+		Lazy< IfcCurve > Directrix;
+		Maybe< IfcParameterValue::Out > StartParam;
+		Maybe< IfcParameterValue::Out > EndParam;
+		Lazy< IfcSurface > ReferenceSurface;
+    };
+
+    // C++ wrapper for IfcSurfaceFeature
+    struct IfcSurfaceFeature : IfcFeatureElement, ObjectHelper<IfcSurfaceFeature,1> { IfcSurfaceFeature() : Object("IfcSurfaceFeature") {}
+		Maybe< IfcSurfaceFeatureTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSweptSurface
+    struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {}
+		Lazy< IfcProfileDef > SweptCurve;
+		Maybe< Lazy< IfcAxis2Placement3D > > Position;
+    };
+
+    // C++ wrapper for IfcSurfaceOfLinearExtrusion
+    struct IfcSurfaceOfLinearExtrusion : IfcSweptSurface, ObjectHelper<IfcSurfaceOfLinearExtrusion,2> { IfcSurfaceOfLinearExtrusion() : Object("IfcSurfaceOfLinearExtrusion") {}
+		Lazy< IfcDirection > ExtrudedDirection;
+		IfcLengthMeasure::Out Depth;
+    };
+
+    // C++ wrapper for IfcSurfaceOfRevolution
+    struct IfcSurfaceOfRevolution : IfcSweptSurface, ObjectHelper<IfcSurfaceOfRevolution,1> { IfcSurfaceOfRevolution() : Object("IfcSurfaceOfRevolution") {}
+		Lazy< IfcAxis1Placement > AxisPosition;
+    };
+
+    // C++ wrapper for IfcSurfaceStyle
+    struct IfcSurfaceStyle : IfcPresentationStyle, ObjectHelper<IfcSurfaceStyle,2> { IfcSurfaceStyle() : Object("IfcSurfaceStyle") {}
+		IfcSurfaceSide::Out Side;
+		ListOf< IfcSurfaceStyleElementSelect, 1, 5 >::Out Styles;
+    };
+
+    // C++ wrapper for IfcSurfaceStyleShading
+    struct IfcSurfaceStyleShading : IfcPresentationItem, ObjectHelper<IfcSurfaceStyleShading,2> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {}
+		Lazy< IfcColourRgb > SurfaceColour;
+		Maybe< IfcNormalisedRatioMeasure::Out > Transparency;
+    };
+
+    // C++ wrapper for IfcSurfaceStyleRendering
+    struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,7> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {}
+		Maybe< IfcColourOrFactor::Out > DiffuseColour;
+		Maybe< IfcColourOrFactor::Out > TransmissionColour;
+		Maybe< IfcColourOrFactor::Out > DiffuseTransmissionColour;
+		Maybe< IfcColourOrFactor::Out > ReflectionColour;
+		Maybe< IfcColourOrFactor::Out > SpecularColour;
+		Maybe< IfcSpecularHighlightSelect::Out > SpecularHighlight;
+		IfcReflectanceMethodEnum::Out ReflectanceMethod;
+    };
+
+    // C++ wrapper for IfcSurfaceStyleWithTextures
+    struct IfcSurfaceStyleWithTextures : IfcPresentationItem, ObjectHelper<IfcSurfaceStyleWithTextures,1> { IfcSurfaceStyleWithTextures() : Object("IfcSurfaceStyleWithTextures") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > Textures;
+    };
+
+    // C++ wrapper for IfcSweptDiskSolid
+    struct IfcSweptDiskSolid : IfcSolidModel, ObjectHelper<IfcSweptDiskSolid,5> { IfcSweptDiskSolid() : Object("IfcSweptDiskSolid") {}
+		Lazy< IfcCurve > Directrix;
+		IfcPositiveLengthMeasure::Out Radius;
+		Maybe< IfcPositiveLengthMeasure::Out > InnerRadius;
+		Maybe< IfcParameterValue::Out > StartParam;
+		Maybe< IfcParameterValue::Out > EndParam;
+    };
+
+    // C++ wrapper for IfcSweptDiskSolidPolygonal
+    struct IfcSweptDiskSolidPolygonal : IfcSweptDiskSolid, ObjectHelper<IfcSweptDiskSolidPolygonal,1> { IfcSweptDiskSolidPolygonal() : Object("IfcSweptDiskSolidPolygonal") {}
+		Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
+    };
+
+    // C++ wrapper for IfcSwitchingDevice
+    struct IfcSwitchingDevice : IfcFlowController, ObjectHelper<IfcSwitchingDevice,1> { IfcSwitchingDevice() : Object("IfcSwitchingDevice") {}
+		Maybe< IfcSwitchingDeviceTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSwitchingDeviceType
+    struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {}
+		IfcSwitchingDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSystemFurnitureElement
+    struct IfcSystemFurnitureElement : IfcFurnishingElement, ObjectHelper<IfcSystemFurnitureElement,1> { IfcSystemFurnitureElement() : Object("IfcSystemFurnitureElement") {}
+		Maybe< IfcSystemFurnitureElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcSystemFurnitureElementType
+    struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,1> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {}
+		Maybe< IfcSystemFurnitureElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTShapeProfileDef
+    struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,9> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out Depth;
+		IfcPositiveLengthMeasure::Out FlangeWidth;
+		IfcPositiveLengthMeasure::Out WebThickness;
+		IfcPositiveLengthMeasure::Out FlangeThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FlangeEdgeRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > WebEdgeRadius;
+		Maybe< IfcPlaneAngleMeasure::Out > WebSlope;
+		Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
+    };
+
+    // C++ wrapper for IfcTank
+    struct IfcTank : IfcFlowStorageDevice, ObjectHelper<IfcTank,1> { IfcTank() : Object("IfcTank") {}
+		Maybe< IfcTankTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTankType
+    struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {}
+		IfcTankTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcTask
+    struct IfcTask : IfcProcess, ObjectHelper<IfcTask,6> { IfcTask() : Object("IfcTask") {}
+		Maybe< IfcLabel::Out > Status;
+		Maybe< IfcLabel::Out > WorkMethod;
+		IfcBoolean::Out IsMilestone;
+		Maybe< IfcInteger::Out > Priority;
+		Maybe< Lazy< NotImplemented > > TaskTime;
+		Maybe< IfcTaskTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTaskType
+    struct IfcTaskType : IfcTypeProcess, ObjectHelper<IfcTaskType,2> { IfcTaskType() : Object("IfcTaskType") {}
+		IfcTaskTypeEnum::Out PredefinedType;
+		Maybe< IfcLabel::Out > WorkMethod;
+    };
+
+    // C++ wrapper for IfcTendon
+    struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {}
+		Maybe< IfcTendonTypeEnum::Out > PredefinedType;
+		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
+		Maybe< IfcForceMeasure::Out > TensionForce;
+		Maybe< IfcPressureMeasure::Out > PreStress;
+		Maybe< IfcNormalisedRatioMeasure::Out > FrictionCoefficient;
+		Maybe< IfcPositiveLengthMeasure::Out > AnchorageSlip;
+		Maybe< IfcPositiveLengthMeasure::Out > MinCurvatureRadius;
+    };
+
+    // C++ wrapper for IfcTendonAnchor
+    struct IfcTendonAnchor : IfcReinforcingElement, ObjectHelper<IfcTendonAnchor,1> { IfcTendonAnchor() : Object("IfcTendonAnchor") {}
+		Maybe< IfcTendonAnchorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTendonAnchorType
+    struct IfcTendonAnchorType : IfcReinforcingElementType, ObjectHelper<IfcTendonAnchorType,1> { IfcTendonAnchorType() : Object("IfcTendonAnchorType") {}
+		IfcTendonAnchorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcTendonType
+    struct IfcTendonType : IfcReinforcingElementType, ObjectHelper<IfcTendonType,4> { IfcTendonType() : Object("IfcTendonType") {}
+		IfcTendonTypeEnum::Out PredefinedType;
+		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
+		Maybe< IfcPositiveLengthMeasure::Out > SheathDiameter;
+    };
+
+    // C++ wrapper for IfcTextLiteral
+    struct IfcTextLiteral : IfcGeometricRepresentationItem, ObjectHelper<IfcTextLiteral,3> { IfcTextLiteral() : Object("IfcTextLiteral") {}
+		IfcPresentableText::Out Literal;
+		IfcAxis2Placement::Out Placement;
+		IfcTextPath::Out Path;
+    };
+
+    // C++ wrapper for IfcTextLiteralWithExtent
+    struct IfcTextLiteralWithExtent : IfcTextLiteral, ObjectHelper<IfcTextLiteralWithExtent,2> { IfcTextLiteralWithExtent() : Object("IfcTextLiteralWithExtent") {}
+		Lazy< IfcPlanarExtent > Extent;
+		IfcBoxAlignment::Out BoxAlignment;
+    };
+
+    // C++ wrapper for IfcTopologyRepresentation
+    struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {}
+
+    };
+
+    // C++ wrapper for IfcToroidalSurface
+    struct IfcToroidalSurface : IfcElementarySurface, ObjectHelper<IfcToroidalSurface,2> { IfcToroidalSurface() : Object("IfcToroidalSurface") {}
+		IfcPositiveLengthMeasure::Out MajorRadius;
+		IfcPositiveLengthMeasure::Out MinorRadius;
+    };
+
+    // C++ wrapper for IfcTransformer
+    struct IfcTransformer : IfcEnergyConversionDevice, ObjectHelper<IfcTransformer,1> { IfcTransformer() : Object("IfcTransformer") {}
+		Maybe< IfcTransformerTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTransformerType
+    struct IfcTransformerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTransformerType,1> { IfcTransformerType() : Object("IfcTransformerType") {}
+		IfcTransformerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcTransportElement
+    struct IfcTransportElement : IfcElement, ObjectHelper<IfcTransportElement,1> { IfcTransportElement() : Object("IfcTransportElement") {}
+		Maybe< IfcTransportElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTransportElementType
+    struct IfcTransportElementType : IfcElementType, ObjectHelper<IfcTransportElementType,1> { IfcTransportElementType() : Object("IfcTransportElementType") {}
+		IfcTransportElementTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcTrapeziumProfileDef
+    struct IfcTrapeziumProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTrapeziumProfileDef,4> { IfcTrapeziumProfileDef() : Object("IfcTrapeziumProfileDef") {}
+		IfcPositiveLengthMeasure::Out BottomXDim;
+		IfcPositiveLengthMeasure::Out TopXDim;
+		IfcPositiveLengthMeasure::Out YDim;
+		IfcLengthMeasure::Out TopXOffset;
+    };
+
+    // C++ wrapper for IfcTriangulatedFaceSet
+    struct IfcTriangulatedFaceSet : IfcTessellatedFaceSet, ObjectHelper<IfcTriangulatedFaceSet,2> { IfcTriangulatedFaceSet() : Object("IfcTriangulatedFaceSet") {}
+		Maybe< IfcBoolean::Out > Closed;
+		Maybe< ListOf< IfcPositiveInteger, 1, 0 >::Out > PnIndex;
+    };
+
+    // C++ wrapper for IfcTrimmedCurve
+    struct IfcTrimmedCurve : IfcBoundedCurve, ObjectHelper<IfcTrimmedCurve,5> { IfcTrimmedCurve() : Object("IfcTrimmedCurve") {}
+		Lazy< IfcCurve > BasisCurve;
+		ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim1;
+		ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim2;
+		IfcBoolean::Out SenseAgreement;
+		IfcTrimmingPreference::Out MasterRepresentation;
+    };
+
+    // C++ wrapper for IfcTubeBundle
+    struct IfcTubeBundle : IfcEnergyConversionDevice, ObjectHelper<IfcTubeBundle,1> { IfcTubeBundle() : Object("IfcTubeBundle") {}
+		Maybe< IfcTubeBundleTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcTubeBundleType
+    struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {}
+		IfcTubeBundleTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcUShapeProfileDef
+    struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,7> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out Depth;
+		IfcPositiveLengthMeasure::Out FlangeWidth;
+		IfcPositiveLengthMeasure::Out WebThickness;
+		IfcPositiveLengthMeasure::Out FlangeThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
+		Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
+    };
+
+    // C++ wrapper for IfcUnitAssignment
+    struct IfcUnitAssignment :  ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {}
+		ListOf< IfcUnit, 1, 0 >::Out Units;
+    };
+
+    // C++ wrapper for IfcUnitaryControlElement
+    struct IfcUnitaryControlElement : IfcDistributionControlElement, ObjectHelper<IfcUnitaryControlElement,1> { IfcUnitaryControlElement() : Object("IfcUnitaryControlElement") {}
+		Maybe< IfcUnitaryControlElementTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcUnitaryControlElementType
+    struct IfcUnitaryControlElementType : IfcDistributionControlElementType, ObjectHelper<IfcUnitaryControlElementType,1> { IfcUnitaryControlElementType() : Object("IfcUnitaryControlElementType") {}
+		IfcUnitaryControlElementTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcUnitaryEquipment
+    struct IfcUnitaryEquipment : IfcEnergyConversionDevice, ObjectHelper<IfcUnitaryEquipment,1> { IfcUnitaryEquipment() : Object("IfcUnitaryEquipment") {}
+		Maybe< IfcUnitaryEquipmentTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcUnitaryEquipmentType
+    struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {}
+		IfcUnitaryEquipmentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcValve
+    struct IfcValve : IfcFlowController, ObjectHelper<IfcValve,1> { IfcValve() : Object("IfcValve") {}
+		Maybe< IfcValveTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcValveType
+    struct IfcValveType : IfcFlowControllerType, ObjectHelper<IfcValveType,1> { IfcValveType() : Object("IfcValveType") {}
+		IfcValveTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcVector
+    struct IfcVector : IfcGeometricRepresentationItem, ObjectHelper<IfcVector,2> { IfcVector() : Object("IfcVector") {}
+		Lazy< IfcDirection > Orientation;
+		IfcLengthMeasure::Out Magnitude;
+    };
+
+    // C++ wrapper for IfcVertex
+    struct IfcVertex : IfcTopologicalRepresentationItem, ObjectHelper<IfcVertex,0> { IfcVertex() : Object("IfcVertex") {}
+
+    };
+
+    // C++ wrapper for IfcVertexLoop
+    struct IfcVertexLoop : IfcLoop, ObjectHelper<IfcVertexLoop,1> { IfcVertexLoop() : Object("IfcVertexLoop") {}
+		Lazy< IfcVertex > LoopVertex;
+    };
+
+    // C++ wrapper for IfcVertexPoint
+    struct IfcVertexPoint : IfcVertex, ObjectHelper<IfcVertexPoint,1> { IfcVertexPoint() : Object("IfcVertexPoint") {}
+		Lazy< IfcPoint > VertexGeometry;
+    };
+
+    // C++ wrapper for IfcVibrationIsolator
+    struct IfcVibrationIsolator : IfcElementComponent, ObjectHelper<IfcVibrationIsolator,1> { IfcVibrationIsolator() : Object("IfcVibrationIsolator") {}
+		Maybe< IfcVibrationIsolatorTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcVibrationIsolatorType
+    struct IfcVibrationIsolatorType : IfcElementComponentType, ObjectHelper<IfcVibrationIsolatorType,1> { IfcVibrationIsolatorType() : Object("IfcVibrationIsolatorType") {}
+		IfcVibrationIsolatorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcVirtualElement
+    struct IfcVirtualElement : IfcElement, ObjectHelper<IfcVirtualElement,0> { IfcVirtualElement() : Object("IfcVirtualElement") {}
+
+    };
+
+    // C++ wrapper for IfcVoidingFeature
+    struct IfcVoidingFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcVoidingFeature,1> { IfcVoidingFeature() : Object("IfcVoidingFeature") {}
+		Maybe< IfcVoidingFeatureTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcWall
+    struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,1> { IfcWall() : Object("IfcWall") {}
+		Maybe< IfcWallTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcWallElementedCase
+    struct IfcWallElementedCase : IfcWall, ObjectHelper<IfcWallElementedCase,0> { IfcWallElementedCase() : Object("IfcWallElementedCase") {}
+
+    };
+
+    // C++ wrapper for IfcWallStandardCase
+    struct IfcWallStandardCase : IfcWall, ObjectHelper<IfcWallStandardCase,0> { IfcWallStandardCase() : Object("IfcWallStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcWallType
+    struct IfcWallType : IfcBuildingElementType, ObjectHelper<IfcWallType,1> { IfcWallType() : Object("IfcWallType") {}
+		IfcWallTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcWasteTerminal
+    struct IfcWasteTerminal : IfcFlowTerminal, ObjectHelper<IfcWasteTerminal,1> { IfcWasteTerminal() : Object("IfcWasteTerminal") {}
+		Maybe< IfcWasteTerminalTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcWasteTerminalType
+    struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {}
+		IfcWasteTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcWindow
+    struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,5> { IfcWindow() : Object("IfcWindow") {}
+		Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
+		Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
+		Maybe< IfcWindowTypeEnum::Out > PredefinedType;
+		Maybe< IfcWindowTypePartitioningEnum::Out > PartitioningType;
+		Maybe< IfcLabel::Out > UserDefinedPartitioningType;
+    };
+
+    // C++ wrapper for IfcWindowStandardCase
+    struct IfcWindowStandardCase : IfcWindow, ObjectHelper<IfcWindowStandardCase,0> { IfcWindowStandardCase() : Object("IfcWindowStandardCase") {}
+
+    };
+
+    // C++ wrapper for IfcWindowStyle
+    struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {}
+		IfcWindowStyleConstructionEnum::Out ConstructionType;
+		IfcWindowStyleOperationEnum::Out OperationType;
+		IfcBoolean::Out ParameterTakesPrecedence;
+		IfcBoolean::Out Sizeable;
+    };
+
+    // C++ wrapper for IfcWindowType
+    struct IfcWindowType : IfcBuildingElementType, ObjectHelper<IfcWindowType,4> { IfcWindowType() : Object("IfcWindowType") {}
+		IfcWindowTypeEnum::Out PredefinedType;
+		IfcWindowTypePartitioningEnum::Out PartitioningType;
+		Maybe< IfcBoolean::Out > ParameterTakesPrecedence;
+		Maybe< IfcLabel::Out > UserDefinedPartitioningType;
+    };
+
+    // C++ wrapper for IfcWorkCalendar
+    struct IfcWorkCalendar : IfcControl, ObjectHelper<IfcWorkCalendar,3> { IfcWorkCalendar() : Object("IfcWorkCalendar") {}
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WorkingTimes;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > ExceptionTimes;
+		Maybe< IfcWorkCalendarTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcWorkControl
+    struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,7> { IfcWorkControl() : Object("IfcWorkControl") {}
+		IfcDateTime::Out CreationDate;
+		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators;
+		Maybe< IfcLabel::Out > Purpose;
+		Maybe< IfcDuration::Out > Duration;
+		Maybe< IfcDuration::Out > TotalFloat;
+		IfcDateTime::Out StartTime;
+		Maybe< IfcDateTime::Out > FinishTime;
+    };
+
+    // C++ wrapper for IfcWorkPlan
+    struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,1> { IfcWorkPlan() : Object("IfcWorkPlan") {}
+		Maybe< IfcWorkPlanTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcWorkSchedule
+    struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,1> { IfcWorkSchedule() : Object("IfcWorkSchedule") {}
+		Maybe< IfcWorkScheduleTypeEnum::Out > PredefinedType;
+    };
+
+    // C++ wrapper for IfcZShapeProfileDef
+    struct IfcZShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcZShapeProfileDef,6> { IfcZShapeProfileDef() : Object("IfcZShapeProfileDef") {}
+		IfcPositiveLengthMeasure::Out Depth;
+		IfcPositiveLengthMeasure::Out FlangeWidth;
+		IfcPositiveLengthMeasure::Out WebThickness;
+		IfcPositiveLengthMeasure::Out FlangeThickness;
+		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
+		Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
+    };
+
+    // C++ wrapper for IfcZone
+    struct IfcZone : IfcSystem, ObjectHelper<IfcZone,1> { IfcZone() : Object("IfcZone") {}
+		Maybe< IfcLabel::Out > LongName;
+    };
+
+	void GetSchema(EXPRESS::ConversionSchema& out);
+
+} //! IFC
+namespace STEP {
+
+	// ******************************************************************************
+	// Converter stubs
+	// ******************************************************************************
+	
+#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::type* in)
+	
+	DECL_CONV_STUB(IfcRoot);
+	DECL_CONV_STUB(IfcObjectDefinition);
+	DECL_CONV_STUB(IfcObject);
+	DECL_CONV_STUB(IfcControl);
+	DECL_CONV_STUB(IfcActionRequest);
+	DECL_CONV_STUB(IfcActor);
+	DECL_CONV_STUB(IfcProduct);
+	DECL_CONV_STUB(IfcElement);
+	DECL_CONV_STUB(IfcDistributionElement);
+	DECL_CONV_STUB(IfcDistributionControlElement);
+	DECL_CONV_STUB(IfcActuator);
+	DECL_CONV_STUB(IfcTypeObject);
+	DECL_CONV_STUB(IfcTypeProduct);
+	DECL_CONV_STUB(IfcElementType);
+	DECL_CONV_STUB(IfcDistributionElementType);
+	DECL_CONV_STUB(IfcDistributionControlElementType);
+	DECL_CONV_STUB(IfcActuatorType);
+	DECL_CONV_STUB(IfcRepresentationItem);
+	DECL_CONV_STUB(IfcGeometricRepresentationItem);
+	DECL_CONV_STUB(IfcSolidModel);
+	DECL_CONV_STUB(IfcManifoldSolidBrep);
+	DECL_CONV_STUB(IfcAdvancedBrep);
+	DECL_CONV_STUB(IfcAdvancedBrepWithVoids);
+	DECL_CONV_STUB(IfcTopologicalRepresentationItem);
+	DECL_CONV_STUB(IfcFace);
+	DECL_CONV_STUB(IfcFaceSurface);
+	DECL_CONV_STUB(IfcAdvancedFace);
+	DECL_CONV_STUB(IfcDistributionFlowElement);
+	DECL_CONV_STUB(IfcFlowTerminal);
+	DECL_CONV_STUB(IfcAirTerminal);
+	DECL_CONV_STUB(IfcFlowController);
+	DECL_CONV_STUB(IfcAirTerminalBox);
+	DECL_CONV_STUB(IfcDistributionFlowElementType);
+	DECL_CONV_STUB(IfcFlowControllerType);
+	DECL_CONV_STUB(IfcAirTerminalBoxType);
+	DECL_CONV_STUB(IfcFlowTerminalType);
+	DECL_CONV_STUB(IfcAirTerminalType);
+	DECL_CONV_STUB(IfcEnergyConversionDevice);
+	DECL_CONV_STUB(IfcAirToAirHeatRecovery);
+	DECL_CONV_STUB(IfcEnergyConversionDeviceType);
+	DECL_CONV_STUB(IfcAirToAirHeatRecoveryType);
+	DECL_CONV_STUB(IfcAlarm);
+	DECL_CONV_STUB(IfcAlarmType);
+	DECL_CONV_STUB(IfcAnnotation);
+	DECL_CONV_STUB(IfcAnnotationFillArea);
+	DECL_CONV_STUB(IfcProfileDef);
+	DECL_CONV_STUB(IfcArbitraryClosedProfileDef);
+	DECL_CONV_STUB(IfcArbitraryOpenProfileDef);
+	DECL_CONV_STUB(IfcArbitraryProfileDefWithVoids);
+	DECL_CONV_STUB(IfcGroup);
+	DECL_CONV_STUB(IfcAsset);
+	DECL_CONV_STUB(IfcParameterizedProfileDef);
+	DECL_CONV_STUB(IfcAsymmetricIShapeProfileDef);
+	DECL_CONV_STUB(IfcAudioVisualAppliance);
+	DECL_CONV_STUB(IfcAudioVisualApplianceType);
+	DECL_CONV_STUB(IfcPlacement);
+	DECL_CONV_STUB(IfcAxis1Placement);
+	DECL_CONV_STUB(IfcAxis2Placement2D);
+	DECL_CONV_STUB(IfcAxis2Placement3D);
+	DECL_CONV_STUB(IfcCurve);
+	DECL_CONV_STUB(IfcBoundedCurve);
+	DECL_CONV_STUB(IfcBSplineCurve);
+	DECL_CONV_STUB(IfcBSplineCurveWithKnots);
+	DECL_CONV_STUB(IfcSurface);
+	DECL_CONV_STUB(IfcBoundedSurface);
+	DECL_CONV_STUB(IfcBSplineSurface);
+	DECL_CONV_STUB(IfcBSplineSurfaceWithKnots);
+	DECL_CONV_STUB(IfcBuildingElement);
+	DECL_CONV_STUB(IfcBeam);
+	DECL_CONV_STUB(IfcBeamStandardCase);
+	DECL_CONV_STUB(IfcBuildingElementType);
+	DECL_CONV_STUB(IfcBeamType);
+	DECL_CONV_STUB(IfcPresentationItem);
+	DECL_CONV_STUB(IfcCsgPrimitive3D);
+	DECL_CONV_STUB(IfcBlock);
+	DECL_CONV_STUB(IfcBoiler);
+	DECL_CONV_STUB(IfcBoilerType);
+	DECL_CONV_STUB(IfcBooleanResult);
+	DECL_CONV_STUB(IfcBooleanClippingResult);
+	DECL_CONV_STUB(IfcCompositeCurve);
+	DECL_CONV_STUB(IfcCompositeCurveOnSurface);
+	DECL_CONV_STUB(IfcBoundaryCurve);
+	DECL_CONV_STUB(IfcBoundingBox);
+	DECL_CONV_STUB(IfcHalfSpaceSolid);
+	DECL_CONV_STUB(IfcBoxedHalfSpace);
+	DECL_CONV_STUB(IfcSpatialElement);
+	DECL_CONV_STUB(IfcSpatialStructureElement);
+	DECL_CONV_STUB(IfcBuilding);
+	DECL_CONV_STUB(IfcElementComponent);
+	DECL_CONV_STUB(IfcBuildingElementPart);
+	DECL_CONV_STUB(IfcElementComponentType);
+	DECL_CONV_STUB(IfcBuildingElementPartType);
+	DECL_CONV_STUB(IfcBuildingElementProxy);
+	DECL_CONV_STUB(IfcBuildingElementProxyType);
+	DECL_CONV_STUB(IfcBuildingStorey);
+	DECL_CONV_STUB(IfcSystem);
+	DECL_CONV_STUB(IfcBuildingSystem);
+	DECL_CONV_STUB(IfcBurner);
+	DECL_CONV_STUB(IfcBurnerType);
+	DECL_CONV_STUB(IfcCShapeProfileDef);
+	DECL_CONV_STUB(IfcFlowFitting);
+	DECL_CONV_STUB(IfcCableCarrierFitting);
+	DECL_CONV_STUB(IfcFlowFittingType);
+	DECL_CONV_STUB(IfcCableCarrierFittingType);
+	DECL_CONV_STUB(IfcFlowSegment);
+	DECL_CONV_STUB(IfcCableCarrierSegment);
+	DECL_CONV_STUB(IfcFlowSegmentType);
+	DECL_CONV_STUB(IfcCableCarrierSegmentType);
+	DECL_CONV_STUB(IfcCableFitting);
+	DECL_CONV_STUB(IfcCableFittingType);
+	DECL_CONV_STUB(IfcCableSegment);
+	DECL_CONV_STUB(IfcCableSegmentType);
+	DECL_CONV_STUB(IfcPoint);
+	DECL_CONV_STUB(IfcCartesianPoint);
+	DECL_CONV_STUB(IfcCartesianPointList);
+	DECL_CONV_STUB(IfcCartesianPointList2D);
+	DECL_CONV_STUB(IfcCartesianPointList3D);
+	DECL_CONV_STUB(IfcCartesianTransformationOperator);
+	DECL_CONV_STUB(IfcCartesianTransformationOperator2D);
+	DECL_CONV_STUB(IfcCartesianTransformationOperator2DnonUniform);
+	DECL_CONV_STUB(IfcCartesianTransformationOperator3D);
+	DECL_CONV_STUB(IfcCartesianTransformationOperator3DnonUniform);
+	DECL_CONV_STUB(IfcCenterLineProfileDef);
+	DECL_CONV_STUB(IfcChiller);
+	DECL_CONV_STUB(IfcChillerType);
+	DECL_CONV_STUB(IfcChimney);
+	DECL_CONV_STUB(IfcChimneyType);
+	DECL_CONV_STUB(IfcConic);
+	DECL_CONV_STUB(IfcCircle);
+	DECL_CONV_STUB(IfcCircleProfileDef);
+	DECL_CONV_STUB(IfcCircleHollowProfileDef);
+	DECL_CONV_STUB(IfcCivilElement);
+	DECL_CONV_STUB(IfcCivilElementType);
+	DECL_CONV_STUB(IfcConnectedFaceSet);
+	DECL_CONV_STUB(IfcClosedShell);
+	DECL_CONV_STUB(IfcCoil);
+	DECL_CONV_STUB(IfcCoilType);
+	DECL_CONV_STUB(IfcColourSpecification);
+	DECL_CONV_STUB(IfcColourRgb);
+	DECL_CONV_STUB(IfcColumn);
+	DECL_CONV_STUB(IfcColumnStandardCase);
+	DECL_CONV_STUB(IfcColumnType);
+	DECL_CONV_STUB(IfcCommunicationsAppliance);
+	DECL_CONV_STUB(IfcCommunicationsApplianceType);
+	DECL_CONV_STUB(IfcPropertyAbstraction);
+	DECL_CONV_STUB(IfcProperty);
+	DECL_CONV_STUB(IfcComplexProperty);
+	DECL_CONV_STUB(IfcPropertyDefinition);
+	DECL_CONV_STUB(IfcCompositeCurveSegment);
+	DECL_CONV_STUB(IfcCompositeProfileDef);
+	DECL_CONV_STUB(IfcFlowMovingDevice);
+	DECL_CONV_STUB(IfcCompressor);
+	DECL_CONV_STUB(IfcFlowMovingDeviceType);
+	DECL_CONV_STUB(IfcCompressorType);
+	DECL_CONV_STUB(IfcCondenser);
+	DECL_CONV_STUB(IfcCondenserType);
+	DECL_CONV_STUB(IfcResource);
+	DECL_CONV_STUB(IfcConstructionResource);
+	DECL_CONV_STUB(IfcConstructionEquipmentResource);
+	DECL_CONV_STUB(IfcTypeResource);
+	DECL_CONV_STUB(IfcConstructionResourceType);
+	DECL_CONV_STUB(IfcConstructionEquipmentResourceType);
+	DECL_CONV_STUB(IfcConstructionMaterialResource);
+	DECL_CONV_STUB(IfcConstructionMaterialResourceType);
+	DECL_CONV_STUB(IfcConstructionProductResource);
+	DECL_CONV_STUB(IfcConstructionProductResourceType);
+	DECL_CONV_STUB(IfcContext);
+	DECL_CONV_STUB(IfcNamedUnit);
+	DECL_CONV_STUB(IfcContextDependentUnit);
+	DECL_CONV_STUB(IfcController);
+	DECL_CONV_STUB(IfcControllerType);
+	DECL_CONV_STUB(IfcConversionBasedUnit);
+	DECL_CONV_STUB(IfcConversionBasedUnitWithOffset);
+	DECL_CONV_STUB(IfcCooledBeam);
+	DECL_CONV_STUB(IfcCooledBeamType);
+	DECL_CONV_STUB(IfcCoolingTower);
+	DECL_CONV_STUB(IfcCoolingTowerType);
+	DECL_CONV_STUB(IfcCostItem);
+	DECL_CONV_STUB(IfcCostSchedule);
+	DECL_CONV_STUB(IfcCovering);
+	DECL_CONV_STUB(IfcCoveringType);
+	DECL_CONV_STUB(IfcCrewResource);
+	DECL_CONV_STUB(IfcCrewResourceType);
+	DECL_CONV_STUB(IfcCsgSolid);
+	DECL_CONV_STUB(IfcCurtainWall);
+	DECL_CONV_STUB(IfcCurtainWallType);
+	DECL_CONV_STUB(IfcCurveBoundedPlane);
+	DECL_CONV_STUB(IfcCurveBoundedSurface);
+	DECL_CONV_STUB(IfcPresentationStyle);
+	DECL_CONV_STUB(IfcElementarySurface);
+	DECL_CONV_STUB(IfcCylindricalSurface);
+	DECL_CONV_STUB(IfcDamper);
+	DECL_CONV_STUB(IfcDamperType);
+	DECL_CONV_STUB(IfcDerivedProfileDef);
+	DECL_CONV_STUB(IfcDirection);
+	DECL_CONV_STUB(IfcDiscreteAccessory);
+	DECL_CONV_STUB(IfcDiscreteAccessoryType);
+	DECL_CONV_STUB(IfcDistributionChamberElement);
+	DECL_CONV_STUB(IfcDistributionChamberElementType);
+	DECL_CONV_STUB(IfcDistributionSystem);
+	DECL_CONV_STUB(IfcDistributionCircuit);
+	DECL_CONV_STUB(IfcPort);
+	DECL_CONV_STUB(IfcDistributionPort);
+	DECL_CONV_STUB(IfcDoor);
+	DECL_CONV_STUB(IfcPropertySetDefinition);
+	DECL_CONV_STUB(IfcDoorStandardCase);
+	DECL_CONV_STUB(IfcDoorStyle);
+	DECL_CONV_STUB(IfcDoorType);
+	DECL_CONV_STUB(IfcDuctFitting);
+	DECL_CONV_STUB(IfcDuctFittingType);
+	DECL_CONV_STUB(IfcDuctSegment);
+	DECL_CONV_STUB(IfcDuctSegmentType);
+	DECL_CONV_STUB(IfcFlowTreatmentDevice);
+	DECL_CONV_STUB(IfcDuctSilencer);
+	DECL_CONV_STUB(IfcFlowTreatmentDeviceType);
+	DECL_CONV_STUB(IfcDuctSilencerType);
+	DECL_CONV_STUB(IfcEdge);
+	DECL_CONV_STUB(IfcEdgeCurve);
+	DECL_CONV_STUB(IfcLoop);
+	DECL_CONV_STUB(IfcEdgeLoop);
+	DECL_CONV_STUB(IfcElectricAppliance);
+	DECL_CONV_STUB(IfcElectricApplianceType);
+	DECL_CONV_STUB(IfcElectricDistributionBoard);
+	DECL_CONV_STUB(IfcElectricDistributionBoardType);
+	DECL_CONV_STUB(IfcFlowStorageDevice);
+	DECL_CONV_STUB(IfcElectricFlowStorageDevice);
+	DECL_CONV_STUB(IfcFlowStorageDeviceType);
+	DECL_CONV_STUB(IfcElectricFlowStorageDeviceType);
+	DECL_CONV_STUB(IfcElectricGenerator);
+	DECL_CONV_STUB(IfcElectricGeneratorType);
+	DECL_CONV_STUB(IfcElectricMotor);
+	DECL_CONV_STUB(IfcElectricMotorType);
+	DECL_CONV_STUB(IfcElectricTimeControl);
+	DECL_CONV_STUB(IfcElectricTimeControlType);
+	DECL_CONV_STUB(IfcElementAssembly);
+	DECL_CONV_STUB(IfcElementAssemblyType);
+	DECL_CONV_STUB(IfcQuantitySet);
+	DECL_CONV_STUB(IfcElementQuantity);
+	DECL_CONV_STUB(IfcEllipse);
+	DECL_CONV_STUB(IfcEllipseProfileDef);
+	DECL_CONV_STUB(IfcEngine);
+	DECL_CONV_STUB(IfcEngineType);
+	DECL_CONV_STUB(IfcEvaporativeCooler);
+	DECL_CONV_STUB(IfcEvaporativeCoolerType);
+	DECL_CONV_STUB(IfcEvaporator);
+	DECL_CONV_STUB(IfcEvaporatorType);
+	DECL_CONV_STUB(IfcProcess);
+	DECL_CONV_STUB(IfcEvent);
+	DECL_CONV_STUB(IfcTypeProcess);
+	DECL_CONV_STUB(IfcEventType);
+	DECL_CONV_STUB(IfcExternalSpatialStructureElement);
+	DECL_CONV_STUB(IfcExternalSpatialElement);
+	DECL_CONV_STUB(IfcSweptAreaSolid);
+	DECL_CONV_STUB(IfcExtrudedAreaSolid);
+	DECL_CONV_STUB(IfcExtrudedAreaSolidTapered);
+	DECL_CONV_STUB(IfcFaceBasedSurfaceModel);
+	DECL_CONV_STUB(IfcFaceBound);
+	DECL_CONV_STUB(IfcFaceOuterBound);
+	DECL_CONV_STUB(IfcFacetedBrep);
+	DECL_CONV_STUB(IfcFacetedBrepWithVoids);
+	DECL_CONV_STUB(IfcFan);
+	DECL_CONV_STUB(IfcFanType);
+	DECL_CONV_STUB(IfcFastener);
+	DECL_CONV_STUB(IfcFastenerType);
+	DECL_CONV_STUB(IfcFeatureElement);
+	DECL_CONV_STUB(IfcFeatureElementAddition);
+	DECL_CONV_STUB(IfcFeatureElementSubtraction);
+	DECL_CONV_STUB(IfcFillAreaStyleHatching);
+	DECL_CONV_STUB(IfcFillAreaStyleTiles);
+	DECL_CONV_STUB(IfcFilter);
+	DECL_CONV_STUB(IfcFilterType);
+	DECL_CONV_STUB(IfcFireSuppressionTerminal);
+	DECL_CONV_STUB(IfcFireSuppressionTerminalType);
+	DECL_CONV_STUB(IfcFixedReferenceSweptAreaSolid);
+	DECL_CONV_STUB(IfcFlowInstrument);
+	DECL_CONV_STUB(IfcFlowInstrumentType);
+	DECL_CONV_STUB(IfcFlowMeter);
+	DECL_CONV_STUB(IfcFlowMeterType);
+	DECL_CONV_STUB(IfcFooting);
+	DECL_CONV_STUB(IfcFootingType);
+	DECL_CONV_STUB(IfcFurnishingElement);
+	DECL_CONV_STUB(IfcFurnishingElementType);
+	DECL_CONV_STUB(IfcFurniture);
+	DECL_CONV_STUB(IfcFurnitureType);
+	DECL_CONV_STUB(IfcGeographicElement);
+	DECL_CONV_STUB(IfcGeographicElementType);
+	DECL_CONV_STUB(IfcGeometricSet);
+	DECL_CONV_STUB(IfcGeometricCurveSet);
+	DECL_CONV_STUB(IfcRepresentationContext);
+	DECL_CONV_STUB(IfcGeometricRepresentationContext);
+	DECL_CONV_STUB(IfcGeometricRepresentationSubContext);
+	DECL_CONV_STUB(IfcGrid);
+	DECL_CONV_STUB(IfcObjectPlacement);
+	DECL_CONV_STUB(IfcGridPlacement);
+	DECL_CONV_STUB(IfcHeatExchanger);
+	DECL_CONV_STUB(IfcHeatExchangerType);
+	DECL_CONV_STUB(IfcHumidifier);
+	DECL_CONV_STUB(IfcHumidifierType);
+	DECL_CONV_STUB(IfcIShapeProfileDef);
+	DECL_CONV_STUB(IfcIndexedPolyCurve);
+	DECL_CONV_STUB(IfcTessellatedItem);
+	DECL_CONV_STUB(IfcIndexedPolygonalFace);
+	DECL_CONV_STUB(IfcIndexedPolygonalFaceWithVoids);
+	DECL_CONV_STUB(IfcInterceptor);
+	DECL_CONV_STUB(IfcInterceptorType);
+	DECL_CONV_STUB(IfcSurfaceCurve);
+	DECL_CONV_STUB(IfcIntersectionCurve);
+	DECL_CONV_STUB(IfcInventory);
+	DECL_CONV_STUB(IfcJunctionBox);
+	DECL_CONV_STUB(IfcJunctionBoxType);
+	DECL_CONV_STUB(IfcLShapeProfileDef);
+	DECL_CONV_STUB(IfcLaborResource);
+	DECL_CONV_STUB(IfcLaborResourceType);
+	DECL_CONV_STUB(IfcLamp);
+	DECL_CONV_STUB(IfcLampType);
+	DECL_CONV_STUB(IfcLightFixture);
+	DECL_CONV_STUB(IfcLightFixtureType);
+	DECL_CONV_STUB(IfcLightSource);
+	DECL_CONV_STUB(IfcLightSourceAmbient);
+	DECL_CONV_STUB(IfcLightSourceDirectional);
+	DECL_CONV_STUB(IfcLightSourceGoniometric);
+	DECL_CONV_STUB(IfcLightSourcePositional);
+	DECL_CONV_STUB(IfcLightSourceSpot);
+	DECL_CONV_STUB(IfcLine);
+	DECL_CONV_STUB(IfcLocalPlacement);
+	DECL_CONV_STUB(IfcMappedItem);
+	DECL_CONV_STUB(IfcProductRepresentation);
+	DECL_CONV_STUB(IfcMaterialDefinitionRepresentation);
+	DECL_CONV_STUB(IfcMeasureWithUnit);
+	DECL_CONV_STUB(IfcMechanicalFastener);
+	DECL_CONV_STUB(IfcMechanicalFastenerType);
+	DECL_CONV_STUB(IfcMedicalDevice);
+	DECL_CONV_STUB(IfcMedicalDeviceType);
+	DECL_CONV_STUB(IfcMember);
+	DECL_CONV_STUB(IfcMemberStandardCase);
+	DECL_CONV_STUB(IfcMemberType);
+	DECL_CONV_STUB(IfcMirroredProfileDef);
+	DECL_CONV_STUB(IfcMotorConnection);
+	DECL_CONV_STUB(IfcMotorConnectionType);
+	DECL_CONV_STUB(IfcOccupant);
+	DECL_CONV_STUB(IfcOffsetCurve2D);
+	DECL_CONV_STUB(IfcOffsetCurve3D);
+	DECL_CONV_STUB(IfcOpenShell);
+	DECL_CONV_STUB(IfcOpeningElement);
+	DECL_CONV_STUB(IfcOpeningStandardCase);
+	DECL_CONV_STUB(IfcOrientedEdge);
+	DECL_CONV_STUB(IfcOuterBoundaryCurve);
+	DECL_CONV_STUB(IfcOutlet);
+	DECL_CONV_STUB(IfcOutletType);
+	DECL_CONV_STUB(IfcPath);
+	DECL_CONV_STUB(IfcPcurve);
+	DECL_CONV_STUB(IfcPerformanceHistory);
+	DECL_CONV_STUB(IfcPermit);
+	DECL_CONV_STUB(IfcPile);
+	DECL_CONV_STUB(IfcPileType);
+	DECL_CONV_STUB(IfcPipeFitting);
+	DECL_CONV_STUB(IfcPipeFittingType);
+	DECL_CONV_STUB(IfcPipeSegment);
+	DECL_CONV_STUB(IfcPipeSegmentType);
+	DECL_CONV_STUB(IfcPlanarExtent);
+	DECL_CONV_STUB(IfcPlanarBox);
+	DECL_CONV_STUB(IfcPlane);
+	DECL_CONV_STUB(IfcPlate);
+	DECL_CONV_STUB(IfcPlateStandardCase);
+	DECL_CONV_STUB(IfcPlateType);
+	DECL_CONV_STUB(IfcPointOnCurve);
+	DECL_CONV_STUB(IfcPointOnSurface);
+	DECL_CONV_STUB(IfcPolyLoop);
+	DECL_CONV_STUB(IfcPolygonalBoundedHalfSpace);
+	DECL_CONV_STUB(IfcTessellatedFaceSet);
+	DECL_CONV_STUB(IfcPolygonalFaceSet);
+	DECL_CONV_STUB(IfcPolyline);
+	DECL_CONV_STUB(IfcPresentationStyleAssignment);
+	DECL_CONV_STUB(IfcProcedure);
+	DECL_CONV_STUB(IfcProcedureType);
+	DECL_CONV_STUB(IfcProductDefinitionShape);
+	DECL_CONV_STUB(IfcProject);
+	DECL_CONV_STUB(IfcProjectLibrary);
+	DECL_CONV_STUB(IfcProjectOrder);
+	DECL_CONV_STUB(IfcProjectionElement);
+	DECL_CONV_STUB(IfcSimpleProperty);
+	DECL_CONV_STUB(IfcPropertyBoundedValue);
+	DECL_CONV_STUB(IfcPropertyEnumeratedValue);
+	DECL_CONV_STUB(IfcPropertyListValue);
+	DECL_CONV_STUB(IfcPropertyReferenceValue);
+	DECL_CONV_STUB(IfcPropertySet);
+	DECL_CONV_STUB(IfcPropertySingleValue);
+	DECL_CONV_STUB(IfcPropertyTableValue);
+	DECL_CONV_STUB(IfcProtectiveDevice);
+	DECL_CONV_STUB(IfcProtectiveDeviceTrippingUnit);
+	DECL_CONV_STUB(IfcProtectiveDeviceTrippingUnitType);
+	DECL_CONV_STUB(IfcProtectiveDeviceType);
+	DECL_CONV_STUB(IfcProxy);
+	DECL_CONV_STUB(IfcPump);
+	DECL_CONV_STUB(IfcPumpType);
+	DECL_CONV_STUB(IfcRailing);
+	DECL_CONV_STUB(IfcRailingType);
+	DECL_CONV_STUB(IfcRamp);
+	DECL_CONV_STUB(IfcRampFlight);
+	DECL_CONV_STUB(IfcRampFlightType);
+	DECL_CONV_STUB(IfcRampType);
+	DECL_CONV_STUB(IfcRationalBSplineCurveWithKnots);
+	DECL_CONV_STUB(IfcRationalBSplineSurfaceWithKnots);
+	DECL_CONV_STUB(IfcRectangleProfileDef);
+	DECL_CONV_STUB(IfcRectangleHollowProfileDef);
+	DECL_CONV_STUB(IfcRectangularPyramid);
+	DECL_CONV_STUB(IfcRectangularTrimmedSurface);
+	DECL_CONV_STUB(IfcReinforcingElement);
+	DECL_CONV_STUB(IfcReinforcingBar);
+	DECL_CONV_STUB(IfcReinforcingElementType);
+	DECL_CONV_STUB(IfcReinforcingBarType);
+	DECL_CONV_STUB(IfcReinforcingMesh);
+	DECL_CONV_STUB(IfcReinforcingMeshType);
+	DECL_CONV_STUB(IfcRelationship);
+	DECL_CONV_STUB(IfcRelDecomposes);
+	DECL_CONV_STUB(IfcRelAggregates);
+	DECL_CONV_STUB(IfcRelConnects);
+	DECL_CONV_STUB(IfcRelContainedInSpatialStructure);
+	DECL_CONV_STUB(IfcRelDefines);
+	DECL_CONV_STUB(IfcRelDefinesByProperties);
+	DECL_CONV_STUB(IfcRelFillsElement);
+	DECL_CONV_STUB(IfcRelVoidsElement);
+	DECL_CONV_STUB(IfcReparametrisedCompositeCurveSegment);
+	DECL_CONV_STUB(IfcRepresentation);
+	DECL_CONV_STUB(IfcRepresentationMap);
+	DECL_CONV_STUB(IfcRevolvedAreaSolid);
+	DECL_CONV_STUB(IfcRevolvedAreaSolidTapered);
+	DECL_CONV_STUB(IfcRightCircularCone);
+	DECL_CONV_STUB(IfcRightCircularCylinder);
+	DECL_CONV_STUB(IfcRoof);
+	DECL_CONV_STUB(IfcRoofType);
+	DECL_CONV_STUB(IfcRoundedRectangleProfileDef);
+	DECL_CONV_STUB(IfcSIUnit);
+	DECL_CONV_STUB(IfcSanitaryTerminal);
+	DECL_CONV_STUB(IfcSanitaryTerminalType);
+	DECL_CONV_STUB(IfcSeamCurve);
+	DECL_CONV_STUB(IfcSectionedSpine);
+	DECL_CONV_STUB(IfcSensor);
+	DECL_CONV_STUB(IfcSensorType);
+	DECL_CONV_STUB(IfcShadingDevice);
+	DECL_CONV_STUB(IfcShadingDeviceType);
+	DECL_CONV_STUB(IfcShapeModel);
+	DECL_CONV_STUB(IfcShapeRepresentation);
+	DECL_CONV_STUB(IfcShellBasedSurfaceModel);
+	DECL_CONV_STUB(IfcSite);
+	DECL_CONV_STUB(IfcSlab);
+	DECL_CONV_STUB(IfcSlabElementedCase);
+	DECL_CONV_STUB(IfcSlabStandardCase);
+	DECL_CONV_STUB(IfcSlabType);
+	DECL_CONV_STUB(IfcSolarDevice);
+	DECL_CONV_STUB(IfcSolarDeviceType);
+	DECL_CONV_STUB(IfcSpace);
+	DECL_CONV_STUB(IfcSpaceHeater);
+	DECL_CONV_STUB(IfcSpaceHeaterType);
+	DECL_CONV_STUB(IfcSpatialElementType);
+	DECL_CONV_STUB(IfcSpatialStructureElementType);
+	DECL_CONV_STUB(IfcSpaceType);
+	DECL_CONV_STUB(IfcSpatialZone);
+	DECL_CONV_STUB(IfcSpatialZoneType);
+	DECL_CONV_STUB(IfcSphere);
+	DECL_CONV_STUB(IfcSphericalSurface);
+	DECL_CONV_STUB(IfcStackTerminal);
+	DECL_CONV_STUB(IfcStackTerminalType);
+	DECL_CONV_STUB(IfcStair);
+	DECL_CONV_STUB(IfcStairFlight);
+	DECL_CONV_STUB(IfcStairFlightType);
+	DECL_CONV_STUB(IfcStairType);
+	DECL_CONV_STUB(IfcStructuralActivity);
+	DECL_CONV_STUB(IfcStructuralAction);
+	DECL_CONV_STUB(IfcStructuralAnalysisModel);
+	DECL_CONV_STUB(IfcStructuralItem);
+	DECL_CONV_STUB(IfcStructuralConnection);
+	DECL_CONV_STUB(IfcStructuralCurveAction);
+	DECL_CONV_STUB(IfcStructuralCurveConnection);
+	DECL_CONV_STUB(IfcStructuralMember);
+	DECL_CONV_STUB(IfcStructuralCurveMember);
+	DECL_CONV_STUB(IfcStructuralCurveMemberVarying);
+	DECL_CONV_STUB(IfcStructuralReaction);
+	DECL_CONV_STUB(IfcStructuralCurveReaction);
+	DECL_CONV_STUB(IfcStructuralLinearAction);
+	DECL_CONV_STUB(IfcStructuralLoadGroup);
+	DECL_CONV_STUB(IfcStructuralLoadCase);
+	DECL_CONV_STUB(IfcStructuralSurfaceAction);
+	DECL_CONV_STUB(IfcStructuralPlanarAction);
+	DECL_CONV_STUB(IfcStructuralPointAction);
+	DECL_CONV_STUB(IfcStructuralPointConnection);
+	DECL_CONV_STUB(IfcStructuralPointReaction);
+	DECL_CONV_STUB(IfcStructuralResultGroup);
+	DECL_CONV_STUB(IfcStructuralSurfaceConnection);
+	DECL_CONV_STUB(IfcStructuralSurfaceMember);
+	DECL_CONV_STUB(IfcStructuralSurfaceMemberVarying);
+	DECL_CONV_STUB(IfcStructuralSurfaceReaction);
+	DECL_CONV_STUB(IfcStyleModel);
+	DECL_CONV_STUB(IfcStyledItem);
+	DECL_CONV_STUB(IfcStyledRepresentation);
+	DECL_CONV_STUB(IfcSubContractResource);
+	DECL_CONV_STUB(IfcSubContractResourceType);
+	DECL_CONV_STUB(IfcSubedge);
+	DECL_CONV_STUB(IfcSurfaceCurveSweptAreaSolid);
+	DECL_CONV_STUB(IfcSurfaceFeature);
+	DECL_CONV_STUB(IfcSweptSurface);
+	DECL_CONV_STUB(IfcSurfaceOfLinearExtrusion);
+	DECL_CONV_STUB(IfcSurfaceOfRevolution);
+	DECL_CONV_STUB(IfcSurfaceStyle);
+	DECL_CONV_STUB(IfcSurfaceStyleShading);
+	DECL_CONV_STUB(IfcSurfaceStyleRendering);
+	DECL_CONV_STUB(IfcSurfaceStyleWithTextures);
+	DECL_CONV_STUB(IfcSweptDiskSolid);
+	DECL_CONV_STUB(IfcSweptDiskSolidPolygonal);
+	DECL_CONV_STUB(IfcSwitchingDevice);
+	DECL_CONV_STUB(IfcSwitchingDeviceType);
+	DECL_CONV_STUB(IfcSystemFurnitureElement);
+	DECL_CONV_STUB(IfcSystemFurnitureElementType);
+	DECL_CONV_STUB(IfcTShapeProfileDef);
+	DECL_CONV_STUB(IfcTank);
+	DECL_CONV_STUB(IfcTankType);
+	DECL_CONV_STUB(IfcTask);
+	DECL_CONV_STUB(IfcTaskType);
+	DECL_CONV_STUB(IfcTendon);
+	DECL_CONV_STUB(IfcTendonAnchor);
+	DECL_CONV_STUB(IfcTendonAnchorType);
+	DECL_CONV_STUB(IfcTendonType);
+	DECL_CONV_STUB(IfcTextLiteral);
+	DECL_CONV_STUB(IfcTextLiteralWithExtent);
+	DECL_CONV_STUB(IfcTopologyRepresentation);
+	DECL_CONV_STUB(IfcToroidalSurface);
+	DECL_CONV_STUB(IfcTransformer);
+	DECL_CONV_STUB(IfcTransformerType);
+	DECL_CONV_STUB(IfcTransportElement);
+	DECL_CONV_STUB(IfcTransportElementType);
+	DECL_CONV_STUB(IfcTrapeziumProfileDef);
+	DECL_CONV_STUB(IfcTriangulatedFaceSet);
+	DECL_CONV_STUB(IfcTrimmedCurve);
+	DECL_CONV_STUB(IfcTubeBundle);
+	DECL_CONV_STUB(IfcTubeBundleType);
+	DECL_CONV_STUB(IfcUShapeProfileDef);
+	DECL_CONV_STUB(IfcUnitAssignment);
+	DECL_CONV_STUB(IfcUnitaryControlElement);
+	DECL_CONV_STUB(IfcUnitaryControlElementType);
+	DECL_CONV_STUB(IfcUnitaryEquipment);
+	DECL_CONV_STUB(IfcUnitaryEquipmentType);
+	DECL_CONV_STUB(IfcValve);
+	DECL_CONV_STUB(IfcValveType);
+	DECL_CONV_STUB(IfcVector);
+	DECL_CONV_STUB(IfcVertex);
+	DECL_CONV_STUB(IfcVertexLoop);
+	DECL_CONV_STUB(IfcVertexPoint);
+	DECL_CONV_STUB(IfcVibrationIsolator);
+	DECL_CONV_STUB(IfcVibrationIsolatorType);
+	DECL_CONV_STUB(IfcVirtualElement);
+	DECL_CONV_STUB(IfcVoidingFeature);
+	DECL_CONV_STUB(IfcWall);
+	DECL_CONV_STUB(IfcWallElementedCase);
+	DECL_CONV_STUB(IfcWallStandardCase);
+	DECL_CONV_STUB(IfcWallType);
+	DECL_CONV_STUB(IfcWasteTerminal);
+	DECL_CONV_STUB(IfcWasteTerminalType);
+	DECL_CONV_STUB(IfcWindow);
+	DECL_CONV_STUB(IfcWindowStandardCase);
+	DECL_CONV_STUB(IfcWindowStyle);
+	DECL_CONV_STUB(IfcWindowType);
+	DECL_CONV_STUB(IfcWorkCalendar);
+	DECL_CONV_STUB(IfcWorkControl);
+	DECL_CONV_STUB(IfcWorkPlan);
+	DECL_CONV_STUB(IfcWorkSchedule);
+	DECL_CONV_STUB(IfcZShapeProfileDef);
+	DECL_CONV_STUB(IfcZone);
+
+
+#undef DECL_CONV_STUB
+
+} //! STEP
+} //! Assimp
+
+#endif // INCLUDED_IFC_READER_GEN_H

code/IFCUtil.cpp → code/Importer/IFC/IFCUtil.cpp

@@ -47,9 +47,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
-#include "IFCUtil.h"
-#include "PolyTools.h"
-#include "ProcessHelper.h"
+#include "code/Importer/IFC/IFCUtil.h"
+#include "code/PolyTools.h"
+#include "code/ProcessHelper.h"
 #include <assimp/Defines.h>
 
 namespace Assimp {
@@ -70,31 +70,31 @@ void TempOpening::Transform(const IfcMatrix4& mat)
 // ------------------------------------------------------------------------------------------------
 aiMesh* TempMesh::ToMesh()
 {
-    ai_assert(verts.size() == std::accumulate(vertcnt.begin(),vertcnt.end(),size_t(0)));
+    ai_assert(mVerts.size() == std::accumulate(mVertcnt.begin(),mVertcnt.end(),size_t(0)));
 
-    if (verts.empty()) {
+    if (mVerts.empty()) {
         return NULL;
     }
 
     std::unique_ptr<aiMesh> mesh(new aiMesh());
 
     // copy vertices
-    mesh->mNumVertices = static_cast<unsigned int>(verts.size());
+    mesh->mNumVertices = static_cast<unsigned int>(mVerts.size());
     mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-    std::copy(verts.begin(),verts.end(),mesh->mVertices);
+    std::copy(mVerts.begin(),mVerts.end(),mesh->mVertices);
 
     // and build up faces
-    mesh->mNumFaces = static_cast<unsigned int>(vertcnt.size());
+    mesh->mNumFaces = static_cast<unsigned int>(mVertcnt.size());
     mesh->mFaces = new aiFace[mesh->mNumFaces];
 
     for(unsigned int i = 0,n=0, acc = 0; i < mesh->mNumFaces; ++n) {
         aiFace& f = mesh->mFaces[i];
-        if (!vertcnt[n]) {
+        if (!mVertcnt[n]) {
             --mesh->mNumFaces;
             continue;
         }
 
-        f.mNumIndices = vertcnt[n];
+        f.mNumIndices = mVertcnt[n];
         f.mIndices = new unsigned int[f.mNumIndices];
         for(unsigned int a = 0; a < f.mNumIndices; ++a) {
             f.mIndices[a] = acc++;
@@ -109,14 +109,14 @@ aiMesh* TempMesh::ToMesh()
 // ------------------------------------------------------------------------------------------------
 void TempMesh::Clear()
 {
-    verts.clear();
-    vertcnt.clear();
+    mVerts.clear();
+    mVertcnt.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 void TempMesh::Transform(const IfcMatrix4& mat)
 {
-    for(IfcVector3& v : verts) {
+    for(IfcVector3& v : mVerts) {
         v *= mat;
     }
 }
@@ -124,14 +124,14 @@ void TempMesh::Transform(const IfcMatrix4& mat)
 // ------------------------------------------------------------------------------
 IfcVector3 TempMesh::Center() const
 {
-    return (verts.size() == 0) ? IfcVector3(0.0f, 0.0f, 0.0f) : (std::accumulate(verts.begin(),verts.end(),IfcVector3()) / static_cast<IfcFloat>(verts.size()));
+    return (mVerts.size() == 0) ? IfcVector3(0.0f, 0.0f, 0.0f) : (std::accumulate(mVerts.begin(),mVerts.end(),IfcVector3()) / static_cast<IfcFloat>(mVerts.size()));
 }
 
 // ------------------------------------------------------------------------------------------------
 void TempMesh::Append(const TempMesh& other)
 {
-    verts.insert(verts.end(),other.verts.begin(),other.verts.end());
-    vertcnt.insert(vertcnt.end(),other.vertcnt.begin(),other.vertcnt.end());
+    mVerts.insert(mVerts.end(),other.mVerts.begin(),other.mVerts.end());
+    mVertcnt.insert(mVertcnt.end(),other.mVertcnt.begin(),other.mVertcnt.end());
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -147,13 +147,13 @@ void TempMesh::RemoveDegenerates()
     bool drop = false;
     size_t inor = 0;
 
-    std::vector<IfcVector3>::iterator vit = verts.begin();
-    for (std::vector<unsigned int>::iterator it = vertcnt.begin(); it != vertcnt.end(); ++inor) {
+    std::vector<IfcVector3>::iterator vit = mVerts.begin();
+    for (std::vector<unsigned int>::iterator it = mVertcnt.begin(); it != mVertcnt.end(); ++inor) {
         const unsigned int pcount = *it;
 
         if (normals[inor].SquareLength() < 1e-10f) {
-            it = vertcnt.erase(it);
-            vit = verts.erase(vit, vit + pcount);
+            it = mVertcnt.erase(it);
+            vit = mVerts.erase(vit, vit + pcount);
 
             drop = true;
             continue;
@@ -191,24 +191,24 @@ void TempMesh::ComputePolygonNormals(std::vector<IfcVector3>& normals,
     size_t ofs) const
 {
     size_t max_vcount = 0;
-    std::vector<unsigned int>::const_iterator begin = vertcnt.begin()+ofs, end = vertcnt.end(),  iit;
+    std::vector<unsigned int>::const_iterator begin = mVertcnt.begin()+ofs, end = mVertcnt.end(),  iit;
     for(iit = begin; iit != end; ++iit) {
         max_vcount = std::max(max_vcount,static_cast<size_t>(*iit));
     }
 
     std::vector<IfcFloat> temp((max_vcount+2)*4);
-    normals.reserve( normals.size() + vertcnt.size()-ofs );
+    normals.reserve( normals.size() + mVertcnt.size()-ofs );
 
     // `NewellNormal()` currently has a relatively strange interface and need to
     // re-structure things a bit to meet them.
-    size_t vidx = std::accumulate(vertcnt.begin(),begin,0);
+    size_t vidx = std::accumulate(mVertcnt.begin(),begin,0);
     for(iit = begin; iit != end; vidx += *iit++) {
         if (!*iit) {
             normals.push_back(IfcVector3());
             continue;
         }
         for(size_t vofs = 0, cnt = 0; vofs < *iit; ++vofs) {
-            const IfcVector3& v = verts[vidx+vofs];
+            const IfcVector3& v = mVerts[vidx+vofs];
             temp[cnt++] = v.x;
             temp[cnt++] = v.y;
             temp[cnt++] = v.z;
@@ -233,7 +233,7 @@ void TempMesh::ComputePolygonNormals(std::vector<IfcVector3>& normals,
 // Compute the normal of the last polygon in the given mesh
 IfcVector3 TempMesh::ComputeLastPolygonNormal(bool normalize) const
 {
-    return ComputePolygonNormal(&verts[verts.size() - vertcnt.back()], vertcnt.back(), normalize);
+    return ComputePolygonNormal(&mVerts[mVerts.size() - mVertcnt.back()], mVertcnt.back(), normalize);
 }
 
 struct CompareVector
@@ -258,27 +258,27 @@ void TempMesh::FixupFaceOrientation()
     const IfcVector3 vavg = Center();
 
     // create a list of start indices for all faces to allow random access to faces
-    std::vector<size_t> faceStartIndices(vertcnt.size());
-    for( size_t i = 0, a = 0; a < vertcnt.size(); i += vertcnt[a], ++a )
+    std::vector<size_t> faceStartIndices(mVertcnt.size());
+    for( size_t i = 0, a = 0; a < mVertcnt.size(); i += mVertcnt[a], ++a )
         faceStartIndices[a] = i;
 
     // list all faces on a vertex
     std::map<IfcVector3, std::vector<size_t>, CompareVector> facesByVertex;
-    for( size_t a = 0; a < vertcnt.size(); ++a )
+    for( size_t a = 0; a < mVertcnt.size(); ++a )
     {
-        for( size_t b = 0; b < vertcnt[a]; ++b )
-            facesByVertex[verts[faceStartIndices[a] + b]].push_back(a);
+        for( size_t b = 0; b < mVertcnt[a]; ++b )
+            facesByVertex[mVerts[faceStartIndices[a] + b]].push_back(a);
     }
     // determine neighbourhood for all polys
-    std::vector<size_t> neighbour(verts.size(), SIZE_MAX);
+    std::vector<size_t> neighbour(mVerts.size(), SIZE_MAX);
     std::vector<size_t> tempIntersect(10);
-    for( size_t a = 0; a < vertcnt.size(); ++a )
+    for( size_t a = 0; a < mVertcnt.size(); ++a )
     {
-        for( size_t b = 0; b < vertcnt[a]; ++b )
+        for( size_t b = 0; b < mVertcnt[a]; ++b )
         {
-            size_t ib = faceStartIndices[a] + b, nib = faceStartIndices[a] + (b + 1) % vertcnt[a];
-            const std::vector<size_t>& facesOnB = facesByVertex[verts[ib]];
-            const std::vector<size_t>& facesOnNB = facesByVertex[verts[nib]];
+            size_t ib = faceStartIndices[a] + b, nib = faceStartIndices[a] + (b + 1) % mVertcnt[a];
+            const std::vector<size_t>& facesOnB = facesByVertex[mVerts[ib]];
+            const std::vector<size_t>& facesOnNB = facesByVertex[mVerts[nib]];
             // there should be exactly one or two faces which appear in both lists. Our face and the other side
             std::vector<size_t>::iterator sectstart = tempIntersect.begin();
             std::vector<size_t>::iterator sectend = std::set_intersection(
@@ -295,33 +295,33 @@ void TempMesh::FixupFaceOrientation()
     // now we're getting started. We take the face which is the farthest away from the center. This face is most probably
     // facing outwards. So we reverse this face to point outwards in relation to the center. Then we adapt neighbouring
     // faces to have the same winding until all faces have been tested.
-    std::vector<bool> faceDone(vertcnt.size(), false);
+    std::vector<bool> faceDone(mVertcnt.size(), false);
     while( std::count(faceDone.begin(), faceDone.end(), false) != 0 )
     {
         // find the farthest of the remaining faces
         size_t farthestIndex = SIZE_MAX;
         IfcFloat farthestDistance = -1.0;
-        for( size_t a = 0; a < vertcnt.size(); ++a )
+        for( size_t a = 0; a < mVertcnt.size(); ++a )
         {
             if( faceDone[a] )
                 continue;
-            IfcVector3 faceCenter = std::accumulate(verts.begin() + faceStartIndices[a],
-                verts.begin() + faceStartIndices[a] + vertcnt[a], IfcVector3(0.0)) / IfcFloat(vertcnt[a]);
+            IfcVector3 faceCenter = std::accumulate(mVerts.begin() + faceStartIndices[a],
+                mVerts.begin() + faceStartIndices[a] + mVertcnt[a], IfcVector3(0.0)) / IfcFloat(mVertcnt[a]);
             IfcFloat dst = (faceCenter - vavg).SquareLength();
             if( dst > farthestDistance ) { farthestDistance = dst; farthestIndex = a; }
         }
 
         // calculate its normal and reverse the poly if its facing towards the mesh center
-        IfcVector3 farthestNormal = ComputePolygonNormal(verts.data() + faceStartIndices[farthestIndex], vertcnt[farthestIndex]);
-        IfcVector3 farthestCenter = std::accumulate(verts.begin() + faceStartIndices[farthestIndex],
-            verts.begin() + faceStartIndices[farthestIndex] + vertcnt[farthestIndex], IfcVector3(0.0))
-            / IfcFloat(vertcnt[farthestIndex]);
+        IfcVector3 farthestNormal = ComputePolygonNormal(mVerts.data() + faceStartIndices[farthestIndex], mVertcnt[farthestIndex]);
+        IfcVector3 farthestCenter = std::accumulate(mVerts.begin() + faceStartIndices[farthestIndex],
+            mVerts.begin() + faceStartIndices[farthestIndex] + mVertcnt[farthestIndex], IfcVector3(0.0))
+            / IfcFloat(mVertcnt[farthestIndex]);
         // We accapt a bit of negative orientation without reversing. In case of doubt, prefer the orientation given in
         // the file.
         if( (farthestNormal * (farthestCenter - vavg).Normalize()) < -0.4 )
         {
-            size_t fsi = faceStartIndices[farthestIndex], fvc = vertcnt[farthestIndex];
-            std::reverse(verts.begin() + fsi, verts.begin() + fsi + fvc);
+            size_t fsi = faceStartIndices[farthestIndex], fvc = mVertcnt[farthestIndex];
+            std::reverse(mVerts.begin() + fsi, mVerts.begin() + fsi + fvc);
             std::reverse(neighbour.begin() + fsi, neighbour.begin() + fsi + fvc);
             // because of the neighbour index belonging to the edge starting with the point at the same index, we need to
             // cycle the neighbours through to match the edges again.
@@ -339,7 +339,7 @@ void TempMesh::FixupFaceOrientation()
         while( !todo.empty() )
         {
             size_t tdf = todo.back();
-            size_t vsi = faceStartIndices[tdf], vc = vertcnt[tdf];
+            size_t vsi = faceStartIndices[tdf], vc = mVertcnt[tdf];
             todo.pop_back();
 
             // check its neighbours
@@ -350,19 +350,19 @@ void TempMesh::FixupFaceOrientation()
                 if( nbi == SIZE_MAX || faceDone[nbi] )
                     continue;
 
-                const IfcVector3& vp = verts[vsi + a];
-                size_t nbvsi = faceStartIndices[nbi], nbvc = vertcnt[nbi];
-                std::vector<IfcVector3>::iterator it = std::find_if(verts.begin() + nbvsi, verts.begin() + nbvsi + nbvc, FindVector(vp));
-                ai_assert(it != verts.begin() + nbvsi + nbvc);
-                size_t nb_vidx = std::distance(verts.begin() + nbvsi, it);
+                const IfcVector3& vp = mVerts[vsi + a];
+                size_t nbvsi = faceStartIndices[nbi], nbvc = mVertcnt[nbi];
+                std::vector<IfcVector3>::iterator it = std::find_if(mVerts.begin() + nbvsi, mVerts.begin() + nbvsi + nbvc, FindVector(vp));
+                ai_assert(it != mVerts.begin() + nbvsi + nbvc);
+                size_t nb_vidx = std::distance(mVerts.begin() + nbvsi, it);
                 // two faces winded in the same direction should have a crossed edge, where one face has p0->p1 and the other
                 // has p1'->p0'. If the next point on the neighbouring face is also the next on the current face, we need
                 // to reverse the neighbour
                 nb_vidx = (nb_vidx + 1) % nbvc;
                 size_t oursideidx = (a + 1) % vc;
-                if( FuzzyVectorCompare(1e-6)(verts[vsi + oursideidx], verts[nbvsi + nb_vidx]) )
+                if( FuzzyVectorCompare(1e-6)(mVerts[vsi + oursideidx], mVerts[nbvsi + nb_vidx]) )
                 {
-                    std::reverse(verts.begin() + nbvsi, verts.begin() + nbvsi + nbvc);
+                    std::reverse(mVerts.begin() + nbvsi, mVerts.begin() + nbvsi + nbvc);
                     std::reverse(neighbour.begin() + nbvsi, neighbour.begin() + nbvsi + nbvc);
                     for( size_t a = 0; a < nbvc - 1; ++a )
                         std::swap(neighbour[nbvsi + a], neighbour[nbvsi + a + 1]);
@@ -379,12 +379,10 @@ void TempMesh::FixupFaceOrientation()
 }
 
 // ------------------------------------------------------------------------------------------------
-void TempMesh::RemoveAdjacentDuplicates()
-{
-
+void TempMesh::RemoveAdjacentDuplicates() {
     bool drop = false;
-    std::vector<IfcVector3>::iterator base = verts.begin();
-    for(unsigned int& cnt : vertcnt) {
+    std::vector<IfcVector3>::iterator base = mVerts.begin();
+    for(unsigned int& cnt : mVertcnt) {
         if (cnt < 2){
             base += cnt;
             continue;
@@ -425,13 +423,13 @@ void TempMesh::RemoveAdjacentDuplicates()
         std::vector<IfcVector3>::iterator end = base+cnt, e = std::unique( base, end, fz );
         if (e != end) {
             cnt -= static_cast<unsigned int>(std::distance(e, end));
-            verts.erase(e,end);
+            mVerts.erase(e,end);
             drop  = true;
         }
 
         // check front and back vertices for this polygon
         if (cnt > 1 && fz(*base,*(base+cnt-1))) {
-            verts.erase(base+ --cnt);
+            mVerts.erase(base+ --cnt);
             drop  = true;
         }
 
@@ -447,12 +445,12 @@ void TempMesh::RemoveAdjacentDuplicates()
 // ------------------------------------------------------------------------------------------------
 void TempMesh::Swap(TempMesh& other)
 {
-    vertcnt.swap(other.vertcnt);
-    verts.swap(other.verts);
+    mVertcnt.swap(other.mVertcnt);
+    mVerts.swap(other.mVerts);
 }
 
 // ------------------------------------------------------------------------------------------------
-bool IsTrue(const EXPRESS::BOOLEAN& in)
+bool IsTrue(const ::Assimp::STEP::EXPRESS::BOOLEAN& in)
 {
     return (std::string)in == "TRUE" || (std::string)in == "T";
 }
@@ -515,7 +513,7 @@ IfcFloat ConvertSIPrefix(const std::string& prefix)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertColor(aiColor4D& out, const IfcColourRgb& in)
+void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourRgb& in)
 {
     out.r = static_cast<float>( in.Red );
     out.g = static_cast<float>( in.Green );
@@ -524,9 +522,9 @@ void ConvertColor(aiColor4D& out, const IfcColourRgb& in)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base)
+void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base)
 {
-    if (const EXPRESS::REAL* const r = in.ToPtr<EXPRESS::REAL>()) {
+    if (const ::Assimp::STEP::EXPRESS::REAL* const r = in.ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
         out.r = out.g = out.b = static_cast<float>(*r);
         if(base) {
             out.r *= static_cast<float>( base->r );
@@ -536,7 +534,7 @@ void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& co
         }
         else out.a = 1.0;
     }
-    else if (const IfcColourRgb* const rgb = in.ResolveSelectPtr<IfcColourRgb>(conv.db)) {
+    else if (const Schema_2x3::IfcColourRgb* const rgb = in.ResolveSelectPtr<Schema_2x3::IfcColourRgb>(conv.db)) {
         ConvertColor(out,*rgb);
     }
     else {
@@ -545,7 +543,7 @@ void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& co
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertCartesianPoint(IfcVector3& out, const IfcCartesianPoint& in)
+void ConvertCartesianPoint(IfcVector3& out, const Schema_2x3::IfcCartesianPoint& in)
 {
     out = IfcVector3();
     for(size_t i = 0; i < in.Coordinates.size(); ++i) {
@@ -554,14 +552,14 @@ void ConvertCartesianPoint(IfcVector3& out, const IfcCartesianPoint& in)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertVector(IfcVector3& out, const IfcVector& in)
+void ConvertVector(IfcVector3& out, const Schema_2x3::IfcVector& in)
 {
     ConvertDirection(out,in.Orientation);
     out *= in.Magnitude;
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertDirection(IfcVector3& out, const IfcDirection& in)
+void ConvertDirection(IfcVector3& out, const Schema_2x3::IfcDirection& in)
 {
     out = IfcVector3();
     for(size_t i = 0; i < in.DirectionRatios.size(); ++i) {
@@ -592,7 +590,7 @@ void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y,
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement3D& in)
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement3D& in)
 {
     IfcVector3 loc;
     ConvertCartesianPoint(loc,in.Location);
@@ -617,7 +615,7 @@ void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement3D& in)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement2D& in)
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement2D& in)
 {
     IfcVector3 loc;
     ConvertCartesianPoint(loc,in.Location);
@@ -634,7 +632,7 @@ void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement2D& in)
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IfcAxis1Placement& in)
+void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const Schema_2x3::IfcAxis1Placement& in)
 {
     ConvertCartesianPoint(pos,in.Location);
     if (in.Axis) {
@@ -646,12 +644,12 @@ void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IfcAxis1Place
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement& in, ConversionData& conv)
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement& in, ConversionData& conv)
 {
-    if(const IfcAxis2Placement3D* pl3 = in.ResolveSelectPtr<IfcAxis2Placement3D>(conv.db)) {
+    if(const Schema_2x3::IfcAxis2Placement3D* pl3 = in.ResolveSelectPtr<Schema_2x3::IfcAxis2Placement3D>(conv.db)) {
         ConvertAxisPlacement(out,*pl3);
     }
-    else if(const IfcAxis2Placement2D* pl2 = in.ResolveSelectPtr<IfcAxis2Placement2D>(conv.db)) {
+    else if(const Schema_2x3::IfcAxis2Placement2D* pl2 = in.ResolveSelectPtr<Schema_2x3::IfcAxis2Placement2D>(conv.db)) {
         ConvertAxisPlacement(out,*pl2);
     }
     else {
@@ -660,7 +658,7 @@ void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement& in, Conversi
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertTransformOperator(IfcMatrix4& out, const IfcCartesianTransformationOperator& op)
+void ConvertTransformOperator(IfcMatrix4& out, const Schema_2x3::IfcCartesianTransformationOperator& op)
 {
     IfcVector3 loc;
     ConvertCartesianPoint(loc,op.LocalOrigin);
@@ -672,7 +670,7 @@ void ConvertTransformOperator(IfcMatrix4& out, const IfcCartesianTransformationO
     if (op.Axis2) {
         ConvertDirection(y,*op.Axis2.Get());
     }
-    if (const IfcCartesianTransformationOperator3D* op2 = op.ToPtr<IfcCartesianTransformationOperator3D>()) {
+    if (const Schema_2x3::IfcCartesianTransformationOperator3D* op2 = op.ToPtr<Schema_2x3::IfcCartesianTransformationOperator3D>()) {
         if(op2->Axis3) {
             ConvertDirection(z,*op2->Axis3.Get());
         }
@@ -684,7 +682,7 @@ void ConvertTransformOperator(IfcMatrix4& out, const IfcCartesianTransformationO
 
 
     IfcVector3 vscale;
-    if (const IfcCartesianTransformationOperator3DnonUniform* nuni = op.ToPtr<IfcCartesianTransformationOperator3DnonUniform>()) {
+    if (const Schema_2x3::IfcCartesianTransformationOperator3DnonUniform* nuni = op.ToPtr<Schema_2x3::IfcCartesianTransformationOperator3DnonUniform>()) {
         vscale.x = nuni->Scale?op.Scale.Get():1.f;
         vscale.y = nuni->Scale2?nuni->Scale2.Get():1.f;
         vscale.z = nuni->Scale3?nuni->Scale3.Get():1.f;

code/IFCUtil.h → code/Importer/IFC/IFCUtil.h

@@ -46,9 +46,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IFCUTIL_H
 #define INCLUDED_IFCUTIL_H
 
-#include "IFCReaderGen.h"
+#include "IFCReaderGen_2x3.h"
 #include "IFCLoader.h"
-#include "STEPFile.h"
+#include "code/STEPFile.h"
 #include <assimp/mesh.h>
 #include <assimp/material.h>
 
@@ -71,8 +71,7 @@ namespace IFC {
 // Helper for std::for_each to delete all heap-allocated items in a container
 // ------------------------------------------------------------------------------------------------
 template<typename T>
-struct delete_fun
-{
+struct delete_fun {
     void operator()(T* del) {
         delete del;
     }
@@ -83,10 +82,9 @@ struct delete_fun
 // ------------------------------------------------------------------------------------------------
 // Helper used during mesh construction. Aids at creating aiMesh'es out of relatively few polygons.
 // ------------------------------------------------------------------------------------------------
-struct TempMesh
-{
-    std::vector<IfcVector3> verts;
-    std::vector<unsigned int> vertcnt;
+struct TempMesh {
+    std::vector<IfcVector3> mVerts;
+    std::vector<unsigned int> mVertcnt;
 
     // utilities
     aiMesh* ToMesh();
@@ -94,30 +92,28 @@ struct TempMesh
     void Transform(const IfcMatrix4& mat);
     IfcVector3 Center() const;
     void Append(const TempMesh& other);
-
-    bool IsEmpty() const {
-        return verts.empty() && vertcnt.empty();
-    }
-
+    bool IsEmpty() const;
     void RemoveAdjacentDuplicates();
     void RemoveDegenerates();
-
     void FixupFaceOrientation();
-
     static IfcVector3 ComputePolygonNormal(const IfcVector3* vtcs, size_t cnt, bool normalize = true);
     IfcVector3 ComputeLastPolygonNormal(bool normalize = true) const;
     void ComputePolygonNormals(std::vector<IfcVector3>& normals, bool normalize = true, size_t ofs = 0) const;
-
     void Swap(TempMesh& other);
 };
 
+inline
+bool TempMesh::IsEmpty() const {
+    return mVerts.empty() && mVertcnt.empty();
+}
+
 
 // ------------------------------------------------------------------------------------------------
 // Temporary representation of an opening in a wall or a floor
 // ------------------------------------------------------------------------------------------------
 struct TempOpening
 {
-    const IFC::IfcSolidModel* solid;
+    const IFC::Schema_2x3::IfcSolidModel *solid;
     IfcVector3 extrusionDir;
 
     std::shared_ptr<TempMesh> profileMesh;
@@ -139,7 +135,7 @@ struct TempOpening
     }
 
     // ------------------------------------------------------------------------------
-    TempOpening(const IFC::IfcSolidModel* solid,IfcVector3 extrusionDir,
+    TempOpening(const IFC::Schema_2x3::IfcSolidModel* solid,IfcVector3 extrusionDir,
         std::shared_ptr<TempMesh> profileMesh,
         std::shared_ptr<TempMesh> profileMesh2D)
         : solid(solid)
@@ -174,7 +170,7 @@ struct TempOpening
 // ------------------------------------------------------------------------------------------------
 struct ConversionData
 {
-    ConversionData(const STEP::DB& db, const IFC::IfcProject& proj, aiScene* out,const IFCImporter::Settings& settings)
+    ConversionData(const STEP::DB& db, const IFC::Schema_2x3::IfcProject& proj, aiScene* out,const IFCImporter::Settings& settings)
         : len_scale(1.0)
         , angle_scale(-1.0)
         , db(db)
@@ -194,7 +190,7 @@ struct ConversionData
     bool plane_angle_in_radians;
 
     const STEP::DB& db;
-    const IFC::IfcProject& proj;
+    const IFC::Schema_2x3::IfcProject& proj;
     aiScene* out;
 
     IfcMatrix4 wcs;
@@ -202,16 +198,16 @@ struct ConversionData
     std::vector<aiMaterial*> materials;
 
     struct MeshCacheIndex {
-        const IFC::IfcRepresentationItem* item; unsigned int matindex;
+        const IFC::Schema_2x3::IfcRepresentationItem* item; unsigned int matindex;
         MeshCacheIndex() : item(NULL), matindex(0) { }
-        MeshCacheIndex(const IFC::IfcRepresentationItem* i, unsigned int mi) : item(i), matindex(mi) { }
+        MeshCacheIndex(const IFC::Schema_2x3::IfcRepresentationItem* i, unsigned int mi) : item(i), matindex(mi) { }
         bool operator == (const MeshCacheIndex& o) const { return item == o.item && matindex == o.matindex; }
         bool operator < (const MeshCacheIndex& o) const { return item < o.item || (item == o.item && matindex < o.matindex); }
     };
     typedef std::map<MeshCacheIndex, std::vector<unsigned int> > MeshCache;
     MeshCache cached_meshes;
 
-    typedef std::map<const IFC::IfcSurfaceStyle*, unsigned int> MaterialCache;
+    typedef std::map<const IFC::Schema_2x3::IfcSurfaceStyle*, unsigned int> MaterialCache;
     MaterialCache cached_materials;
 
     const IFCImporter::Settings& settings;
@@ -260,50 +256,50 @@ struct XYSorter {
 
 
 // conversion routines for common IFC entities, implemented in IFCUtil.cpp
-void ConvertColor(aiColor4D& out, const IfcColourRgb& in);
-void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base);
-void ConvertCartesianPoint(IfcVector3& out, const IfcCartesianPoint& in);
-void ConvertDirection(IfcVector3& out, const IfcDirection& in);
-void ConvertVector(IfcVector3& out, const IfcVector& in);
+void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourRgb& in);
+void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base);
+void ConvertCartesianPoint(IfcVector3& out, const Schema_2x3::IfcCartesianPoint& in);
+void ConvertDirection(IfcVector3& out, const Schema_2x3::IfcDirection& in);
+void ConvertVector(IfcVector3& out, const Schema_2x3::IfcVector& in);
 void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y, const IfcVector3& z);
-void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement3D& in);
-void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement2D& in);
-void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IFC::IfcAxis1Placement& in);
-void ConvertAxisPlacement(IfcMatrix4& out, const IfcAxis2Placement& in, ConversionData& conv);
-void ConvertTransformOperator(IfcMatrix4& out, const IfcCartesianTransformationOperator& op);
-bool IsTrue(const EXPRESS::BOOLEAN& in);
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement3D& in);
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement2D& in);
+void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IFC::Schema_2x3::IfcAxis1Placement& in);
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement& in, ConversionData& conv);
+void ConvertTransformOperator(IfcMatrix4& out, const Schema_2x3::IfcCartesianTransformationOperator& op);
+bool IsTrue(const Assimp::STEP::EXPRESS::BOOLEAN& in);
 IfcFloat ConvertSIPrefix(const std::string& prefix);
 
 
 // IFCProfile.cpp
-bool ProcessProfile(const IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv);
-bool ProcessCurve(const IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
+bool ProcessProfile(const Schema_2x3::IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv);
+bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
 
 // IFCMaterial.cpp
 unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionData& conv, bool forceDefaultMat);
 
 // IFCGeometry.cpp
 IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVector3& norOut);
-bool ProcessRepresentationItem(const IfcRepresentationItem& item, unsigned int matid, std::vector<unsigned int>& mesh_indices, ConversionData& conv);
+bool ProcessRepresentationItem(const Schema_2x3::IfcRepresentationItem& item, unsigned int matid, std::vector<unsigned int>& mesh_indices, ConversionData& conv);
 void AssignAddedMeshes(std::vector<unsigned int>& mesh_indices,aiNode* nd,ConversionData& /*conv*/);
 
-void ProcessSweptAreaSolid(const IfcSweptAreaSolid& swept, TempMesh& meshout,
+void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh& meshout,
                            ConversionData& conv);
 
-void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& result,
+void ProcessExtrudedAreaSolid(const Schema_2x3::IfcExtrudedAreaSolid& solid, TempMesh& result,
                               ConversionData& conv, bool collect_openings);
 
 // IFCBoolean.cpp
 
-void ProcessBoolean(const IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv);
-void ProcessBooleanHalfSpaceDifference(const IfcHalfSpaceSolid* hs, TempMesh& result,
+void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv);
+void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs, TempMesh& result,
                                        const TempMesh& first_operand,
                                        ConversionData& conv);
 
-void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
+void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
                                                        const TempMesh& first_operand,
                                                        ConversionData& conv);
-void ProcessBooleanExtrudedAreaSolidDifference(const IfcExtrudedAreaSolid* as, TempMesh& result,
+void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid* as, TempMesh& result,
                                                const TempMesh& first_operand,
                                                ConversionData& conv);
 
@@ -324,38 +320,31 @@ bool GenerateOpenings(std::vector<TempOpening>& openings,
 // ------------------------------------------------------------------------------------------------
 // Custom exception for use by members of the Curve class
 // ------------------------------------------------------------------------------------------------
-class CurveError
-{
+class CurveError {
 public:
     CurveError(const std::string& s)
-        : s(s)
-    {
+    : mStr(s) {
+        // empty
     }
 
-    std::string s;
+    std::string mStr;
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Temporary representation for an arbitrary sub-class of IfcCurve. Used to sample the curves
 // to obtain a list of line segments.
 // ------------------------------------------------------------------------------------------------
-class Curve
-{
+class Curve {
 protected:
-
-    Curve(const IfcCurve& base_entity, ConversionData& conv)
-        : base_entity(base_entity)
-        , conv(conv)
-    {}
+    Curve(const Schema_2x3::IfcCurve& base_entity, ConversionData& conv)
+    : base_entity(base_entity)
+    , conv(conv) {
+        // empty
+    }
 
 public:
-
     typedef std::pair<IfcFloat, IfcFloat> ParamRange;
 
-public:
-
-
     virtual ~Curve() {}
 
 
@@ -386,14 +375,10 @@ public:
     // check if a particular parameter value lies within the well-defined range
     bool InRange(IfcFloat) const;
 #endif
-
-public:
-
-    static Curve* Convert(const IFC::IfcCurve&,ConversionData& conv);
+    static Curve* Convert(const IFC::Schema_2x3::IfcCurve&,ConversionData& conv);
 
 protected:
-
-    const IfcCurve& base_entity;
+    const Schema_2x3::IfcCurve& base_entity;
     ConversionData& conv;
 };
 
@@ -402,11 +387,9 @@ protected:
 // A BoundedCurve always holds the invariant that GetParametricRange()
 // never returns infinite values.
 // --------------------------------------------------------------------------------
-class BoundedCurve : public Curve
-{
+class BoundedCurve : public Curve {
 public:
-
-    BoundedCurve(const IfcBoundedCurve& entity, ConversionData& conv)
+    BoundedCurve(const Schema_2x3::IfcBoundedCurve& entity, ConversionData& conv)
         : Curve(entity,conv)
     {}
 
@@ -422,7 +405,7 @@ public:
 };
 
 // IfcProfile.cpp
-bool ProcessCurve(const IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
+bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
 }
 }
 

code/STEPFileEncoding.cpp → code/Importer/IFC/STEPFileEncoding.cpp

@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief STEP character handling, string un-escaping
  */
 #include "STEPFileEncoding.h"
-#include "fast_atof.h"
+#include "code/fast_atof.h"
 #include <contrib/utf8cpp/source/utf8.h>
 
 #include <memory>

code/STEPFileReader.cpp → code/Importer/IFC/STEPFileReader.cpp

@@ -46,8 +46,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "STEPFileReader.h"
 #include "STEPFileEncoding.h"
-#include "TinyFormatter.h"
-#include "fast_atof.h"
+#include "code/TinyFormatter.h"
+#include "code/fast_atof.h"
 #include <memory>
 
 

code/STEPFileReader.h → code/Importer/IFC/STEPFileReader.h

@@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_STEPFILEREADER_H
 #define INCLUDED_AI_STEPFILEREADER_H
 
-#include "STEPFile.h"
+#include "code/STEPFile.h"
 
 namespace Assimp {
 namespace STEP {

code/ImporterRegistry.cpp

@@ -169,7 +169,7 @@ corresponding preprocessor flag to selectively disable formats.
 #   include "NDOLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#   include "IFCLoader.h"
+#   include "Importer/IFC/IFCLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_XGL_IMPORTER
 #   include "XGLLoader.h"

code/LogAux.h

@@ -51,12 +51,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp {
 
-template <class TDeriving>
-class LogFunctions
-{
-
+template<class TDeriving>
+class LogFunctions {
 public:
-
     // ------------------------------------------------------------------------------------------------
     static void ThrowException(const std::string& msg)
     {

code/STEPFile.h

@@ -364,17 +364,16 @@ namespace STEP {
         // -------------------------------------------------------------------------------
         class ConversionSchema
         {
-
         public:
-
             struct SchemaEntry {
-                SchemaEntry(const char* name,ConvertObjectProc func)
-                    : name(name)
-                    , func(func)
-                {}
+                SchemaEntry( const char *name, ConvertObjectProc func )
+                : mName( name )
+                , mFunc(func) {
+                    // empty
+                }
 
-                const char* name;
-                ConvertObjectProc func;
+                const char* mName;
+                ConvertObjectProc mFunc;
             };
 
             typedef std::map<std::string,ConvertObjectProc> ConverterMap;
@@ -410,7 +409,7 @@ namespace STEP {
             const ConversionSchema& operator=( const SchemaEntry (& schemas)[N]) {
                 for(size_t i = 0; i < N; ++i ) {
                     const SchemaEntry& schema = schemas[i];
-                    converters[schema.name] = schema.func;
+                    converters[schema.mName] = schema.mFunc;
                 }
                 return *this;
             }

scripts/IFCImporter/ExpressReader.py

@@ -94,8 +94,9 @@ class Type:
         self.enums = enums
         
 
-def read(filename,silent=False):
+def read(filename, silent=False):
     schema = Schema()
+    print( "Try to read EXPRESS schema file" + filename)
     with open(filename,'rt') as inp: 
         contents = inp.read()
         types = re.findall(re_match_type,contents)

scripts/IFCImporter/schema_ifc4.exp

@@ -0,0 +1,12401 @@
+(*
+Copyright by:
+buildingSMART International Limited, 1996-2016
+
+Any technical documentation made available by buildingSMART International Limited
+is the copyrighted work of buildingSMART International Limited and is owned by the 
+buildingSMART International Limited. It may be photocopied, used in software development, 
+or translated into another computer language without prior written consent from 
+buildingSMART International Limited provided that full attribution is given. 
+Prior written consent is required if changes are made to the technical specification.
+
+This material is delivered to you as is and buildingSMART International Limited makes 
+no warranty of any kind with regard to it, including, but not limited to, the implied 
+warranties as to its accuracy or fitness for a particular purpose. Any use of the 
+technical documentation or the information contained therein is at the risk of the user. 
+Documentation may include technical or other inaccuracies or typographical errors. 
+buildingSMART International Limited shall not be liable for errors contained therein or 
+for incidental consequential damages in connection with the furnishing, performance or use 
+of the material. The information contained in this document is subject to change without notice.
+
+Issue date:
+Montag, 11. Juli 2016
+
+*)
+
+SCHEMA IFC4;
+
+TYPE IfcStrippedOptional = BOOLEAN;
+END_TYPE;
+
+TYPE IfcAbsorbedDoseMeasure = REAL;
+END_TYPE;
+
+TYPE IfcAccelerationMeasure = REAL;
+END_TYPE;
+
+TYPE IfcAmountOfSubstanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcAngularVelocityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcArcIndex = LIST [3:3] OF IfcPositiveInteger;
+END_TYPE;
+
+TYPE IfcAreaDensityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcAreaMeasure = REAL;
+END_TYPE;
+
+TYPE IfcBinary = BINARY;
+END_TYPE;
+
+TYPE IfcBoolean = BOOLEAN;
+END_TYPE;
+
+TYPE IfcBoxAlignment = IfcLabel;
+ WHERE
+	WR1 : SELF IN ['top-left', 'top-middle', 'top-right', 'middle-left', 'center', 'middle-right', 'bottom-left', 'bottom-middle', 'bottom-right'];
+END_TYPE;
+
+TYPE IfcCardinalPointReference = INTEGER;
+ WHERE
+	GreaterThanZero : SELF > 0;
+END_TYPE;
+
+TYPE IfcComplexNumber = ARRAY [1:2] OF REAL;
+END_TYPE;
+
+TYPE IfcCompoundPlaneAngleMeasure = LIST [3:4] OF INTEGER;
+ WHERE
+	MinutesInRange : ABS(SELF[2]) < 60;
+	SecondsInRange : ABS(SELF[3]) < 60;
+	MicrosecondsInRange : (SIZEOF(SELF) = 3) OR (ABS(SELF[4]) < 1000000);
+	ConsistentSign : ((SELF[1] >= 0) AND (SELF[2] >= 0) AND (SELF[3] >= 0) AND ((SIZEOF(SELF) = 3) OR (SELF[4] >= 0)))
+OR
+((SELF[1] <= 0) AND (SELF[2] <= 0) AND (SELF[3] <= 0) AND ((SIZEOF(SELF) = 3) OR (SELF[4] <= 0)));
+END_TYPE;
+
+TYPE IfcContextDependentMeasure = REAL;
+END_TYPE;
+
+TYPE IfcCountMeasure = NUMBER;
+END_TYPE;
+
+TYPE IfcCurvatureMeasure = REAL;
+END_TYPE;
+
+TYPE IfcDate = STRING;
+END_TYPE;
+
+TYPE IfcDateTime = STRING;
+END_TYPE;
+
+TYPE IfcDayInMonthNumber = INTEGER;
+ WHERE
+	ValidRange : {1 <= SELF <= 31};
+END_TYPE;
+
+TYPE IfcDayInWeekNumber = INTEGER;
+ WHERE
+	ValidRange : {1 <= SELF <= 7};
+END_TYPE;
+
+TYPE IfcDescriptiveMeasure = STRING;
+END_TYPE;
+
+TYPE IfcDimensionCount = INTEGER;
+ WHERE
+	WR1 : { 0 < SELF <= 3 };
+END_TYPE;
+
+TYPE IfcDoseEquivalentMeasure = REAL;
+END_TYPE;
+
+TYPE IfcDuration = STRING;
+END_TYPE;
+
+TYPE IfcDynamicViscosityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcElectricCapacitanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcElectricChargeMeasure = REAL;
+END_TYPE;
+
+TYPE IfcElectricConductanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcElectricCurrentMeasure = REAL;
+END_TYPE;
+
+TYPE IfcElectricResistanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcElectricVoltageMeasure = REAL;
+END_TYPE;
+
+TYPE IfcEnergyMeasure = REAL;
+END_TYPE;
+
+TYPE IfcFontStyle = STRING;
+ WHERE
+	WR1 : SELF IN ['normal','italic','oblique'];
+END_TYPE;
+
+TYPE IfcFontVariant = STRING;
+ WHERE
+	WR1 : SELF IN ['normal','small-caps'];
+END_TYPE;
+
+TYPE IfcFontWeight = STRING;
+ WHERE
+	WR1 : SELF IN ['normal','small-caps','100','200','300','400','500','600','700','800','900'];
+END_TYPE;
+
+TYPE IfcForceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcFrequencyMeasure = REAL;
+END_TYPE;
+
+TYPE IfcGloballyUniqueId = STRING(22) FIXED;
+END_TYPE;
+
+TYPE IfcHeatFluxDensityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcHeatingValueMeasure = REAL;
+ WHERE
+	WR1 : SELF > 0.;
+END_TYPE;
+
+TYPE IfcIdentifier = STRING(255);
+END_TYPE;
+
+TYPE IfcIlluminanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcInductanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcInteger = INTEGER;
+END_TYPE;
+
+TYPE IfcIntegerCountRateMeasure = INTEGER;
+END_TYPE;
+
+TYPE IfcIonConcentrationMeasure = REAL;
+END_TYPE;
+
+TYPE IfcIsothermalMoistureCapacityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcKinematicViscosityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLabel = STRING(255);
+END_TYPE;
+
+TYPE IfcLanguageId = IfcIdentifier;
+END_TYPE;
+
+TYPE IfcLengthMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLineIndex = LIST [2:?] OF IfcPositiveInteger;
+END_TYPE;
+
+TYPE IfcLinearForceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLinearMomentMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLinearStiffnessMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLinearVelocityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLogical = LOGICAL;
+END_TYPE;
+
+TYPE IfcLuminousFluxMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLuminousIntensityDistributionMeasure = REAL;
+END_TYPE;
+
+TYPE IfcLuminousIntensityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMagneticFluxDensityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMagneticFluxMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMassDensityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMassFlowRateMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMassMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMassPerLengthMeasure = REAL;
+END_TYPE;
+
+TYPE IfcModulusOfElasticityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcModulusOfLinearSubgradeReactionMeasure = REAL;
+END_TYPE;
+
+TYPE IfcModulusOfRotationalSubgradeReactionMeasure = REAL;
+END_TYPE;
+
+TYPE IfcModulusOfSubgradeReactionMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMoistureDiffusivityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMolecularWeightMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMomentOfInertiaMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMonetaryMeasure = REAL;
+END_TYPE;
+
+TYPE IfcMonthInYearNumber = INTEGER;
+ WHERE
+	ValidRange : {1 <= SELF <= 12};
+END_TYPE;
+
+TYPE IfcNonNegativeLengthMeasure = IfcLengthMeasure;
+ WHERE
+	NotNegative : SELF >= 0.;
+END_TYPE;
+
+TYPE IfcNormalisedRatioMeasure = IfcRatioMeasure;
+ WHERE
+	WR1 : {0.0 <= SELF <= 1.0};
+END_TYPE;
+
+TYPE IfcNumericMeasure = NUMBER;
+END_TYPE;
+
+TYPE IfcPHMeasure = REAL;
+ WHERE
+	WR21 : {0.0 <= SELF <= 14.0};
+END_TYPE;
+
+TYPE IfcParameterValue = REAL;
+END_TYPE;
+
+TYPE IfcPlanarForceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcPlaneAngleMeasure = REAL;
+END_TYPE;
+
+TYPE IfcPositiveInteger = IfcInteger;
+ WHERE
+	WR1 : SELF > 0;
+END_TYPE;
+
+TYPE IfcPositiveLengthMeasure = IfcLengthMeasure;
+ WHERE
+	WR1 : SELF > 0.;
+END_TYPE;
+
+TYPE IfcPositivePlaneAngleMeasure = IfcPlaneAngleMeasure;
+ WHERE
+	WR1 : SELF > 0.;
+END_TYPE;
+
+TYPE IfcPositiveRatioMeasure = IfcRatioMeasure;
+ WHERE
+	WR1 : SELF > 0.;
+END_TYPE;
+
+TYPE IfcPowerMeasure = REAL;
+END_TYPE;
+
+TYPE IfcPresentableText = STRING;
+END_TYPE;
+
+TYPE IfcPressureMeasure = REAL;
+END_TYPE;
+
+TYPE IfcPropertySetDefinitionSet = SET [1:?] OF IfcPropertySetDefinition;
+END_TYPE;
+
+TYPE IfcRadioActivityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcRatioMeasure = REAL;
+END_TYPE;
+
+TYPE IfcReal = REAL;
+END_TYPE;
+
+TYPE IfcRotationalFrequencyMeasure = REAL;
+END_TYPE;
+
+TYPE IfcRotationalMassMeasure = REAL;
+END_TYPE;
+
+TYPE IfcRotationalStiffnessMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSectionModulusMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSectionalAreaIntegralMeasure = REAL;
+END_TYPE;
+
+TYPE IfcShearModulusMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSolidAngleMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSoundPowerLevelMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSoundPowerMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSoundPressureLevelMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSoundPressureMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSpecificHeatCapacityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcSpecularExponent = REAL;
+END_TYPE;
+
+TYPE IfcSpecularRoughness = REAL;
+ WHERE
+	WR1 : {0.0 <= SELF <= 1.0};
+END_TYPE;
+
+TYPE IfcTemperatureGradientMeasure = REAL;
+END_TYPE;
+
+TYPE IfcTemperatureRateOfChangeMeasure = REAL;
+END_TYPE;
+
+TYPE IfcText = STRING;
+END_TYPE;
+
+TYPE IfcTextAlignment = STRING;
+ WHERE
+	WR1 : SELF IN ['left', 'right', 'center', 'justify'];
+END_TYPE;
+
+TYPE IfcTextDecoration = STRING;
+ WHERE
+	WR1 : SELF IN ['none', 'underline', 'overline', 'line-through', 'blink'];
+END_TYPE;
+
+TYPE IfcTextFontName = STRING;
+END_TYPE;
+
+TYPE IfcTextTransformation = STRING;
+ WHERE
+	WR1 : SELF IN ['capitalize', 'uppercase', 'lowercase', 'none'];
+END_TYPE;
+
+TYPE IfcThermalAdmittanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcThermalConductivityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcThermalExpansionCoefficientMeasure = REAL;
+END_TYPE;
+
+TYPE IfcThermalResistanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcThermalTransmittanceMeasure = REAL;
+END_TYPE;
+
+TYPE IfcThermodynamicTemperatureMeasure = REAL;
+END_TYPE;
+
+TYPE IfcTime = STRING;
+END_TYPE;
+
+TYPE IfcTimeMeasure = REAL;
+END_TYPE;
+
+TYPE IfcTimeStamp = INTEGER;
+END_TYPE;
+
+TYPE IfcTorqueMeasure = REAL;
+END_TYPE;
+
+TYPE IfcURIReference = STRING;
+END_TYPE;
+
+TYPE IfcVaporPermeabilityMeasure = REAL;
+END_TYPE;
+
+TYPE IfcVolumeMeasure = REAL;
+END_TYPE;
+
+TYPE IfcVolumetricFlowRateMeasure = REAL;
+END_TYPE;
+
+TYPE IfcWarpingConstantMeasure = REAL;
+END_TYPE;
+
+TYPE IfcWarpingMomentMeasure = REAL;
+END_TYPE;
+
+TYPE IfcActionRequestTypeEnum = ENUMERATION OF
+	(EMAIL
+	,FAX
+	,PHONE
+	,POST
+	,VERBAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcActionSourceTypeEnum = ENUMERATION OF
+	(DEAD_LOAD_G
+	,COMPLETION_G1
+	,LIVE_LOAD_Q
+	,SNOW_S
+	,WIND_W
+	,PRESTRESSING_P
+	,SETTLEMENT_U
+	,TEMPERATURE_T
+	,EARTHQUAKE_E
+	,FIRE
+	,IMPULSE
+	,IMPACT
+	,TRANSPORT
+	,ERECTION
+	,PROPPING
+	,SYSTEM_IMPERFECTION
+	,SHRINKAGE
+	,CREEP
+	,LACK_OF_FIT
+	,BUOYANCY
+	,ICE
+	,CURRENT
+	,WAVE
+	,RAIN
+	,BRAKES
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcActionTypeEnum = ENUMERATION OF
+	(PERMANENT_G
+	,VARIABLE_Q
+	,EXTRAORDINARY_A
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcActuatorTypeEnum = ENUMERATION OF
+	(ELECTRICACTUATOR
+	,HANDOPERATEDACTUATOR
+	,HYDRAULICACTUATOR
+	,PNEUMATICACTUATOR
+	,THERMOSTATICACTUATOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAddressTypeEnum = ENUMERATION OF
+	(OFFICE
+	,SITE
+	,HOME
+	,DISTRIBUTIONPOINT
+	,USERDEFINED);
+END_TYPE;
+
+TYPE IfcAirTerminalBoxTypeEnum = ENUMERATION OF
+	(CONSTANTFLOW
+	,VARIABLEFLOWPRESSUREDEPENDANT
+	,VARIABLEFLOWPRESSUREINDEPENDANT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAirTerminalTypeEnum = ENUMERATION OF
+	(DIFFUSER
+	,GRILLE
+	,LOUVRE
+	,REGISTER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAirToAirHeatRecoveryTypeEnum = ENUMERATION OF
+	(FIXEDPLATECOUNTERFLOWEXCHANGER
+	,FIXEDPLATECROSSFLOWEXCHANGER
+	,FIXEDPLATEPARALLELFLOWEXCHANGER
+	,ROTARYWHEEL
+	,RUNAROUNDCOILLOOP
+	,HEATPIPE
+	,TWINTOWERENTHALPYRECOVERYLOOPS
+	,THERMOSIPHONSEALEDTUBEHEATEXCHANGERS
+	,THERMOSIPHONCOILTYPEHEATEXCHANGERS
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAlarmTypeEnum = ENUMERATION OF
+	(BELL
+	,BREAKGLASSBUTTON
+	,LIGHT
+	,MANUALPULLBOX
+	,SIREN
+	,WHISTLE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAnalysisModelTypeEnum = ENUMERATION OF
+	(IN_PLANE_LOADING_2D
+	,OUT_PLANE_LOADING_2D
+	,LOADING_3D
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAnalysisTheoryTypeEnum = ENUMERATION OF
+	(FIRST_ORDER_THEORY
+	,SECOND_ORDER_THEORY
+	,THIRD_ORDER_THEORY
+	,FULL_NONLINEAR_THEORY
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcArithmeticOperatorEnum = ENUMERATION OF
+	(ADD
+	,DIVIDE
+	,MULTIPLY
+	,SUBTRACT);
+END_TYPE;
+
+TYPE IfcAssemblyPlaceEnum = ENUMERATION OF
+	(SITE
+	,FACTORY
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcAudioVisualApplianceTypeEnum = ENUMERATION OF
+	(AMPLIFIER
+	,CAMERA
+	,DISPLAY
+	,MICROPHONE
+	,PLAYER
+	,PROJECTOR
+	,RECEIVER
+	,SPEAKER
+	,SWITCHER
+	,TELEPHONE
+	,TUNER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcBSplineCurveForm = ENUMERATION OF
+	(POLYLINE_FORM
+	,CIRCULAR_ARC
+	,ELLIPTIC_ARC
+	,PARABOLIC_ARC
+	,HYPERBOLIC_ARC
+	,UNSPECIFIED);
+END_TYPE;
+
+TYPE IfcBSplineSurfaceForm = ENUMERATION OF
+	(PLANE_SURF
+	,CYLINDRICAL_SURF
+	,CONICAL_SURF
+	,SPHERICAL_SURF
+	,TOROIDAL_SURF
+	,SURF_OF_REVOLUTION
+	,RULED_SURF
+	,GENERALISED_CONE
+	,QUADRIC_SURF
+	,SURF_OF_LINEAR_EXTRUSION
+	,UNSPECIFIED);
+END_TYPE;
+
+TYPE IfcBeamTypeEnum = ENUMERATION OF
+	(BEAM
+	,JOIST
+	,HOLLOWCORE
+	,LINTEL
+	,SPANDREL
+	,T_BEAM
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcBenchmarkEnum = ENUMERATION OF
+	(GREATERTHAN
+	,GREATERTHANOREQUALTO
+	,LESSTHAN
+	,LESSTHANOREQUALTO
+	,EQUALTO
+	,NOTEQUALTO
+	,INCLUDES
+	,NOTINCLUDES
+	,INCLUDEDIN
+	,NOTINCLUDEDIN);
+END_TYPE;
+
+TYPE IfcBoilerTypeEnum = ENUMERATION OF
+	(WATER
+	,STEAM
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcBooleanOperator = ENUMERATION OF
+	(UNION
+	,INTERSECTION
+	,DIFFERENCE);
+END_TYPE;
+
+TYPE IfcBuildingElementPartTypeEnum = ENUMERATION OF
+	(INSULATION
+	,PRECASTPANEL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcBuildingElementProxyTypeEnum = ENUMERATION OF
+	(COMPLEX
+	,ELEMENT
+	,PARTIAL
+	,PROVISIONFORVOID
+	,PROVISIONFORSPACE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcBuildingSystemTypeEnum = ENUMERATION OF
+	(FENESTRATION
+	,FOUNDATION
+	,LOADBEARING
+	,OUTERSHELL
+	,SHADING
+	,TRANSPORT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcBurnerTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCableCarrierFittingTypeEnum = ENUMERATION OF
+	(BEND
+	,CROSS
+	,REDUCER
+	,TEE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCableCarrierSegmentTypeEnum = ENUMERATION OF
+	(CABLELADDERSEGMENT
+	,CABLETRAYSEGMENT
+	,CABLETRUNKINGSEGMENT
+	,CONDUITSEGMENT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCableFittingTypeEnum = ENUMERATION OF
+	(CONNECTOR
+	,ENTRY
+	,EXIT
+	,JUNCTION
+	,TRANSITION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCableSegmentTypeEnum = ENUMERATION OF
+	(BUSBARSEGMENT
+	,CABLESEGMENT
+	,CONDUCTORSEGMENT
+	,CORESEGMENT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcChangeActionEnum = ENUMERATION OF
+	(NOCHANGE
+	,MODIFIED
+	,ADDED
+	,DELETED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcChillerTypeEnum = ENUMERATION OF
+	(AIRCOOLED
+	,WATERCOOLED
+	,HEATRECOVERY
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcChimneyTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCoilTypeEnum = ENUMERATION OF
+	(DXCOOLINGCOIL
+	,ELECTRICHEATINGCOIL
+	,GASHEATINGCOIL
+	,HYDRONICCOIL
+	,STEAMHEATINGCOIL
+	,WATERCOOLINGCOIL
+	,WATERHEATINGCOIL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcColumnTypeEnum = ENUMERATION OF
+	(COLUMN
+	,PILASTER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCommunicationsApplianceTypeEnum = ENUMERATION OF
+	(ANTENNA
+	,COMPUTER
+	,FAX
+	,GATEWAY
+	,MODEM
+	,NETWORKAPPLIANCE
+	,NETWORKBRIDGE
+	,NETWORKHUB
+	,PRINTER
+	,REPEATER
+	,ROUTER
+	,SCANNER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcComplexPropertyTemplateTypeEnum = ENUMERATION OF
+	(P_COMPLEX
+	,Q_COMPLEX);
+END_TYPE;
+
+TYPE IfcCompressorTypeEnum = ENUMERATION OF
+	(DYNAMIC
+	,RECIPROCATING
+	,ROTARY
+	,SCROLL
+	,TROCHOIDAL
+	,SINGLESTAGE
+	,BOOSTER
+	,OPENTYPE
+	,HERMETIC
+	,SEMIHERMETIC
+	,WELDEDSHELLHERMETIC
+	,ROLLINGPISTON
+	,ROTARYVANE
+	,SINGLESCREW
+	,TWINSCREW
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCondenserTypeEnum = ENUMERATION OF
+	(AIRCOOLED
+	,EVAPORATIVECOOLED
+	,WATERCOOLED
+	,WATERCOOLEDBRAZEDPLATE
+	,WATERCOOLEDSHELLCOIL
+	,WATERCOOLEDSHELLTUBE
+	,WATERCOOLEDTUBEINTUBE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcConnectionTypeEnum = ENUMERATION OF
+	(ATPATH
+	,ATSTART
+	,ATEND
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcConstraintEnum = ENUMERATION OF
+	(HARD
+	,SOFT
+	,ADVISORY
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcConstructionEquipmentResourceTypeEnum = ENUMERATION OF
+	(DEMOLISHING
+	,EARTHMOVING
+	,ERECTING
+	,HEATING
+	,LIGHTING
+	,PAVING
+	,PUMPING
+	,TRANSPORTING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcConstructionMaterialResourceTypeEnum = ENUMERATION OF
+	(AGGREGATES
+	,CONCRETE
+	,DRYWALL
+	,FUEL
+	,GYPSUM
+	,MASONRY
+	,METAL
+	,PLASTIC
+	,WOOD
+	,NOTDEFINED
+	,USERDEFINED);
+END_TYPE;
+
+TYPE IfcConstructionProductResourceTypeEnum = ENUMERATION OF
+	(ASSEMBLY
+	,FORMWORK
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcControllerTypeEnum = ENUMERATION OF
+	(FLOATING
+	,PROGRAMMABLE
+	,PROPORTIONAL
+	,MULTIPOSITION
+	,TWOPOSITION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCooledBeamTypeEnum = ENUMERATION OF
+	(ACTIVE
+	,PASSIVE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCoolingTowerTypeEnum = ENUMERATION OF
+	(NATURALDRAFT
+	,MECHANICALINDUCEDDRAFT
+	,MECHANICALFORCEDDRAFT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCostItemTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCostScheduleTypeEnum = ENUMERATION OF
+	(BUDGET
+	,COSTPLAN
+	,ESTIMATE
+	,TENDER
+	,PRICEDBILLOFQUANTITIES
+	,UNPRICEDBILLOFQUANTITIES
+	,SCHEDULEOFRATES
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCoveringTypeEnum = ENUMERATION OF
+	(CEILING
+	,FLOORING
+	,CLADDING
+	,ROOFING
+	,MOLDING
+	,SKIRTINGBOARD
+	,INSULATION
+	,MEMBRANE
+	,SLEEVING
+	,WRAPPING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCrewResourceTypeEnum = ENUMERATION OF
+	(OFFICE
+	,SITE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCurtainWallTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcCurveInterpolationEnum = ENUMERATION OF
+	(LINEAR
+	,LOG_LINEAR
+	,LOG_LOG
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDamperTypeEnum = ENUMERATION OF
+	(BACKDRAFTDAMPER
+	,BALANCINGDAMPER
+	,BLASTDAMPER
+	,CONTROLDAMPER
+	,FIREDAMPER
+	,FIRESMOKEDAMPER
+	,FUMEHOODEXHAUST
+	,GRAVITYDAMPER
+	,GRAVITYRELIEFDAMPER
+	,RELIEFDAMPER
+	,SMOKEDAMPER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDataOriginEnum = ENUMERATION OF
+	(MEASURED
+	,PREDICTED
+	,SIMULATED
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDerivedUnitEnum = ENUMERATION OF
+	(ANGULARVELOCITYUNIT
+	,AREADENSITYUNIT
+	,COMPOUNDPLANEANGLEUNIT
+	,DYNAMICVISCOSITYUNIT
+	,HEATFLUXDENSITYUNIT
+	,INTEGERCOUNTRATEUNIT
+	,ISOTHERMALMOISTURECAPACITYUNIT
+	,KINEMATICVISCOSITYUNIT
+	,LINEARVELOCITYUNIT
+	,MASSDENSITYUNIT
+	,MASSFLOWRATEUNIT
+	,MOISTUREDIFFUSIVITYUNIT
+	,MOLECULARWEIGHTUNIT
+	,SPECIFICHEATCAPACITYUNIT
+	,THERMALADMITTANCEUNIT
+	,THERMALCONDUCTANCEUNIT
+	,THERMALRESISTANCEUNIT
+	,THERMALTRANSMITTANCEUNIT
+	,VAPORPERMEABILITYUNIT
+	,VOLUMETRICFLOWRATEUNIT
+	,ROTATIONALFREQUENCYUNIT
+	,TORQUEUNIT
+	,MOMENTOFINERTIAUNIT
+	,LINEARMOMENTUNIT
+	,LINEARFORCEUNIT
+	,PLANARFORCEUNIT
+	,MODULUSOFELASTICITYUNIT
+	,SHEARMODULUSUNIT
+	,LINEARSTIFFNESSUNIT
+	,ROTATIONALSTIFFNESSUNIT
+	,MODULUSOFSUBGRADEREACTIONUNIT
+	,ACCELERATIONUNIT
+	,CURVATUREUNIT
+	,HEATINGVALUEUNIT
+	,IONCONCENTRATIONUNIT
+	,LUMINOUSINTENSITYDISTRIBUTIONUNIT
+	,MASSPERLENGTHUNIT
+	,MODULUSOFLINEARSUBGRADEREACTIONUNIT
+	,MODULUSOFROTATIONALSUBGRADEREACTIONUNIT
+	,PHUNIT
+	,ROTATIONALMASSUNIT
+	,SECTIONAREAINTEGRALUNIT
+	,SECTIONMODULUSUNIT
+	,SOUNDPOWERLEVELUNIT
+	,SOUNDPOWERUNIT
+	,SOUNDPRESSURELEVELUNIT
+	,SOUNDPRESSUREUNIT
+	,TEMPERATUREGRADIENTUNIT
+	,TEMPERATURERATEOFCHANGEUNIT
+	,THERMALEXPANSIONCOEFFICIENTUNIT
+	,WARPINGCONSTANTUNIT
+	,WARPINGMOMENTUNIT
+	,USERDEFINED);
+END_TYPE;
+
+TYPE IfcDirectionSenseEnum = ENUMERATION OF
+	(POSITIVE
+	,NEGATIVE);
+END_TYPE;
+
+TYPE IfcDiscreteAccessoryTypeEnum = ENUMERATION OF
+	(ANCHORPLATE
+	,BRACKET
+	,SHOE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDistributionChamberElementTypeEnum = ENUMERATION OF
+	(FORMEDDUCT
+	,INSPECTIONCHAMBER
+	,INSPECTIONPIT
+	,MANHOLE
+	,METERCHAMBER
+	,SUMP
+	,TRENCH
+	,VALVECHAMBER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDistributionPortTypeEnum = ENUMERATION OF
+	(CABLE
+	,CABLECARRIER
+	,DUCT
+	,PIPE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDistributionSystemEnum = ENUMERATION OF
+	(AIRCONDITIONING
+	,AUDIOVISUAL
+	,CHEMICAL
+	,CHILLEDWATER
+	,COMMUNICATION
+	,COMPRESSEDAIR
+	,CONDENSERWATER
+	,CONTROL
+	,CONVEYING
+	,DATA
+	,DISPOSAL
+	,DOMESTICCOLDWATER
+	,DOMESTICHOTWATER
+	,DRAINAGE
+	,EARTHING
+	,ELECTRICAL
+	,ELECTROACOUSTIC
+	,EXHAUST
+	,FIREPROTECTION
+	,FUEL
+	,GAS
+	,HAZARDOUS
+	,HEATING
+	,LIGHTING
+	,LIGHTNINGPROTECTION
+	,MUNICIPALSOLIDWASTE
+	,OIL
+	,OPERATIONAL
+	,POWERGENERATION
+	,RAINWATER
+	,REFRIGERATION
+	,SECURITY
+	,SEWAGE
+	,SIGNAL
+	,STORMWATER
+	,TELEPHONE
+	,TV
+	,VACUUM
+	,VENT
+	,VENTILATION
+	,WASTEWATER
+	,WATERSUPPLY
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDocumentConfidentialityEnum = ENUMERATION OF
+	(PUBLIC
+	,RESTRICTED
+	,CONFIDENTIAL
+	,PERSONAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDocumentStatusEnum = ENUMERATION OF
+	(DRAFT
+	,FINALDRAFT
+	,FINAL
+	,REVISION
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDoorPanelOperationEnum = ENUMERATION OF
+	(SWINGING
+	,DOUBLE_ACTING
+	,SLIDING
+	,FOLDING
+	,REVOLVING
+	,ROLLINGUP
+	,FIXEDPANEL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDoorPanelPositionEnum = ENUMERATION OF
+	(LEFT
+	,MIDDLE
+	,RIGHT
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDoorStyleConstructionEnum = ENUMERATION OF
+	(ALUMINIUM
+	,HIGH_GRADE_STEEL
+	,STEEL
+	,WOOD
+	,ALUMINIUM_WOOD
+	,ALUMINIUM_PLASTIC
+	,PLASTIC
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDoorStyleOperationEnum = ENUMERATION OF
+	(SINGLE_SWING_LEFT
+	,SINGLE_SWING_RIGHT
+	,DOUBLE_DOOR_SINGLE_SWING
+	,DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT
+	,DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT
+	,DOUBLE_SWING_LEFT
+	,DOUBLE_SWING_RIGHT
+	,DOUBLE_DOOR_DOUBLE_SWING
+	,SLIDING_TO_LEFT
+	,SLIDING_TO_RIGHT
+	,DOUBLE_DOOR_SLIDING
+	,FOLDING_TO_LEFT
+	,FOLDING_TO_RIGHT
+	,DOUBLE_DOOR_FOLDING
+	,REVOLVING
+	,ROLLINGUP
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDoorTypeEnum = ENUMERATION OF
+	(DOOR
+	,GATE
+	,TRAPDOOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDoorTypeOperationEnum = ENUMERATION OF
+	(SINGLE_SWING_LEFT
+	,SINGLE_SWING_RIGHT
+	,DOUBLE_DOOR_SINGLE_SWING
+	,DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT
+	,DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT
+	,DOUBLE_SWING_LEFT
+	,DOUBLE_SWING_RIGHT
+	,DOUBLE_DOOR_DOUBLE_SWING
+	,SLIDING_TO_LEFT
+	,SLIDING_TO_RIGHT
+	,DOUBLE_DOOR_SLIDING
+	,FOLDING_TO_LEFT
+	,FOLDING_TO_RIGHT
+	,DOUBLE_DOOR_FOLDING
+	,REVOLVING
+	,ROLLINGUP
+	,SWING_FIXED_LEFT
+	,SWING_FIXED_RIGHT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDuctFittingTypeEnum = ENUMERATION OF
+	(BEND
+	,CONNECTOR
+	,ENTRY
+	,EXIT
+	,JUNCTION
+	,OBSTRUCTION
+	,TRANSITION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDuctSegmentTypeEnum = ENUMERATION OF
+	(RIGIDSEGMENT
+	,FLEXIBLESEGMENT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcDuctSilencerTypeEnum = ENUMERATION OF
+	(FLATOVAL
+	,RECTANGULAR
+	,ROUND
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElectricApplianceTypeEnum = ENUMERATION OF
+	(DISHWASHER
+	,ELECTRICCOOKER
+	,FREESTANDINGELECTRICHEATER
+	,FREESTANDINGFAN
+	,FREESTANDINGWATERHEATER
+	,FREESTANDINGWATERCOOLER
+	,FREEZER
+	,FRIDGE_FREEZER
+	,HANDDRYER
+	,KITCHENMACHINE
+	,MICROWAVE
+	,PHOTOCOPIER
+	,REFRIGERATOR
+	,TUMBLEDRYER
+	,VENDINGMACHINE
+	,WASHINGMACHINE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElectricDistributionBoardTypeEnum = ENUMERATION OF
+	(CONSUMERUNIT
+	,DISTRIBUTIONBOARD
+	,MOTORCONTROLCENTRE
+	,SWITCHBOARD
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElectricFlowStorageDeviceTypeEnum = ENUMERATION OF
+	(BATTERY
+	,CAPACITORBANK
+	,HARMONICFILTER
+	,INDUCTORBANK
+	,UPS
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElectricGeneratorTypeEnum = ENUMERATION OF
+	(CHP
+	,ENGINEGENERATOR
+	,STANDALONE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElectricMotorTypeEnum = ENUMERATION OF
+	(DC
+	,INDUCTION
+	,POLYPHASE
+	,RELUCTANCESYNCHRONOUS
+	,SYNCHRONOUS
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElectricTimeControlTypeEnum = ENUMERATION OF
+	(TIMECLOCK
+	,TIMEDELAY
+	,RELAY
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElementAssemblyTypeEnum = ENUMERATION OF
+	(ACCESSORY_ASSEMBLY
+	,ARCH
+	,BEAM_GRID
+	,BRACED_FRAME
+	,GIRDER
+	,REINFORCEMENT_UNIT
+	,RIGID_FRAME
+	,SLAB_FIELD
+	,TRUSS
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcElementCompositionEnum = ENUMERATION OF
+	(COMPLEX
+	,ELEMENT
+	,PARTIAL);
+END_TYPE;
+
+TYPE IfcEngineTypeEnum = ENUMERATION OF
+	(EXTERNALCOMBUSTION
+	,INTERNALCOMBUSTION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcEvaporativeCoolerTypeEnum = ENUMERATION OF
+	(DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER
+	,DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER
+	,DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER
+	,DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER
+	,DIRECTEVAPORATIVEAIRWASHER
+	,INDIRECTEVAPORATIVEPACKAGEAIRCOOLER
+	,INDIRECTEVAPORATIVEWETCOIL
+	,INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER
+	,INDIRECTDIRECTCOMBINATION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcEvaporatorTypeEnum = ENUMERATION OF
+	(DIRECTEXPANSION
+	,DIRECTEXPANSIONSHELLANDTUBE
+	,DIRECTEXPANSIONTUBEINTUBE
+	,DIRECTEXPANSIONBRAZEDPLATE
+	,FLOODEDSHELLANDTUBE
+	,SHELLANDCOIL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcEventTriggerTypeEnum = ENUMERATION OF
+	(EVENTRULE
+	,EVENTMESSAGE
+	,EVENTTIME
+	,EVENTCOMPLEX
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcEventTypeEnum = ENUMERATION OF
+	(STARTEVENT
+	,ENDEVENT
+	,INTERMEDIATEEVENT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcExternalSpatialElementTypeEnum = ENUMERATION OF
+	(EXTERNAL
+	,EXTERNAL_EARTH
+	,EXTERNAL_WATER
+	,EXTERNAL_FIRE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFanTypeEnum = ENUMERATION OF
+	(CENTRIFUGALFORWARDCURVED
+	,CENTRIFUGALRADIAL
+	,CENTRIFUGALBACKWARDINCLINEDCURVED
+	,CENTRIFUGALAIRFOIL
+	,TUBEAXIAL
+	,VANEAXIAL
+	,PROPELLORAXIAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFastenerTypeEnum = ENUMERATION OF
+	(GLUE
+	,MORTAR
+	,WELD
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFilterTypeEnum = ENUMERATION OF
+	(AIRPARTICLEFILTER
+	,COMPRESSEDAIRFILTER
+	,ODORFILTER
+	,OILFILTER
+	,STRAINER
+	,WATERFILTER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFireSuppressionTerminalTypeEnum = ENUMERATION OF
+	(BREECHINGINLET
+	,FIREHYDRANT
+	,HOSEREEL
+	,SPRINKLER
+	,SPRINKLERDEFLECTOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFlowDirectionEnum = ENUMERATION OF
+	(SOURCE
+	,SINK
+	,SOURCEANDSINK
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFlowInstrumentTypeEnum = ENUMERATION OF
+	(PRESSUREGAUGE
+	,THERMOMETER
+	,AMMETER
+	,FREQUENCYMETER
+	,POWERFACTORMETER
+	,PHASEANGLEMETER
+	,VOLTMETER_PEAK
+	,VOLTMETER_RMS
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFlowMeterTypeEnum = ENUMERATION OF
+	(ENERGYMETER
+	,GASMETER
+	,OILMETER
+	,WATERMETER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFootingTypeEnum = ENUMERATION OF
+	(CAISSON_FOUNDATION
+	,FOOTING_BEAM
+	,PAD_FOOTING
+	,PILE_CAP
+	,STRIP_FOOTING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcFurnitureTypeEnum = ENUMERATION OF
+	(CHAIR
+	,TABLE
+	,DESK
+	,BED
+	,FILECABINET
+	,SHELF
+	,SOFA
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcGeographicElementTypeEnum = ENUMERATION OF
+	(TERRAIN
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcGeometricProjectionEnum = ENUMERATION OF
+	(GRAPH_VIEW
+	,SKETCH_VIEW
+	,MODEL_VIEW
+	,PLAN_VIEW
+	,REFLECTED_PLAN_VIEW
+	,SECTION_VIEW
+	,ELEVATION_VIEW
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcGlobalOrLocalEnum = ENUMERATION OF
+	(GLOBAL_COORDS
+	,LOCAL_COORDS);
+END_TYPE;
+
+TYPE IfcGridTypeEnum = ENUMERATION OF
+	(RECTANGULAR
+	,RADIAL
+	,TRIANGULAR
+	,IRREGULAR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcHeatExchangerTypeEnum = ENUMERATION OF
+	(PLATE
+	,SHELLANDTUBE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcHumidifierTypeEnum = ENUMERATION OF
+	(STEAMINJECTION
+	,ADIABATICAIRWASHER
+	,ADIABATICPAN
+	,ADIABATICWETTEDELEMENT
+	,ADIABATICATOMIZING
+	,ADIABATICULTRASONIC
+	,ADIABATICRIGIDMEDIA
+	,ADIABATICCOMPRESSEDAIRNOZZLE
+	,ASSISTEDELECTRIC
+	,ASSISTEDNATURALGAS
+	,ASSISTEDPROPANE
+	,ASSISTEDBUTANE
+	,ASSISTEDSTEAM
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcInterceptorTypeEnum = ENUMERATION OF
+	(CYCLONIC
+	,GREASE
+	,OIL
+	,PETROL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcInternalOrExternalEnum = ENUMERATION OF
+	(INTERNAL
+	,EXTERNAL
+	,EXTERNAL_EARTH
+	,EXTERNAL_WATER
+	,EXTERNAL_FIRE
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcInventoryTypeEnum = ENUMERATION OF
+	(ASSETINVENTORY
+	,SPACEINVENTORY
+	,FURNITUREINVENTORY
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcJunctionBoxTypeEnum = ENUMERATION OF
+	(DATA
+	,POWER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcKnotType = ENUMERATION OF
+	(UNIFORM_KNOTS
+	,QUASI_UNIFORM_KNOTS
+	,PIECEWISE_BEZIER_KNOTS
+	,UNSPECIFIED);
+END_TYPE;
+
+TYPE IfcLaborResourceTypeEnum = ENUMERATION OF
+	(ADMINISTRATION
+	,CARPENTRY
+	,CLEANING
+	,CONCRETE
+	,DRYWALL
+	,ELECTRIC
+	,FINISHING
+	,FLOORING
+	,GENERAL
+	,HVAC
+	,LANDSCAPING
+	,MASONRY
+	,PAINTING
+	,PAVING
+	,PLUMBING
+	,ROOFING
+	,SITEGRADING
+	,STEELWORK
+	,SURVEYING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcLampTypeEnum = ENUMERATION OF
+	(COMPACTFLUORESCENT
+	,FLUORESCENT
+	,HALOGEN
+	,HIGHPRESSUREMERCURY
+	,HIGHPRESSURESODIUM
+	,LED
+	,METALHALIDE
+	,OLED
+	,TUNGSTENFILAMENT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcLayerSetDirectionEnum = ENUMERATION OF
+	(AXIS1
+	,AXIS2
+	,AXIS3);
+END_TYPE;
+
+TYPE IfcLightDistributionCurveEnum = ENUMERATION OF
+	(TYPE_A
+	,TYPE_B
+	,TYPE_C
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcLightEmissionSourceEnum = ENUMERATION OF
+	(COMPACTFLUORESCENT
+	,FLUORESCENT
+	,HIGHPRESSUREMERCURY
+	,HIGHPRESSURESODIUM
+	,LIGHTEMITTINGDIODE
+	,LOWPRESSURESODIUM
+	,LOWVOLTAGEHALOGEN
+	,MAINVOLTAGEHALOGEN
+	,METALHALIDE
+	,TUNGSTENFILAMENT
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcLightFixtureTypeEnum = ENUMERATION OF
+	(POINTSOURCE
+	,DIRECTIONSOURCE
+	,SECURITYLIGHTING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcLoadGroupTypeEnum = ENUMERATION OF
+	(LOAD_GROUP
+	,LOAD_CASE
+	,LOAD_COMBINATION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcLogicalOperatorEnum = ENUMERATION OF
+	(LOGICALAND
+	,LOGICALOR
+	,LOGICALXOR
+	,LOGICALNOTAND
+	,LOGICALNOTOR);
+END_TYPE;
+
+TYPE IfcMechanicalFastenerTypeEnum = ENUMERATION OF
+	(ANCHORBOLT
+	,BOLT
+	,DOWEL
+	,NAIL
+	,NAILPLATE
+	,RIVET
+	,SCREW
+	,SHEARCONNECTOR
+	,STAPLE
+	,STUDSHEARCONNECTOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcMedicalDeviceTypeEnum = ENUMERATION OF
+	(AIRSTATION
+	,FEEDAIRUNIT
+	,OXYGENGENERATOR
+	,OXYGENPLANT
+	,VACUUMSTATION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcMemberTypeEnum = ENUMERATION OF
+	(BRACE
+	,CHORD
+	,COLLAR
+	,MEMBER
+	,MULLION
+	,PLATE
+	,POST
+	,PURLIN
+	,RAFTER
+	,STRINGER
+	,STRUT
+	,STUD
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcMotorConnectionTypeEnum = ENUMERATION OF
+	(BELTDRIVE
+	,COUPLING
+	,DIRECTDRIVE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcNullStyle = ENUMERATION OF
+	(NULL);
+END_TYPE;
+
+TYPE IfcObjectTypeEnum = ENUMERATION OF
+	(PRODUCT
+	,PROCESS
+	,CONTROL
+	,RESOURCE
+	,ACTOR
+	,GROUP
+	,PROJECT
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcObjectiveEnum = ENUMERATION OF
+	(CODECOMPLIANCE
+	,CODEWAIVER
+	,DESIGNINTENT
+	,EXTERNAL
+	,HEALTHANDSAFETY
+	,MERGECONFLICT
+	,MODELVIEW
+	,PARAMETER
+	,REQUIREMENT
+	,SPECIFICATION
+	,TRIGGERCONDITION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcOccupantTypeEnum = ENUMERATION OF
+	(ASSIGNEE
+	,ASSIGNOR
+	,LESSEE
+	,LESSOR
+	,LETTINGAGENT
+	,OWNER
+	,TENANT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcOpeningElementTypeEnum = ENUMERATION OF
+	(OPENING
+	,RECESS
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcOutletTypeEnum = ENUMERATION OF
+	(AUDIOVISUALOUTLET
+	,COMMUNICATIONSOUTLET
+	,POWEROUTLET
+	,DATAOUTLET
+	,TELEPHONEOUTLET
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPerformanceHistoryTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPermeableCoveringOperationEnum = ENUMERATION OF
+	(GRILL
+	,LOUVER
+	,SCREEN
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPermitTypeEnum = ENUMERATION OF
+	(ACCESS
+	,BUILDING
+	,WORK
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPhysicalOrVirtualEnum = ENUMERATION OF
+	(PHYSICAL
+	,VIRTUAL
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPileConstructionEnum = ENUMERATION OF
+	(CAST_IN_PLACE
+	,COMPOSITE
+	,PRECAST_CONCRETE
+	,PREFAB_STEEL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPileTypeEnum = ENUMERATION OF
+	(BORED
+	,DRIVEN
+	,JETGROUTING
+	,COHESION
+	,FRICTION
+	,SUPPORT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPipeFittingTypeEnum = ENUMERATION OF
+	(BEND
+	,CONNECTOR
+	,ENTRY
+	,EXIT
+	,JUNCTION
+	,OBSTRUCTION
+	,TRANSITION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPipeSegmentTypeEnum = ENUMERATION OF
+	(CULVERT
+	,FLEXIBLESEGMENT
+	,RIGIDSEGMENT
+	,GUTTER
+	,SPOOL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPlateTypeEnum = ENUMERATION OF
+	(CURTAIN_PANEL
+	,SHEET
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPreferredSurfaceCurveRepresentation = ENUMERATION OF
+	(CURVE3D
+	,PCURVE_S1
+	,PCURVE_S2);
+END_TYPE;
+
+TYPE IfcProcedureTypeEnum = ENUMERATION OF
+	(ADVICE_CAUTION
+	,ADVICE_NOTE
+	,ADVICE_WARNING
+	,CALIBRATION
+	,DIAGNOSTIC
+	,SHUTDOWN
+	,STARTUP
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcProfileTypeEnum = ENUMERATION OF
+	(CURVE
+	,AREA);
+END_TYPE;
+
+TYPE IfcProjectOrderTypeEnum = ENUMERATION OF
+	(CHANGEORDER
+	,MAINTENANCEWORKORDER
+	,MOVEORDER
+	,PURCHASEORDER
+	,WORKORDER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcProjectedOrTrueLengthEnum = ENUMERATION OF
+	(PROJECTED_LENGTH
+	,TRUE_LENGTH);
+END_TYPE;
+
+TYPE IfcProjectionElementTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPropertySetTemplateTypeEnum = ENUMERATION OF
+	(PSET_TYPEDRIVENONLY
+	,PSET_TYPEDRIVENOVERRIDE
+	,PSET_OCCURRENCEDRIVEN
+	,PSET_PERFORMANCEDRIVEN
+	,QTO_TYPEDRIVENONLY
+	,QTO_TYPEDRIVENOVERRIDE
+	,QTO_OCCURRENCEDRIVEN
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcProtectiveDeviceTrippingUnitTypeEnum = ENUMERATION OF
+	(ELECTRONIC
+	,ELECTROMAGNETIC
+	,RESIDUALCURRENT
+	,THERMAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcProtectiveDeviceTypeEnum = ENUMERATION OF
+	(CIRCUITBREAKER
+	,EARTHLEAKAGECIRCUITBREAKER
+	,EARTHINGSWITCH
+	,FUSEDISCONNECTOR
+	,RESIDUALCURRENTCIRCUITBREAKER
+	,RESIDUALCURRENTSWITCH
+	,VARISTOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcPumpTypeEnum = ENUMERATION OF
+	(CIRCULATOR
+	,ENDSUCTION
+	,SPLITCASE
+	,SUBMERSIBLEPUMP
+	,SUMPPUMP
+	,VERTICALINLINE
+	,VERTICALTURBINE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcRailingTypeEnum = ENUMERATION OF
+	(HANDRAIL
+	,GUARDRAIL
+	,BALUSTRADE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcRampFlightTypeEnum = ENUMERATION OF
+	(STRAIGHT
+	,SPIRAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcRampTypeEnum = ENUMERATION OF
+	(STRAIGHT_RUN_RAMP
+	,TWO_STRAIGHT_RUN_RAMP
+	,QUARTER_TURN_RAMP
+	,TWO_QUARTER_TURN_RAMP
+	,HALF_TURN_RAMP
+	,SPIRAL_RAMP
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcRecurrenceTypeEnum = ENUMERATION OF
+	(DAILY
+	,WEEKLY
+	,MONTHLY_BY_DAY_OF_MONTH
+	,MONTHLY_BY_POSITION
+	,BY_DAY_COUNT
+	,BY_WEEKDAY_COUNT
+	,YEARLY_BY_DAY_OF_MONTH
+	,YEARLY_BY_POSITION);
+END_TYPE;
+
+TYPE IfcReflectanceMethodEnum = ENUMERATION OF
+	(BLINN
+	,FLAT
+	,GLASS
+	,MATT
+	,METAL
+	,MIRROR
+	,PHONG
+	,PLASTIC
+	,STRAUSS
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcReinforcingBarRoleEnum = ENUMERATION OF
+	(MAIN
+	,SHEAR
+	,LIGATURE
+	,STUD
+	,PUNCHING
+	,EDGE
+	,RING
+	,ANCHORING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcReinforcingBarSurfaceEnum = ENUMERATION OF
+	(PLAIN
+	,TEXTURED);
+END_TYPE;
+
+TYPE IfcReinforcingBarTypeEnum = ENUMERATION OF
+	(ANCHORING
+	,EDGE
+	,LIGATURE
+	,MAIN
+	,PUNCHING
+	,RING
+	,SHEAR
+	,STUD
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcReinforcingMeshTypeEnum = ENUMERATION OF
+	(USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcRoleEnum = ENUMERATION OF
+	(SUPPLIER
+	,MANUFACTURER
+	,CONTRACTOR
+	,SUBCONTRACTOR
+	,ARCHITECT
+	,STRUCTURALENGINEER
+	,COSTENGINEER
+	,CLIENT
+	,BUILDINGOWNER
+	,BUILDINGOPERATOR
+	,MECHANICALENGINEER
+	,ELECTRICALENGINEER
+	,PROJECTMANAGER
+	,FACILITIESMANAGER
+	,CIVILENGINEER
+	,COMMISSIONINGENGINEER
+	,ENGINEER
+	,OWNER
+	,CONSULTANT
+	,CONSTRUCTIONMANAGER
+	,FIELDCONSTRUCTIONMANAGER
+	,RESELLER
+	,USERDEFINED);
+END_TYPE;
+
+TYPE IfcRoofTypeEnum = ENUMERATION OF
+	(FLAT_ROOF
+	,SHED_ROOF
+	,GABLE_ROOF
+	,HIP_ROOF
+	,HIPPED_GABLE_ROOF
+	,GAMBREL_ROOF
+	,MANSARD_ROOF
+	,BARREL_ROOF
+	,RAINBOW_ROOF
+	,BUTTERFLY_ROOF
+	,PAVILION_ROOF
+	,DOME_ROOF
+	,FREEFORM
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSIPrefix = ENUMERATION OF
+	(EXA
+	,PETA
+	,TERA
+	,GIGA
+	,MEGA
+	,KILO
+	,HECTO
+	,DECA
+	,DECI
+	,CENTI
+	,MILLI
+	,MICRO
+	,NANO
+	,PICO
+	,FEMTO
+	,ATTO);
+END_TYPE;
+
+TYPE IfcSIUnitName = ENUMERATION OF
+	(AMPERE
+	,BECQUEREL
+	,CANDELA
+	,COULOMB
+	,CUBIC_METRE
+	,DEGREE_CELSIUS
+	,FARAD
+	,GRAM
+	,GRAY
+	,HENRY
+	,HERTZ
+	,JOULE
+	,KELVIN
+	,LUMEN
+	,LUX
+	,METRE
+	,MOLE
+	,NEWTON
+	,OHM
+	,PASCAL
+	,RADIAN
+	,SECOND
+	,SIEMENS
+	,SIEVERT
+	,SQUARE_METRE
+	,STERADIAN
+	,TESLA
+	,VOLT
+	,WATT
+	,WEBER);
+END_TYPE;
+
+TYPE IfcSanitaryTerminalTypeEnum = ENUMERATION OF
+	(BATH
+	,BIDET
+	,CISTERN
+	,SHOWER
+	,SINK
+	,SANITARYFOUNTAIN
+	,TOILETPAN
+	,URINAL
+	,WASHHANDBASIN
+	,WCSEAT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSectionTypeEnum = ENUMERATION OF
+	(UNIFORM
+	,TAPERED);
+END_TYPE;
+
+TYPE IfcSensorTypeEnum = ENUMERATION OF
+	(COSENSOR
+	,CO2SENSOR
+	,CONDUCTANCESENSOR
+	,CONTACTSENSOR
+	,FIRESENSOR
+	,FLOWSENSOR
+	,FROSTSENSOR
+	,GASSENSOR
+	,HEATSENSOR
+	,HUMIDITYSENSOR
+	,IDENTIFIERSENSOR
+	,IONCONCENTRATIONSENSOR
+	,LEVELSENSOR
+	,LIGHTSENSOR
+	,MOISTURESENSOR
+	,MOVEMENTSENSOR
+	,PHSENSOR
+	,PRESSURESENSOR
+	,RADIATIONSENSOR
+	,RADIOACTIVITYSENSOR
+	,SMOKESENSOR
+	,SOUNDSENSOR
+	,TEMPERATURESENSOR
+	,WINDSENSOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSequenceEnum = ENUMERATION OF
+	(START_START
+	,START_FINISH
+	,FINISH_START
+	,FINISH_FINISH
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcShadingDeviceTypeEnum = ENUMERATION OF
+	(JALOUSIE
+	,SHUTTER
+	,AWNING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSimplePropertyTemplateTypeEnum = ENUMERATION OF
+	(P_SINGLEVALUE
+	,P_ENUMERATEDVALUE
+	,P_BOUNDEDVALUE
+	,P_LISTVALUE
+	,P_TABLEVALUE
+	,P_REFERENCEVALUE
+	,Q_LENGTH
+	,Q_AREA
+	,Q_VOLUME
+	,Q_COUNT
+	,Q_WEIGHT
+	,Q_TIME);
+END_TYPE;
+
+TYPE IfcSlabTypeEnum = ENUMERATION OF
+	(FLOOR
+	,ROOF
+	,LANDING
+	,BASESLAB
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSolarDeviceTypeEnum = ENUMERATION OF
+	(SOLARCOLLECTOR
+	,SOLARPANEL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSpaceHeaterTypeEnum = ENUMERATION OF
+	(CONVECTOR
+	,RADIATOR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSpaceTypeEnum = ENUMERATION OF
+	(SPACE
+	,PARKING
+	,GFA
+	,INTERNAL
+	,EXTERNAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSpatialZoneTypeEnum = ENUMERATION OF
+	(CONSTRUCTION
+	,FIRESAFETY
+	,LIGHTING
+	,OCCUPANCY
+	,SECURITY
+	,THERMAL
+	,TRANSPORT
+	,VENTILATION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStackTerminalTypeEnum = ENUMERATION OF
+	(BIRDCAGE
+	,COWL
+	,RAINWATERHOPPER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStairFlightTypeEnum = ENUMERATION OF
+	(STRAIGHT
+	,WINDER
+	,SPIRAL
+	,CURVED
+	,FREEFORM
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStairTypeEnum = ENUMERATION OF
+	(STRAIGHT_RUN_STAIR
+	,TWO_STRAIGHT_RUN_STAIR
+	,QUARTER_WINDING_STAIR
+	,QUARTER_TURN_STAIR
+	,HALF_WINDING_STAIR
+	,HALF_TURN_STAIR
+	,TWO_QUARTER_WINDING_STAIR
+	,TWO_QUARTER_TURN_STAIR
+	,THREE_QUARTER_WINDING_STAIR
+	,THREE_QUARTER_TURN_STAIR
+	,SPIRAL_STAIR
+	,DOUBLE_RETURN_STAIR
+	,CURVED_RUN_STAIR
+	,TWO_CURVED_RUN_STAIR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStateEnum = ENUMERATION OF
+	(READWRITE
+	,READONLY
+	,LOCKED
+	,READWRITELOCKED
+	,READONLYLOCKED);
+END_TYPE;
+
+TYPE IfcStructuralCurveActivityTypeEnum = ENUMERATION OF
+	(CONST
+	,LINEAR
+	,POLYGONAL
+	,EQUIDISTANT
+	,SINUS
+	,PARABOLA
+	,DISCRETE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStructuralCurveMemberTypeEnum = ENUMERATION OF
+	(RIGID_JOINED_MEMBER
+	,PIN_JOINED_MEMBER
+	,CABLE
+	,TENSION_MEMBER
+	,COMPRESSION_MEMBER
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStructuralSurfaceActivityTypeEnum = ENUMERATION OF
+	(CONST
+	,BILINEAR
+	,DISCRETE
+	,ISOCONTOUR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcStructuralSurfaceMemberTypeEnum = ENUMERATION OF
+	(BENDING_ELEMENT
+	,MEMBRANE_ELEMENT
+	,SHELL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSubContractResourceTypeEnum = ENUMERATION OF
+	(PURCHASE
+	,WORK
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSurfaceFeatureTypeEnum = ENUMERATION OF
+	(MARK
+	,TAG
+	,TREATMENT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSurfaceSide = ENUMERATION OF
+	(POSITIVE
+	,NEGATIVE
+	,BOTH);
+END_TYPE;
+
+TYPE IfcSwitchingDeviceTypeEnum = ENUMERATION OF
+	(CONTACTOR
+	,DIMMERSWITCH
+	,EMERGENCYSTOP
+	,KEYPAD
+	,MOMENTARYSWITCH
+	,SELECTORSWITCH
+	,STARTER
+	,SWITCHDISCONNECTOR
+	,TOGGLESWITCH
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcSystemFurnitureElementTypeEnum = ENUMERATION OF
+	(PANEL
+	,WORKSURFACE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTankTypeEnum = ENUMERATION OF
+	(BASIN
+	,BREAKPRESSURE
+	,EXPANSION
+	,FEEDANDEXPANSION
+	,PRESSUREVESSEL
+	,STORAGE
+	,VESSEL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTaskDurationEnum = ENUMERATION OF
+	(ELAPSEDTIME
+	,WORKTIME
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTaskTypeEnum = ENUMERATION OF
+	(ATTENDANCE
+	,CONSTRUCTION
+	,DEMOLITION
+	,DISMANTLE
+	,DISPOSAL
+	,INSTALLATION
+	,LOGISTIC
+	,MAINTENANCE
+	,MOVE
+	,OPERATION
+	,REMOVAL
+	,RENOVATION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTendonAnchorTypeEnum = ENUMERATION OF
+	(COUPLER
+	,FIXED_END
+	,TENSIONING_END
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTendonTypeEnum = ENUMERATION OF
+	(BAR
+	,COATED
+	,STRAND
+	,WIRE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTextPath = ENUMERATION OF
+	(LEFT
+	,RIGHT
+	,UP
+	,DOWN);
+END_TYPE;
+
+TYPE IfcTimeSeriesDataTypeEnum = ENUMERATION OF
+	(CONTINUOUS
+	,DISCRETE
+	,DISCRETEBINARY
+	,PIECEWISEBINARY
+	,PIECEWISECONSTANT
+	,PIECEWISECONTINUOUS
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTransformerTypeEnum = ENUMERATION OF
+	(CURRENT
+	,FREQUENCY
+	,INVERTER
+	,RECTIFIER
+	,VOLTAGE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTransitionCode = ENUMERATION OF
+	(DISCONTINUOUS
+	,CONTINUOUS
+	,CONTSAMEGRADIENT
+	,CONTSAMEGRADIENTSAMECURVATURE);
+END_TYPE;
+
+TYPE IfcTransportElementTypeEnum = ENUMERATION OF
+	(ELEVATOR
+	,ESCALATOR
+	,MOVINGWALKWAY
+	,CRANEWAY
+	,LIFTINGGEAR
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcTrimmingPreference = ENUMERATION OF
+	(CARTESIAN
+	,PARAMETER
+	,UNSPECIFIED);
+END_TYPE;
+
+TYPE IfcTubeBundleTypeEnum = ENUMERATION OF
+	(FINNED
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcUnitEnum = ENUMERATION OF
+	(ABSORBEDDOSEUNIT
+	,AMOUNTOFSUBSTANCEUNIT
+	,AREAUNIT
+	,DOSEEQUIVALENTUNIT
+	,ELECTRICCAPACITANCEUNIT
+	,ELECTRICCHARGEUNIT
+	,ELECTRICCONDUCTANCEUNIT
+	,ELECTRICCURRENTUNIT
+	,ELECTRICRESISTANCEUNIT
+	,ELECTRICVOLTAGEUNIT
+	,ENERGYUNIT
+	,FORCEUNIT
+	,FREQUENCYUNIT
+	,ILLUMINANCEUNIT
+	,INDUCTANCEUNIT
+	,LENGTHUNIT
+	,LUMINOUSFLUXUNIT
+	,LUMINOUSINTENSITYUNIT
+	,MAGNETICFLUXDENSITYUNIT
+	,MAGNETICFLUXUNIT
+	,MASSUNIT
+	,PLANEANGLEUNIT
+	,POWERUNIT
+	,PRESSUREUNIT
+	,RADIOACTIVITYUNIT
+	,SOLIDANGLEUNIT
+	,THERMODYNAMICTEMPERATUREUNIT
+	,TIMEUNIT
+	,VOLUMEUNIT
+	,USERDEFINED);
+END_TYPE;
+
+TYPE IfcUnitaryControlElementTypeEnum = ENUMERATION OF
+	(ALARMPANEL
+	,CONTROLPANEL
+	,GASDETECTIONPANEL
+	,INDICATORPANEL
+	,MIMICPANEL
+	,HUMIDISTAT
+	,THERMOSTAT
+	,WEATHERSTATION
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcUnitaryEquipmentTypeEnum = ENUMERATION OF
+	(AIRHANDLER
+	,AIRCONDITIONINGUNIT
+	,DEHUMIDIFIER
+	,SPLITSYSTEM
+	,ROOFTOPUNIT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcValveTypeEnum = ENUMERATION OF
+	(AIRRELEASE
+	,ANTIVACUUM
+	,CHANGEOVER
+	,CHECK
+	,COMMISSIONING
+	,DIVERTING
+	,DRAWOFFCOCK
+	,DOUBLECHECK
+	,DOUBLEREGULATING
+	,FAUCET
+	,FLUSHING
+	,GASCOCK
+	,GASTAP
+	,ISOLATING
+	,MIXING
+	,PRESSUREREDUCING
+	,PRESSURERELIEF
+	,REGULATING
+	,SAFETYCUTOFF
+	,STEAMTRAP
+	,STOPCOCK
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcVibrationIsolatorTypeEnum = ENUMERATION OF
+	(COMPRESSION
+	,SPRING
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcVoidingFeatureTypeEnum = ENUMERATION OF
+	(CUTOUT
+	,NOTCH
+	,HOLE
+	,MITER
+	,CHAMFER
+	,EDGE
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWallTypeEnum = ENUMERATION OF
+	(MOVABLE
+	,PARAPET
+	,PARTITIONING
+	,PLUMBINGWALL
+	,SHEAR
+	,SOLIDWALL
+	,STANDARD
+	,POLYGONAL
+	,ELEMENTEDWALL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWasteTerminalTypeEnum = ENUMERATION OF
+	(FLOORTRAP
+	,FLOORWASTE
+	,GULLYSUMP
+	,GULLYTRAP
+	,ROOFDRAIN
+	,WASTEDISPOSALUNIT
+	,WASTETRAP
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWindowPanelOperationEnum = ENUMERATION OF
+	(SIDEHUNGRIGHTHAND
+	,SIDEHUNGLEFTHAND
+	,TILTANDTURNRIGHTHAND
+	,TILTANDTURNLEFTHAND
+	,TOPHUNG
+	,BOTTOMHUNG
+	,PIVOTHORIZONTAL
+	,PIVOTVERTICAL
+	,SLIDINGHORIZONTAL
+	,SLIDINGVERTICAL
+	,REMOVABLECASEMENT
+	,FIXEDCASEMENT
+	,OTHEROPERATION
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWindowPanelPositionEnum = ENUMERATION OF
+	(LEFT
+	,MIDDLE
+	,RIGHT
+	,BOTTOM
+	,TOP
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWindowStyleConstructionEnum = ENUMERATION OF
+	(ALUMINIUM
+	,HIGH_GRADE_STEEL
+	,STEEL
+	,WOOD
+	,ALUMINIUM_WOOD
+	,PLASTIC
+	,OTHER_CONSTRUCTION
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWindowStyleOperationEnum = ENUMERATION OF
+	(SINGLE_PANEL
+	,DOUBLE_PANEL_VERTICAL
+	,DOUBLE_PANEL_HORIZONTAL
+	,TRIPLE_PANEL_VERTICAL
+	,TRIPLE_PANEL_BOTTOM
+	,TRIPLE_PANEL_TOP
+	,TRIPLE_PANEL_LEFT
+	,TRIPLE_PANEL_RIGHT
+	,TRIPLE_PANEL_HORIZONTAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWindowTypeEnum = ENUMERATION OF
+	(WINDOW
+	,SKYLIGHT
+	,LIGHTDOME
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWindowTypePartitioningEnum = ENUMERATION OF
+	(SINGLE_PANEL
+	,DOUBLE_PANEL_VERTICAL
+	,DOUBLE_PANEL_HORIZONTAL
+	,TRIPLE_PANEL_VERTICAL
+	,TRIPLE_PANEL_BOTTOM
+	,TRIPLE_PANEL_TOP
+	,TRIPLE_PANEL_LEFT
+	,TRIPLE_PANEL_RIGHT
+	,TRIPLE_PANEL_HORIZONTAL
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWorkCalendarTypeEnum = ENUMERATION OF
+	(FIRSTSHIFT
+	,SECONDSHIFT
+	,THIRDSHIFT
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWorkPlanTypeEnum = ENUMERATION OF
+	(ACTUAL
+	,BASELINE
+	,PLANNED
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcWorkScheduleTypeEnum = ENUMERATION OF
+	(ACTUAL
+	,BASELINE
+	,PLANNED
+	,USERDEFINED
+	,NOTDEFINED);
+END_TYPE;
+
+TYPE IfcActorSelect = SELECT
+	(IfcOrganization
+	,IfcPerson
+	,IfcPersonAndOrganization);
+END_TYPE;
+
+TYPE IfcAppliedValueSelect = SELECT
+	(IfcMeasureWithUnit
+	,IfcReference
+	,IfcValue);
+END_TYPE;
+
+TYPE IfcAxis2Placement = SELECT
+	(IfcAxis2Placement2D
+	,IfcAxis2Placement3D);
+END_TYPE;
+
+TYPE IfcBendingParameterSelect = SELECT
+	(IfcLengthMeasure
+	,IfcPlaneAngleMeasure);
+END_TYPE;
+
+TYPE IfcBooleanOperand = SELECT
+	(IfcBooleanResult
+	,IfcCsgPrimitive3D
+	,IfcHalfSpaceSolid
+	,IfcSolidModel
+	,IfcTessellatedFaceSet);
+END_TYPE;
+
+TYPE IfcClassificationReferenceSelect = SELECT
+	(IfcClassification
+	,IfcClassificationReference);
+END_TYPE;
+
+TYPE IfcClassificationSelect = SELECT
+	(IfcClassification
+	,IfcClassificationReference);
+END_TYPE;
+
+TYPE IfcColour = SELECT
+	(IfcColourSpecification
+	,IfcPreDefinedColour);
+END_TYPE;
+
+TYPE IfcColourOrFactor = SELECT
+	(IfcColourRgb
+	,IfcNormalisedRatioMeasure);
+END_TYPE;
+
+TYPE IfcCoordinateReferenceSystemSelect = SELECT
+	(IfcCoordinateReferenceSystem
+	,IfcGeometricRepresentationContext);
+END_TYPE;
+
+TYPE IfcCsgSelect = SELECT
+	(IfcBooleanResult
+	,IfcCsgPrimitive3D);
+END_TYPE;
+
+TYPE IfcCurveFontOrScaledCurveFontSelect = SELECT
+	(IfcCurveStyleFontAndScaling
+	,IfcCurveStyleFontSelect);
+END_TYPE;
+
+TYPE IfcCurveOnSurface = SELECT
+	(IfcCompositeCurveOnSurface
+	,IfcPcurve
+	,IfcSurfaceCurve);
+END_TYPE;
+
+TYPE IfcCurveOrEdgeCurve = SELECT
+	(IfcBoundedCurve
+	,IfcEdgeCurve);
+END_TYPE;
+
+TYPE IfcCurveStyleFontSelect = SELECT
+	(IfcCurveStyleFont
+	,IfcPreDefinedCurveFont);
+END_TYPE;
+
+TYPE IfcDefinitionSelect = SELECT
+	(IfcObjectDefinition
+	,IfcPropertyDefinition);
+END_TYPE;
+
+TYPE IfcDerivedMeasureValue = SELECT
+	(IfcAbsorbedDoseMeasure
+	,IfcAccelerationMeasure
+	,IfcAngularVelocityMeasure
+	,IfcAreaDensityMeasure
+	,IfcCompoundPlaneAngleMeasure
+	,IfcCurvatureMeasure
+	,IfcDoseEquivalentMeasure
+	,IfcDynamicViscosityMeasure
+	,IfcElectricCapacitanceMeasure
+	,IfcElectricChargeMeasure
+	,IfcElectricConductanceMeasure
+	,IfcElectricResistanceMeasure
+	,IfcElectricVoltageMeasure
+	,IfcEnergyMeasure
+	,IfcForceMeasure
+	,IfcFrequencyMeasure
+	,IfcHeatFluxDensityMeasure
+	,IfcHeatingValueMeasure
+	,IfcIlluminanceMeasure
+	,IfcInductanceMeasure
+	,IfcIntegerCountRateMeasure
+	,IfcIonConcentrationMeasure
+	,IfcIsothermalMoistureCapacityMeasure
+	,IfcKinematicViscosityMeasure
+	,IfcLinearForceMeasure
+	,IfcLinearMomentMeasure
+	,IfcLinearStiffnessMeasure
+	,IfcLinearVelocityMeasure
+	,IfcLuminousFluxMeasure
+	,IfcLuminousIntensityDistributionMeasure
+	,IfcMagneticFluxDensityMeasure
+	,IfcMagneticFluxMeasure
+	,IfcMassDensityMeasure
+	,IfcMassFlowRateMeasure
+	,IfcMassPerLengthMeasure
+	,IfcModulusOfElasticityMeasure
+	,IfcModulusOfLinearSubgradeReactionMeasure
+	,IfcModulusOfRotationalSubgradeReactionMeasure
+	,IfcModulusOfSubgradeReactionMeasure
+	,IfcMoistureDiffusivityMeasure
+	,IfcMolecularWeightMeasure
+	,IfcMomentOfInertiaMeasure
+	,IfcMonetaryMeasure
+	,IfcPHMeasure
+	,IfcPlanarForceMeasure
+	,IfcPowerMeasure
+	,IfcPressureMeasure
+	,IfcRadioActivityMeasure
+	,IfcRotationalFrequencyMeasure
+	,IfcRotationalMassMeasure
+	,IfcRotationalStiffnessMeasure
+	,IfcSectionModulusMeasure
+	,IfcSectionalAreaIntegralMeasure
+	,IfcShearModulusMeasure
+	,IfcSoundPowerLevelMeasure
+	,IfcSoundPowerMeasure
+	,IfcSoundPressureLevelMeasure
+	,IfcSoundPressureMeasure
+	,IfcSpecificHeatCapacityMeasure
+	,IfcTemperatureGradientMeasure
+	,IfcTemperatureRateOfChangeMeasure
+	,IfcThermalAdmittanceMeasure
+	,IfcThermalConductivityMeasure
+	,IfcThermalExpansionCoefficientMeasure
+	,IfcThermalResistanceMeasure
+	,IfcThermalTransmittanceMeasure
+	,IfcTorqueMeasure
+	,IfcVaporPermeabilityMeasure
+	,IfcVolumetricFlowRateMeasure
+	,IfcWarpingConstantMeasure
+	,IfcWarpingMomentMeasure);
+END_TYPE;
+
+TYPE IfcDocumentSelect = SELECT
+	(IfcDocumentInformation
+	,IfcDocumentReference);
+END_TYPE;
+
+TYPE IfcFillStyleSelect = SELECT
+	(IfcColour
+	,IfcExternallyDefinedHatchStyle
+	,IfcFillAreaStyleHatching
+	,IfcFillAreaStyleTiles);
+END_TYPE;
+
+TYPE IfcGeometricSetSelect = SELECT
+	(IfcCurve
+	,IfcPoint
+	,IfcSurface);
+END_TYPE;
+
+TYPE IfcGridPlacementDirectionSelect = SELECT
+	(IfcDirection
+	,IfcVirtualGridIntersection);
+END_TYPE;
+
+TYPE IfcHatchLineDistanceSelect = SELECT
+	(IfcPositiveLengthMeasure
+	,IfcVector);
+END_TYPE;
+
+TYPE IfcLayeredItem = SELECT
+	(IfcRepresentation
+	,IfcRepresentationItem);
+END_TYPE;
+
+TYPE IfcLibrarySelect = SELECT
+	(IfcLibraryInformation
+	,IfcLibraryReference);
+END_TYPE;
+
+TYPE IfcLightDistributionDataSourceSelect = SELECT
+	(IfcExternalReference
+	,IfcLightIntensityDistribution);
+END_TYPE;
+
+TYPE IfcMaterialSelect = SELECT
+	(IfcMaterialDefinition
+	,IfcMaterialList
+	,IfcMaterialUsageDefinition);
+END_TYPE;
+
+TYPE IfcMeasureValue = SELECT
+	(IfcAmountOfSubstanceMeasure
+	,IfcAreaMeasure
+	,IfcComplexNumber
+	,IfcContextDependentMeasure
+	,IfcCountMeasure
+	,IfcDescriptiveMeasure
+	,IfcElectricCurrentMeasure
+	,IfcLengthMeasure
+	,IfcLuminousIntensityMeasure
+	,IfcMassMeasure
+	,IfcNonNegativeLengthMeasure
+	,IfcNormalisedRatioMeasure
+	,IfcNumericMeasure
+	,IfcParameterValue
+	,IfcPlaneAngleMeasure
+	,IfcPositiveLengthMeasure
+	,IfcPositivePlaneAngleMeasure
+	,IfcPositiveRatioMeasure
+	,IfcRatioMeasure
+	,IfcSolidAngleMeasure
+	,IfcThermodynamicTemperatureMeasure
+	,IfcTimeMeasure
+	,IfcVolumeMeasure);
+END_TYPE;
+
+TYPE IfcMetricValueSelect = SELECT
+	(IfcAppliedValue
+	,IfcMeasureWithUnit
+	,IfcReference
+	,IfcTable
+	,IfcTimeSeries
+	,IfcValue);
+END_TYPE;
+
+TYPE IfcModulusOfRotationalSubgradeReactionSelect = SELECT
+	(IfcBoolean
+	,IfcModulusOfRotationalSubgradeReactionMeasure);
+END_TYPE;
+
+TYPE IfcModulusOfSubgradeReactionSelect = SELECT
+	(IfcBoolean
+	,IfcModulusOfSubgradeReactionMeasure);
+END_TYPE;
+
+TYPE IfcModulusOfTranslationalSubgradeReactionSelect = SELECT
+	(IfcBoolean
+	,IfcModulusOfLinearSubgradeReactionMeasure);
+END_TYPE;
+
+TYPE IfcObjectReferenceSelect = SELECT
+	(IfcAddress
+	,IfcAppliedValue
+	,IfcExternalReference
+	,IfcMaterialDefinition
+	,IfcOrganization
+	,IfcPerson
+	,IfcPersonAndOrganization
+	,IfcTable
+	,IfcTimeSeries);
+END_TYPE;
+
+TYPE IfcPointOrVertexPoint = SELECT
+	(IfcPoint
+	,IfcVertexPoint);
+END_TYPE;
+
+TYPE IfcPresentationStyleSelect = SELECT
+	(IfcCurveStyle
+	,IfcFillAreaStyle
+	,IfcNullStyle
+	,IfcSurfaceStyle
+	,IfcTextStyle);
+END_TYPE;
+
+TYPE IfcProcessSelect = SELECT
+	(IfcProcess
+	,IfcTypeProcess);
+END_TYPE;
+
+TYPE IfcProductRepresentationSelect = SELECT
+	(IfcProductDefinitionShape
+	,IfcRepresentationMap);
+END_TYPE;
+
+TYPE IfcProductSelect = SELECT
+	(IfcProduct
+	,IfcTypeProduct);
+END_TYPE;
+
+TYPE IfcPropertySetDefinitionSelect = SELECT
+	(IfcPropertySetDefinition
+	,IfcPropertySetDefinitionSet);
+END_TYPE;
+
+TYPE IfcResourceObjectSelect = SELECT
+	(IfcActorRole
+	,IfcAppliedValue
+	,IfcApproval
+	,IfcConstraint
+	,IfcContextDependentUnit
+	,IfcConversionBasedUnit
+	,IfcExternalInformation
+	,IfcExternalReference
+	,IfcMaterialDefinition
+	,IfcOrganization
+	,IfcPerson
+	,IfcPersonAndOrganization
+	,IfcPhysicalQuantity
+	,IfcProfileDef
+	,IfcPropertyAbstraction
+	,IfcTimeSeries);
+END_TYPE;
+
+TYPE IfcResourceSelect = SELECT
+	(IfcResource
+	,IfcTypeResource);
+END_TYPE;
+
+TYPE IfcRotationalStiffnessSelect = SELECT
+	(IfcBoolean
+	,IfcRotationalStiffnessMeasure);
+END_TYPE;
+
+TYPE IfcSegmentIndexSelect = SELECT
+	(IfcArcIndex
+	,IfcLineIndex);
+END_TYPE;
+
+TYPE IfcShell = SELECT
+	(IfcClosedShell
+	,IfcOpenShell);
+END_TYPE;
+
+TYPE IfcSimpleValue = SELECT
+	(IfcBinary
+	,IfcBoolean
+	,IfcDate
+	,IfcDateTime
+	,IfcDuration
+	,IfcIdentifier
+	,IfcInteger
+	,IfcLabel
+	,IfcLogical
+	,IfcPositiveInteger
+	,IfcReal
+	,IfcText
+	,IfcTime
+	,IfcTimeStamp);
+END_TYPE;
+
+TYPE IfcSizeSelect = SELECT
+	(IfcDescriptiveMeasure
+	,IfcLengthMeasure
+	,IfcNormalisedRatioMeasure
+	,IfcPositiveLengthMeasure
+	,IfcPositiveRatioMeasure
+	,IfcRatioMeasure);
+END_TYPE;
+
+TYPE IfcSolidOrShell = SELECT
+	(IfcClosedShell
+	,IfcSolidModel);
+END_TYPE;
+
+TYPE IfcSpaceBoundarySelect = SELECT
+	(IfcExternalSpatialElement
+	,IfcSpace);
+END_TYPE;
+
+TYPE IfcSpecularHighlightSelect = SELECT
+	(IfcSpecularExponent
+	,IfcSpecularRoughness);
+END_TYPE;
+
+TYPE IfcStructuralActivityAssignmentSelect = SELECT
+	(IfcElement
+	,IfcStructuralItem);
+END_TYPE;
+
+TYPE IfcStyleAssignmentSelect = SELECT
+	(IfcPresentationStyle
+	,IfcPresentationStyleAssignment);
+END_TYPE;
+
+TYPE IfcSurfaceOrFaceSurface = SELECT
+	(IfcFaceBasedSurfaceModel
+	,IfcFaceSurface
+	,IfcSurface);
+END_TYPE;
+
+TYPE IfcSurfaceStyleElementSelect = SELECT
+	(IfcExternallyDefinedSurfaceStyle
+	,IfcSurfaceStyleLighting
+	,IfcSurfaceStyleRefraction
+	,IfcSurfaceStyleShading
+	,IfcSurfaceStyleWithTextures);
+END_TYPE;
+
+TYPE IfcTextFontSelect = SELECT
+	(IfcExternallyDefinedTextFont
+	,IfcPreDefinedTextFont);
+END_TYPE;
+
+TYPE IfcTimeOrRatioSelect = SELECT
+	(IfcDuration
+	,IfcRatioMeasure);
+END_TYPE;
+
+TYPE IfcTranslationalStiffnessSelect = SELECT
+	(IfcBoolean
+	,IfcLinearStiffnessMeasure);
+END_TYPE;
+
+TYPE IfcTrimmingSelect = SELECT
+	(IfcCartesianPoint
+	,IfcParameterValue);
+END_TYPE;
+
+TYPE IfcUnit = SELECT
+	(IfcDerivedUnit
+	,IfcMonetaryUnit
+	,IfcNamedUnit);
+END_TYPE;
+
+TYPE IfcValue = SELECT
+	(IfcDerivedMeasureValue
+	,IfcMeasureValue
+	,IfcSimpleValue);
+END_TYPE;
+
+TYPE IfcVectorOrDirection = SELECT
+	(IfcDirection
+	,IfcVector);
+END_TYPE;
+
+TYPE IfcWarpingStiffnessSelect = SELECT
+	(IfcBoolean
+	,IfcWarpingMomentMeasure);
+END_TYPE;
+
+ENTITY IfcActionRequest
+ SUBTYPE OF (IfcControl);
+	PredefinedType : OPTIONAL IfcActionRequestTypeEnum;
+	Status : OPTIONAL IfcLabel;
+	LongDescription : OPTIONAL IfcText;
+END_ENTITY;
+
+ENTITY IfcActor
+ SUPERTYPE OF (ONEOF
+    (IfcOccupant))
+ SUBTYPE OF (IfcObject);
+	TheActor : IfcActorSelect;
+ INVERSE
+	IsActingUpon : SET [0:?] OF IfcRelAssignsToActor FOR RelatingActor;
+END_ENTITY;
+
+ENTITY IfcActorRole;
+	Role : IfcRoleEnum;
+	UserDefinedRole : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+ INVERSE
+	HasExternalReference : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+ WHERE
+	WR1 : (Role <> IfcRoleEnum.USERDEFINED) OR
+((Role = IfcRoleEnum.USERDEFINED) AND
+  EXISTS(SELF.UserDefinedRole));
+END_ENTITY;
+
+ENTITY IfcActuator
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcActuatorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcActuatorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcActuatorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCACTUATORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcActuatorType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcActuatorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcActuatorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcActuatorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcAddress
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPostalAddress
+    ,IfcTelecomAddress));
+	Purpose : OPTIONAL IfcAddressTypeEnum;
+	Description : OPTIONAL IfcText;
+	UserDefinedPurpose : OPTIONAL IfcLabel;
+ INVERSE
+	OfPerson : SET [0:?] OF IfcPerson FOR Addresses;
+	OfOrganization : SET [0:?] OF IfcOrganization FOR Addresses;
+ WHERE
+	WR1 : (NOT(EXISTS(Purpose))) OR
+((Purpose <> IfcAddressTypeEnum.USERDEFINED) OR
+((Purpose = IfcAddressTypeEnum.USERDEFINED) AND
+  EXISTS(SELF.UserDefinedPurpose)));
+END_ENTITY;
+
+ENTITY IfcAdvancedBrep
+ SUPERTYPE OF (ONEOF
+    (IfcAdvancedBrepWithVoids))
+ SUBTYPE OF (IfcManifoldSolidBrep);
+ WHERE
+	HasAdvancedFaces : SIZEOF(QUERY(Afs <* SELF\IfcManifoldSolidBrep.Outer.CfsFaces |
+  (NOT ('IFC4.IFCADVANCEDFACE' IN TYPEOF(Afs)))
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcAdvancedBrepWithVoids
+ SUBTYPE OF (IfcAdvancedBrep);
+	Voids : SET [1:?] OF IfcClosedShell;
+ WHERE
+	VoidsHaveAdvancedFaces : SIZEOF (QUERY (Vsh <* Voids |
+  SIZEOF (QUERY (Afs <* Vsh.CfsFaces |
+  (NOT ('IFC4.IFCADVANCEDFACE' IN TYPEOF(Afs)))
+  )) = 0
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcAdvancedFace
+ SUBTYPE OF (IfcFaceSurface);
+ WHERE
+	ApplicableSurface : SIZEOF (
+['IFC4.IFCELEMENTARYSURFACE',
+ 'IFC4.IFCSWEPTSURFACE',
+ 'IFC4.IFCBSPLINESURFACE'] *
+TYPEOF(SELF\IfcFaceSurface.FaceSurface)) = 1;
+	RequiresEdgeCurve : SIZEOF(QUERY (ElpFbnds <* 
+  QUERY (Bnds <* SELF\IfcFace.Bounds |
+    'IFC4.IFCEDGELOOP' IN TYPEOF(Bnds.Bound)) |
+     NOT (SIZEOF (QUERY (Oe <* ElpFbnds.Bound\IfcEdgeLoop.EdgeList |
+       NOT('IFC4.IFCEDGECURVE' IN 
+       TYPEOF(Oe\IfcOrientedEdge.EdgeElement)
+  ))) = 0
+))) = 0;
+	ApplicableEdgeCurves : SIZEOF(QUERY (ElpFbnds <* 
+  QUERY (Bnds <* SELF\IfcFace.Bounds |
+    'IFC4.IFCEDGELOOP' IN TYPEOF(Bnds.Bound)) |
+     NOT (SIZEOF (QUERY (Oe <* ElpFbnds.Bound\IfcEdgeLoop.EdgeList |
+       NOT (SIZEOF (['IFC4.IFCLINE',
+                     'IFC4.IFCCONIC',
+                     'IFC4.IFCPOLYLINE',
+                     'IFC4.IFCBSPLINECURVE'] *
+         TYPEOF(Oe\IfcOrientedEdge.EdgeElement\IfcEdgeCurve.EdgeGeometry)) = 1 )
+  )) = 0
+))) = 0;
+END_ENTITY;
+
+ENTITY IfcAirTerminal
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcAirTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcAirTerminalTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcAirTerminalTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCAIRTERMINALTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcAirTerminalBox
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcAirTerminalBoxTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcAirTerminalBoxTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcAirTerminalBoxTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCAIRTERMINALBOXTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcAirTerminalBoxType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcAirTerminalBoxTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcAirTerminalBoxTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcAirTerminalBoxTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcAirTerminalType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcAirTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcAirTerminalTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcAirTerminalTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcAirToAirHeatRecovery
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcAirToAirHeatRecoveryTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCAIRTOAIRHEATRECOVERYTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcAirToAirHeatRecoveryType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcAirToAirHeatRecoveryTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcAlarm
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcAlarmTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcAlarmTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcAlarmTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCALARMTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcAlarmType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcAlarmTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcAlarmTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcAlarmTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcAnnotation
+ SUBTYPE OF (IfcProduct);
+ INVERSE
+	ContainedInStructure : SET [0:1] OF IfcRelContainedInSpatialStructure FOR RelatedElements;
+END_ENTITY;
+
+ENTITY IfcAnnotationFillArea
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	OuterBoundary : IfcCurve;
+	InnerBoundaries : OPTIONAL SET [1:?] OF IfcCurve;
+END_ENTITY;
+
+ENTITY IfcApplication;
+	ApplicationDeveloper : IfcOrganization;
+	Version : IfcLabel;
+	ApplicationFullName : IfcLabel;
+	ApplicationIdentifier : IfcIdentifier;
+ UNIQUE
+	UR1 : ApplicationIdentifier;
+	UR2 : ApplicationFullName, Version;
+END_ENTITY;
+
+ENTITY IfcAppliedValue
+ SUPERTYPE OF (ONEOF
+    (IfcCostValue));
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	AppliedValue : OPTIONAL IfcAppliedValueSelect;
+	UnitBasis : OPTIONAL IfcMeasureWithUnit;
+	ApplicableDate : OPTIONAL IfcDate;
+	FixedUntilDate : OPTIONAL IfcDate;
+	Category : OPTIONAL IfcLabel;
+	Condition : OPTIONAL IfcLabel;
+	ArithmeticOperator : OPTIONAL IfcArithmeticOperatorEnum;
+	Components : OPTIONAL LIST [1:?] OF IfcAppliedValue;
+ INVERSE
+	HasExternalReference : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+END_ENTITY;
+
+ENTITY IfcApproval;
+	Identifier : OPTIONAL IfcIdentifier;
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	TimeOfApproval : OPTIONAL IfcDateTime;
+	Status : OPTIONAL IfcLabel;
+	Level : OPTIONAL IfcLabel;
+	Qualifier : OPTIONAL IfcText;
+	RequestingApproval : OPTIONAL IfcActorSelect;
+	GivingApproval : OPTIONAL IfcActorSelect;
+ INVERSE
+	HasExternalReferences : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+	ApprovedObjects : SET [0:?] OF IfcRelAssociatesApproval FOR RelatingApproval;
+	ApprovedResources : SET [0:?] OF IfcResourceApprovalRelationship FOR RelatingApproval;
+	IsRelatedWith : SET [0:?] OF IfcApprovalRelationship FOR RelatedApprovals;
+	Relates : SET [0:?] OF IfcApprovalRelationship FOR RelatingApproval;
+ WHERE
+	HasIdentifierOrName : EXISTS (Identifier) OR EXISTS (Name);
+END_ENTITY;
+
+ENTITY IfcApprovalRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingApproval : IfcApproval;
+	RelatedApprovals : SET [1:?] OF IfcApproval;
+END_ENTITY;
+
+ENTITY IfcArbitraryClosedProfileDef
+ SUPERTYPE OF (ONEOF
+    (IfcArbitraryProfileDefWithVoids))
+ SUBTYPE OF (IfcProfileDef);
+	OuterCurve : IfcCurve;
+ WHERE
+	WR1 : OuterCurve.Dim = 2;
+	WR2 : NOT('IFC4.IFCLINE' IN TYPEOF(OuterCurve));
+	WR3 : NOT('IFC4.IFCOFFSETCURVE2D' IN TYPEOF(OuterCurve));
+END_ENTITY;
+
+ENTITY IfcArbitraryOpenProfileDef
+ SUPERTYPE OF (ONEOF
+    (IfcCenterLineProfileDef))
+ SUBTYPE OF (IfcProfileDef);
+	Curve : IfcBoundedCurve;
+ WHERE
+	WR11 : ('IFC4.IFCCENTERLINEPROFILEDEF' IN TYPEOF(SELF)) OR 
+ (SELF\IfcProfileDef.ProfileType = IfcProfileTypeEnum.CURVE);
+	WR12 : Curve.Dim = 2;
+END_ENTITY;
+
+ENTITY IfcArbitraryProfileDefWithVoids
+ SUBTYPE OF (IfcArbitraryClosedProfileDef);
+	InnerCurves : SET [1:?] OF IfcCurve;
+ WHERE
+	WR1 : SELF\IfcProfileDef.ProfileType = AREA;
+	WR2 : SIZEOF(QUERY(temp <* InnerCurves | temp.Dim <> 2)) = 0;
+	WR3 : SIZEOF(QUERY(temp <* InnerCurves | 'IFC4.IFCLINE' IN TYPEOF(temp))) = 0;
+END_ENTITY;
+
+ENTITY IfcAsset
+ SUBTYPE OF (IfcGroup);
+	Identification : OPTIONAL IfcIdentifier;
+	OriginalValue : OPTIONAL IfcCostValue;
+	CurrentValue : OPTIONAL IfcCostValue;
+	TotalReplacementCost : OPTIONAL IfcCostValue;
+	Owner : OPTIONAL IfcActorSelect;
+	User : OPTIONAL IfcActorSelect;
+	ResponsiblePerson : OPTIONAL IfcPerson;
+	IncorporationDate : OPTIONAL IfcDate;
+	DepreciatedValue : OPTIONAL IfcCostValue;
+END_ENTITY;
+
+ENTITY IfcAsymmetricIShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	BottomFlangeWidth : IfcPositiveLengthMeasure;
+	OverallDepth : IfcPositiveLengthMeasure;
+	WebThickness : IfcPositiveLengthMeasure;
+	BottomFlangeThickness : IfcPositiveLengthMeasure;
+	BottomFlangeFilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	TopFlangeWidth : IfcPositiveLengthMeasure;
+	TopFlangeThickness : OPTIONAL IfcPositiveLengthMeasure;
+	TopFlangeFilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	BottomFlangeEdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	BottomFlangeSlope : OPTIONAL IfcPlaneAngleMeasure;
+	TopFlangeEdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	TopFlangeSlope : OPTIONAL IfcPlaneAngleMeasure;
+ WHERE
+	ValidFlangeThickness : NOT(EXISTS(TopFlangeThickness)) OR ((BottomFlangeThickness + TopFlangeThickness) < OverallDepth);
+	ValidWebThickness : (WebThickness < BottomFlangeWidth) AND (WebThickness < TopFlangeWidth);
+	ValidBottomFilletRadius : (NOT(EXISTS(BottomFlangeFilletRadius))) OR 
+(BottomFlangeFilletRadius <= (BottomFlangeWidth - WebThickness)/2.);
+	ValidTopFilletRadius : (NOT(EXISTS(TopFlangeFilletRadius))) OR 
+(TopFlangeFilletRadius <= (TopFlangeWidth - WebThickness)/2.);
+END_ENTITY;
+
+ENTITY IfcAudioVisualAppliance
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcAudioVisualApplianceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcAudioVisualApplianceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcAudioVisualApplianceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCAUDIOVISUALAPPLIANCETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcAudioVisualApplianceType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcAudioVisualApplianceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcAudioVisualApplianceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcAudioVisualApplianceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcAxis1Placement
+ SUBTYPE OF (IfcPlacement);
+	Axis : OPTIONAL IfcDirection;
+ DERIVE
+	Z : IfcDirection := NVL (IfcNormalise(Axis), IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0,0.0,1.0]));
+ WHERE
+	AxisIs3D : (NOT (EXISTS (Axis))) OR (Axis.Dim = 3);
+	LocationIs3D : SELF\IfcPlacement.Location.Dim = 3;
+END_ENTITY;
+
+ENTITY IfcAxis2Placement2D
+ SUBTYPE OF (IfcPlacement);
+	RefDirection : OPTIONAL IfcDirection;
+ DERIVE
+	P : LIST [2:2] OF IfcDirection := IfcBuild2Axes(RefDirection);
+ WHERE
+	RefDirIs2D : (NOT (EXISTS (RefDirection))) OR (RefDirection.Dim = 2);
+	LocationIs2D : SELF\IfcPlacement.Location.Dim = 2;
+END_ENTITY;
+
+ENTITY IfcAxis2Placement3D
+ SUBTYPE OF (IfcPlacement);
+	Axis : OPTIONAL IfcDirection;
+	RefDirection : OPTIONAL IfcDirection;
+ DERIVE
+	P : LIST [3:3] OF IfcDirection := IfcBuildAxes(Axis, RefDirection);
+ WHERE
+	LocationIs3D : SELF\IfcPlacement.Location.Dim = 3;
+	AxisIs3D : (NOT (EXISTS (Axis))) OR (Axis.Dim = 3);
+	RefDirIs3D : (NOT (EXISTS (RefDirection))) OR (RefDirection.Dim = 3);
+	AxisToRefDirPosition : (NOT (EXISTS (Axis))) OR (NOT (EXISTS (RefDirection))) OR (IfcCrossProduct(Axis,RefDirection).Magnitude > 0.0);
+	AxisAndRefDirProvision : NOT ((EXISTS (Axis)) XOR (EXISTS (RefDirection)));
+END_ENTITY;
+
+ENTITY IfcBSplineCurve
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBSplineCurveWithKnots))
+ SUBTYPE OF (IfcBoundedCurve);
+	Degree : IfcInteger;
+	ControlPointsList : LIST [2:?] OF IfcCartesianPoint;
+	CurveForm : IfcBSplineCurveForm;
+	ClosedCurve : IfcLogical;
+	SelfIntersect : IfcLogical;
+ DERIVE
+	UpperIndexOnControlPoints : IfcInteger := (SIZEOF(ControlPointsList) - 1);
+	ControlPoints : ARRAY [0:UpperIndexOnControlPoints] OF IfcCartesianPoint := IfcListToArray(ControlPointsList,0,UpperIndexOnControlPoints);
+ WHERE
+	SameDim : SIZEOF(QUERY(Temp <* ControlPointsList |
+  Temp.Dim <> ControlPointsList[1].Dim))
+= 0;
+END_ENTITY;
+
+ENTITY IfcBSplineCurveWithKnots
+ SUPERTYPE OF (ONEOF
+    (IfcRationalBSplineCurveWithKnots))
+ SUBTYPE OF (IfcBSplineCurve);
+	KnotMultiplicities : LIST [2:?] OF IfcInteger;
+	Knots : LIST [2:?] OF IfcParameterValue;
+	KnotSpec : IfcKnotType;
+ DERIVE
+	UpperIndexOnKnots : IfcInteger := SIZEOF(Knots);
+ WHERE
+	ConsistentBSpline : IfcConstraintsParamBSpline(Degree, UpperIndexOnKnots,
+UpperIndexOnControlPoints, KnotMultiplicities, Knots);
+	CorrespondingKnotLists : SIZEOF(KnotMultiplicities) = UpperIndexOnKnots;
+END_ENTITY;
+
+ENTITY IfcBSplineSurface
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBSplineSurfaceWithKnots))
+ SUBTYPE OF (IfcBoundedSurface);
+	UDegree : IfcInteger;
+	VDegree : IfcInteger;
+	ControlPointsList : LIST [2:?] OF LIST [2:?] OF IfcCartesianPoint;
+	SurfaceForm : IfcBSplineSurfaceForm;
+	UClosed : IfcLogical;
+	VClosed : IfcLogical;
+	SelfIntersect : IfcLogical;
+ DERIVE
+	UUpper : IfcInteger := SIZEOF(ControlPointsList) - 1;
+	VUpper : IfcInteger := SIZEOF(ControlPointsList[1]) - 1;
+	ControlPoints : ARRAY [0:UUpper] OF ARRAY [0:VUpper] OF IfcCartesianPoint := IfcMakeArrayOfArray(ControlPointsList,
+0,UUpper,0,VUpper);
+END_ENTITY;
+
+ENTITY IfcBSplineSurfaceWithKnots
+ SUPERTYPE OF (ONEOF
+    (IfcRationalBSplineSurfaceWithKnots))
+ SUBTYPE OF (IfcBSplineSurface);
+	UMultiplicities : LIST [2:?] OF IfcInteger;
+	VMultiplicities : LIST [2:?] OF IfcInteger;
+	UKnots : LIST [2:?] OF IfcParameterValue;
+	VKnots : LIST [2:?] OF IfcParameterValue;
+	KnotSpec : IfcKnotType;
+ DERIVE
+	KnotVUpper : IfcInteger := SIZEOF(VKnots);
+	KnotUUpper : IfcInteger := SIZEOF(UKnots);
+ WHERE
+	UDirectionConstraints : IfcConstraintsParamBSpline (
+  SELF\IfcBSplineSurface.UDegree, KnotUUpper, 
+  SELF\IfcBSplineSurface.UUpper, UMultiplicities, UKnots);
+	VDirectionConstraints : IfcConstraintsParamBSpline (
+  SELF\IfcBSplineSurface.VDegree, KnotVUpper, 
+  SELF\IfcBSplineSurface.VUpper, VMultiplicities, VKnots);
+	CorrespondingULists : SIZEOF(UMultiplicities) = KnotUUpper;
+	CorrespondingVLists : SIZEOF(VMultiplicities) = KnotVUpper;
+END_ENTITY;
+
+ENTITY IfcBeam
+ SUPERTYPE OF (ONEOF
+    (IfcBeamStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcBeamTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcBeamTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcBeamTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCBEAMTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcBeamStandardCase
+ SUBTYPE OF (IfcBeam);
+ WHERE
+	HasMaterialProfileSetUsage : SIZEOF (QUERY(temp <* USEDIN(SELF, 'IFC4.IFCRELASSOCIATES.RELATEDOBJECTS') |
+              ('IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)) AND
+              ('IFC4.IFCMATERIALPROFILESETUSAGE' IN TYPEOF(temp.RelatingMaterial))
+              )) = 1;
+END_ENTITY;
+
+ENTITY IfcBeamType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcBeamTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcBeamTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcBeamTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcBlobTexture
+ SUBTYPE OF (IfcSurfaceTexture);
+	RasterFormat : IfcIdentifier;
+	RasterCode : IfcBinary;
+ WHERE
+	SupportedRasterFormat : SELF.RasterFormat IN ['BMP', 'JPG', 'GIF', 'PNG'];
+	RasterCodeByteStream : BLENGTH(RasterCode) MOD 8 = 0;
+END_ENTITY;
+
+ENTITY IfcBlock
+ SUBTYPE OF (IfcCsgPrimitive3D);
+	XLength : IfcPositiveLengthMeasure;
+	YLength : IfcPositiveLengthMeasure;
+	ZLength : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcBoiler
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcBoilerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcBoilerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcBoilerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCBOILERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcBoilerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcBoilerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcBoilerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcBoilerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcBooleanClippingResult
+ SUBTYPE OF (IfcBooleanResult);
+ WHERE
+	FirstOperandType : ('IFC4.IFCSWEPTAREASOLID' IN TYPEOF(FirstOperand)) OR 
+('IFC4.IFCSWEPTDISCSOLID' IN TYPEOF(FirstOperand)) OR 
+('IFC4.IFCBOOLEANCLIPPINGRESULT' IN TYPEOF(FirstOperand));
+	SecondOperandType : ('IFC4.IFCHALFSPACESOLID' IN TYPEOF(SecondOperand));
+	OperatorType : Operator = DIFFERENCE;
+END_ENTITY;
+
+ENTITY IfcBooleanResult
+ SUPERTYPE OF (ONEOF
+    (IfcBooleanClippingResult))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Operator : IfcBooleanOperator;
+	FirstOperand : IfcBooleanOperand;
+	SecondOperand : IfcBooleanOperand;
+ DERIVE
+	Dim : IfcDimensionCount := FirstOperand.Dim;
+ WHERE
+	SameDim : FirstOperand.Dim = SecondOperand.Dim;
+	FirstOperandClosed : NOT('IFC4.IFCTESSELLATEDFACESET' IN TYPEOF(FirstOperand)) OR (EXISTS(FirstOperand.Closed) AND FirstOperand.Closed);
+	SecondOperandClosed : NOT('IFC4.IFCTESSELLATEDFACESET' IN TYPEOF(SecondOperand)) OR (EXISTS(SecondOperand.Closed) AND SecondOperand.Closed);
+END_ENTITY;
+
+ENTITY IfcBoundaryCondition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBoundaryEdgeCondition
+    ,IfcBoundaryFaceCondition
+    ,IfcBoundaryNodeCondition));
+	Name : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcBoundaryCurve
+ SUPERTYPE OF (ONEOF
+    (IfcOuterBoundaryCurve))
+ SUBTYPE OF (IfcCompositeCurveOnSurface);
+ WHERE
+	IsClosed : SELF\IfcCompositeCurve.ClosedCurve;
+END_ENTITY;
+
+ENTITY IfcBoundaryEdgeCondition
+ SUBTYPE OF (IfcBoundaryCondition);
+	TranslationalStiffnessByLengthX : OPTIONAL IfcModulusOfTranslationalSubgradeReactionSelect;
+	TranslationalStiffnessByLengthY : OPTIONAL IfcModulusOfTranslationalSubgradeReactionSelect;
+	TranslationalStiffnessByLengthZ : OPTIONAL IfcModulusOfTranslationalSubgradeReactionSelect;
+	RotationalStiffnessByLengthX : OPTIONAL IfcModulusOfRotationalSubgradeReactionSelect;
+	RotationalStiffnessByLengthY : OPTIONAL IfcModulusOfRotationalSubgradeReactionSelect;
+	RotationalStiffnessByLengthZ : OPTIONAL IfcModulusOfRotationalSubgradeReactionSelect;
+END_ENTITY;
+
+ENTITY IfcBoundaryFaceCondition
+ SUBTYPE OF (IfcBoundaryCondition);
+	TranslationalStiffnessByAreaX : OPTIONAL IfcModulusOfSubgradeReactionSelect;
+	TranslationalStiffnessByAreaY : OPTIONAL IfcModulusOfSubgradeReactionSelect;
+	TranslationalStiffnessByAreaZ : OPTIONAL IfcModulusOfSubgradeReactionSelect;
+END_ENTITY;
+
+ENTITY IfcBoundaryNodeCondition
+ SUPERTYPE OF (ONEOF
+    (IfcBoundaryNodeConditionWarping))
+ SUBTYPE OF (IfcBoundaryCondition);
+	TranslationalStiffnessX : OPTIONAL IfcTranslationalStiffnessSelect;
+	TranslationalStiffnessY : OPTIONAL IfcTranslationalStiffnessSelect;
+	TranslationalStiffnessZ : OPTIONAL IfcTranslationalStiffnessSelect;
+	RotationalStiffnessX : OPTIONAL IfcRotationalStiffnessSelect;
+	RotationalStiffnessY : OPTIONAL IfcRotationalStiffnessSelect;
+	RotationalStiffnessZ : OPTIONAL IfcRotationalStiffnessSelect;
+END_ENTITY;
+
+ENTITY IfcBoundaryNodeConditionWarping
+ SUBTYPE OF (IfcBoundaryNodeCondition);
+	WarpingStiffness : OPTIONAL IfcWarpingStiffnessSelect;
+END_ENTITY;
+
+ENTITY IfcBoundedCurve
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBSplineCurve
+    ,IfcCompositeCurve
+    ,IfcIndexedPolyCurve
+    ,IfcPolyline
+    ,IfcTrimmedCurve))
+ SUBTYPE OF (IfcCurve);
+END_ENTITY;
+
+ENTITY IfcBoundedSurface
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBSplineSurface
+    ,IfcCurveBoundedPlane
+    ,IfcCurveBoundedSurface
+    ,IfcRectangularTrimmedSurface))
+ SUBTYPE OF (IfcSurface);
+END_ENTITY;
+
+ENTITY IfcBoundingBox
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Corner : IfcCartesianPoint;
+	XDim : IfcPositiveLengthMeasure;
+	YDim : IfcPositiveLengthMeasure;
+	ZDim : IfcPositiveLengthMeasure;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcBoxedHalfSpace
+ SUBTYPE OF (IfcHalfSpaceSolid);
+	Enclosure : IfcBoundingBox;
+ WHERE
+	UnboundedSurface : NOT ('IFC4.IFCCURVEBOUNDEDPLANE' IN TYPEOF(SELF\IfcHalfSpaceSolid.BaseSurface));
+END_ENTITY;
+
+ENTITY IfcBuilding
+ SUBTYPE OF (IfcSpatialStructureElement);
+	ElevationOfRefHeight : OPTIONAL IfcLengthMeasure;
+	ElevationOfTerrain : OPTIONAL IfcLengthMeasure;
+	BuildingAddress : OPTIONAL IfcPostalAddress;
+END_ENTITY;
+
+ENTITY IfcBuildingElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBeam
+    ,IfcBuildingElementProxy
+    ,IfcChimney
+    ,IfcColumn
+    ,IfcCovering
+    ,IfcCurtainWall
+    ,IfcDoor
+    ,IfcFooting
+    ,IfcMember
+    ,IfcPile
+    ,IfcPlate
+    ,IfcRailing
+    ,IfcRamp
+    ,IfcRampFlight
+    ,IfcRoof
+    ,IfcShadingDevice
+    ,IfcSlab
+    ,IfcStair
+    ,IfcStairFlight
+    ,IfcWall
+    ,IfcWindow))
+ SUBTYPE OF (IfcElement);
+ WHERE
+	MaxOneMaterialAssociation : SIZEOF (QUERY(temp <* SELF\IfcObjectDefinition.HasAssociations |
+  'IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)
+  )) <= 1;
+END_ENTITY;
+
+ENTITY IfcBuildingElementPart
+ SUBTYPE OF (IfcElementComponent);
+	PredefinedType : OPTIONAL IfcBuildingElementPartTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+(PredefinedType <> IfcBuildingElementPartTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcBuildingElementPartTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCBUILDINGELEMENTPARTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcBuildingElementPartType
+ SUBTYPE OF (IfcElementComponentType);
+	PredefinedType : IfcBuildingElementPartTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcBuildingElementPartTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcBuildingElementPartTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcBuildingElementProxy
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcBuildingElementProxyTypeEnum;
+ WHERE
+	HasObjectName : EXISTS(SELF\IfcRoot.Name);
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcBuildingElementProxyTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcBuildingElementProxyTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCBUILDINGELEMENTPROXYTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcBuildingElementProxyType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcBuildingElementProxyTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcBuildingElementProxyTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcBuildingElementProxyTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcBuildingElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBeamType
+    ,IfcBuildingElementProxyType
+    ,IfcChimneyType
+    ,IfcColumnType
+    ,IfcCoveringType
+    ,IfcCurtainWallType
+    ,IfcDoorType
+    ,IfcFootingType
+    ,IfcMemberType
+    ,IfcPileType
+    ,IfcPlateType
+    ,IfcRailingType
+    ,IfcRampFlightType
+    ,IfcRampType
+    ,IfcRoofType
+    ,IfcShadingDeviceType
+    ,IfcSlabType
+    ,IfcStairFlightType
+    ,IfcStairType
+    ,IfcWallType
+    ,IfcWindowType))
+ SUBTYPE OF (IfcElementType);
+END_ENTITY;
+
+ENTITY IfcBuildingStorey
+ SUBTYPE OF (IfcSpatialStructureElement);
+	Elevation : OPTIONAL IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcBuildingSystem
+ SUBTYPE OF (IfcSystem);
+	PredefinedType : OPTIONAL IfcBuildingSystemTypeEnum;
+	LongName : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcBurner
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcBurnerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcBurnerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcBurnerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCBURNERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcBurnerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcBurnerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcBurnerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcBurnerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	Depth : IfcPositiveLengthMeasure;
+	Width : IfcPositiveLengthMeasure;
+	WallThickness : IfcPositiveLengthMeasure;
+	Girth : IfcPositiveLengthMeasure;
+	InternalFilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+ WHERE
+	ValidGirth : Girth < (Depth / 2.);
+	ValidInternalFilletRadius : NOT(EXISTS(InternalFilletRadius)) OR
+((InternalFilletRadius <= Width/2. - WallThickness) AND (InternalFilletRadius <= Depth/2. - WallThickness));
+	ValidWallThickness : (WallThickness < Width/2.) AND (WallThickness < Depth/2.);
+END_ENTITY;
+
+ENTITY IfcCableCarrierFitting
+ SUBTYPE OF (IfcFlowFitting);
+	PredefinedType : OPTIONAL IfcCableCarrierFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCableCarrierFittingTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCableCarrierFittingTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCABLECARRIERFITTINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCableCarrierFittingType
+ SUBTYPE OF (IfcFlowFittingType);
+	PredefinedType : IfcCableCarrierFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCableCarrierFittingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCableCarrierFittingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCableCarrierSegment
+ SUBTYPE OF (IfcFlowSegment);
+	PredefinedType : OPTIONAL IfcCableCarrierSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCableCarrierSegmentTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCableCarrierSegmentTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCABLECARRIERSEGMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCableCarrierSegmentType
+ SUBTYPE OF (IfcFlowSegmentType);
+	PredefinedType : IfcCableCarrierSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCableCarrierSegmentTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCableCarrierSegmentTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCableFitting
+ SUBTYPE OF (IfcFlowFitting);
+	PredefinedType : OPTIONAL IfcCableFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCableFittingTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCableFittingTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCABLEFITTINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCableFittingType
+ SUBTYPE OF (IfcFlowFittingType);
+	PredefinedType : IfcCableFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCableFittingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCableFittingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCableSegment
+ SUBTYPE OF (IfcFlowSegment);
+	PredefinedType : OPTIONAL IfcCableSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCableSegmentTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCableSegmentTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCABLESEGMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCableSegmentType
+ SUBTYPE OF (IfcFlowSegmentType);
+	PredefinedType : IfcCableSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCableSegmentTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCableSegmentTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCartesianPoint
+ SUBTYPE OF (IfcPoint);
+	Coordinates : LIST [1:3] OF IfcLengthMeasure;
+ DERIVE
+	Dim : IfcDimensionCount := HIINDEX(Coordinates);
+ WHERE
+	CP2Dor3D : HIINDEX(Coordinates) >= 2;
+END_ENTITY;
+
+ENTITY IfcCartesianPointList
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCartesianPointList2D
+    ,IfcCartesianPointList3D))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+ DERIVE
+	Dim : IfcDimensionCount := IfcPointListDim(SELF);
+END_ENTITY;
+
+ENTITY IfcCartesianPointList2D
+ SUBTYPE OF (IfcCartesianPointList);
+	CoordList : LIST [1:?] OF LIST [2:2] OF IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcCartesianPointList3D
+ SUBTYPE OF (IfcCartesianPointList);
+	CoordList : LIST [1:?] OF LIST [3:3] OF IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcCartesianTransformationOperator
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCartesianTransformationOperator2D
+    ,IfcCartesianTransformationOperator3D))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Axis1 : OPTIONAL IfcDirection;
+	Axis2 : OPTIONAL IfcDirection;
+	LocalOrigin : IfcCartesianPoint;
+	Scale : OPTIONAL IfcReal;
+ DERIVE
+	Scl : IfcReal := NVL(Scale, 1.0);
+	Dim : IfcDimensionCount := LocalOrigin.Dim;
+ WHERE
+	ScaleGreaterZero : Scl > 0.0;
+END_ENTITY;
+
+ENTITY IfcCartesianTransformationOperator2D
+ SUPERTYPE OF (ONEOF
+    (IfcCartesianTransformationOperator2DnonUniform))
+ SUBTYPE OF (IfcCartesianTransformationOperator);
+ DERIVE
+	U : LIST [2:2] OF IfcDirection := IfcBaseAxis(2,SELF\IfcCartesianTransformationOperator.Axis1,
+SELF\IfcCartesianTransformationOperator.Axis2,?);
+ WHERE
+	DimEqual2 : SELF\IfcCartesianTransformationOperator.Dim = 2;
+	Axis1Is2D : NOT(EXISTS(SELF\IfcCartesianTransformationOperator.Axis1)) OR 
+(SELF\IfcCartesianTransformationOperator.Axis1.Dim = 2);
+	Axis2Is2D : NOT(EXISTS(SELF\IfcCartesianTransformationOperator.Axis2)) OR 
+(SELF\IfcCartesianTransformationOperator.Axis2.Dim = 2);
+END_ENTITY;
+
+ENTITY IfcCartesianTransformationOperator2DnonUniform
+ SUBTYPE OF (IfcCartesianTransformationOperator2D);
+	Scale2 : OPTIONAL IfcReal;
+ DERIVE
+	Scl2 : IfcReal := NVL(Scale2, SELF\IfcCartesianTransformationOperator.Scl);
+ WHERE
+	Scale2GreaterZero : Scl2 > 0.0;
+END_ENTITY;
+
+ENTITY IfcCartesianTransformationOperator3D
+ SUPERTYPE OF (ONEOF
+    (IfcCartesianTransformationOperator3DnonUniform))
+ SUBTYPE OF (IfcCartesianTransformationOperator);
+	Axis3 : OPTIONAL IfcDirection;
+ DERIVE
+	U : LIST [3:3] OF IfcDirection := IfcBaseAxis(3,SELF\IfcCartesianTransformationOperator.Axis1,
+SELF\IfcCartesianTransformationOperator.Axis2,Axis3);
+ WHERE
+	DimIs3D : SELF\IfcCartesianTransformationOperator.Dim = 3;
+	Axis1Is3D : NOT(EXISTS(SELF\IfcCartesianTransformationOperator.Axis1)) OR 
+(SELF\IfcCartesianTransformationOperator.Axis1.Dim = 3);
+	Axis2Is3D : NOT(EXISTS(SELF\IfcCartesianTransformationOperator.Axis2)) OR 
+(SELF\IfcCartesianTransformationOperator.Axis2.Dim = 3);
+	Axis3Is3D : NOT(EXISTS(Axis3)) OR (Axis3.Dim = 3);
+END_ENTITY;
+
+ENTITY IfcCartesianTransformationOperator3DnonUniform
+ SUBTYPE OF (IfcCartesianTransformationOperator3D);
+	Scale2 : OPTIONAL IfcReal;
+	Scale3 : OPTIONAL IfcReal;
+ DERIVE
+	Scl2 : IfcReal := NVL(Scale2, SELF\IfcCartesianTransformationOperator.Scl);
+	Scl3 : IfcReal := NVL(Scale3, SELF\IfcCartesianTransformationOperator.Scl);
+ WHERE
+	Scale2GreaterZero : Scl2 > 0.0;
+	Scale3GreaterZero : Scl3 > 0.0;
+END_ENTITY;
+
+ENTITY IfcCenterLineProfileDef
+ SUBTYPE OF (IfcArbitraryOpenProfileDef);
+	Thickness : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcChiller
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcChillerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcChillerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcChillerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCHILLERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcChillerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcChillerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcChillerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcChillerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcChimney
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcChimneyTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcChimneyTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcChimneyTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCCHIMNEYTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcChimneyType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcChimneyTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcChimneyTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcChimneyTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCircle
+ SUBTYPE OF (IfcConic);
+	Radius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcCircleHollowProfileDef
+ SUBTYPE OF (IfcCircleProfileDef);
+	WallThickness : IfcPositiveLengthMeasure;
+ WHERE
+	WR1 : WallThickness < SELF\IfcCircleProfileDef.Radius;
+END_ENTITY;
+
+ENTITY IfcCircleProfileDef
+ SUPERTYPE OF (ONEOF
+    (IfcCircleHollowProfileDef))
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	Radius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcCivilElement
+ SUBTYPE OF (IfcElement);
+END_ENTITY;
+
+ENTITY IfcCivilElementType
+ SUBTYPE OF (IfcElementType);
+END_ENTITY;
+
+ENTITY IfcClassification
+ SUBTYPE OF (IfcExternalInformation);
+	Source : OPTIONAL IfcLabel;
+	Edition : OPTIONAL IfcLabel;
+	EditionDate : OPTIONAL IfcDate;
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	Location : OPTIONAL IfcURIReference;
+	ReferenceTokens : OPTIONAL LIST [1:?] OF IfcIdentifier;
+ INVERSE
+	ClassificationForObjects : SET [0:?] OF IfcRelAssociatesClassification FOR RelatingClassification;
+	HasReferences : SET [0:?] OF IfcClassificationReference FOR ReferencedSource;
+END_ENTITY;
+
+ENTITY IfcClassificationReference
+ SUBTYPE OF (IfcExternalReference);
+	ReferencedSource : OPTIONAL IfcClassificationReferenceSelect;
+	Description : OPTIONAL IfcText;
+	Sort : OPTIONAL IfcIdentifier;
+ INVERSE
+	ClassificationRefForObjects : SET [0:?] OF IfcRelAssociatesClassification FOR RelatingClassification;
+	HasReferences : SET [0:?] OF IfcClassificationReference FOR ReferencedSource;
+END_ENTITY;
+
+ENTITY IfcClosedShell
+ SUBTYPE OF (IfcConnectedFaceSet);
+END_ENTITY;
+
+ENTITY IfcCoil
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcCoilTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCoilTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCoilTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCOILTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCoilType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcCoilTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCoilTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCoilTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcColourRgb
+ SUBTYPE OF (IfcColourSpecification);
+	Red : IfcNormalisedRatioMeasure;
+	Green : IfcNormalisedRatioMeasure;
+	Blue : IfcNormalisedRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcColourRgbList
+ SUBTYPE OF (IfcPresentationItem);
+	ColourList : LIST [1:?] OF LIST [3:3] OF IfcNormalisedRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcColourSpecification
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcColourRgb))
+ SUBTYPE OF (IfcPresentationItem);
+	Name : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcColumn
+ SUPERTYPE OF (ONEOF
+    (IfcColumnStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcColumnTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcColumnTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcColumnTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCCOLUMNTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcColumnStandardCase
+ SUBTYPE OF (IfcColumn);
+ WHERE
+	HasMaterialProfileSetUsage : SIZEOF (QUERY(temp <* USEDIN(SELF, 'IFC4.IFCRELASSOCIATES.RELATEDOBJECTS') |
+              ('IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)) AND
+              ('IFC4.IFCMATERIALPROFILESETUSAGE' IN TYPEOF(temp.RelatingMaterial))
+              )) = 1;
+END_ENTITY;
+
+ENTITY IfcColumnType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcColumnTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcColumnTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcColumnTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCommunicationsAppliance
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcCommunicationsApplianceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCommunicationsApplianceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCommunicationsApplianceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCOMMUNICATIONSAPPLIANCETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCommunicationsApplianceType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcCommunicationsApplianceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCommunicationsApplianceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCommunicationsApplianceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcComplexProperty
+ SUBTYPE OF (IfcProperty);
+	UsageName : IfcIdentifier;
+	HasProperties : SET [1:?] OF IfcProperty;
+ WHERE
+	WR21 : SIZEOF(QUERY(temp <* HasProperties | SELF :=: temp)) = 0;
+	WR22 : IfcUniquePropertyName(HasProperties);
+END_ENTITY;
+
+ENTITY IfcComplexPropertyTemplate
+ SUBTYPE OF (IfcPropertyTemplate);
+	UsageName : OPTIONAL IfcLabel;
+	TemplateType : OPTIONAL IfcComplexPropertyTemplateTypeEnum;
+	HasPropertyTemplates : OPTIONAL SET [1:?] OF IfcPropertyTemplate;
+ WHERE
+	UniquePropertyNames : IfcUniquePropertyTemplateNames(HasPropertyTemplates);
+	NoSelfReference : SIZEOF(QUERY(temp <* HasPropertyTemplates | SELF :=: temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcCompositeCurve
+ SUPERTYPE OF (ONEOF
+    (IfcCompositeCurveOnSurface))
+ SUBTYPE OF (IfcBoundedCurve);
+	Segments : LIST [1:?] OF IfcCompositeCurveSegment;
+	SelfIntersect : IfcLogical;
+ DERIVE
+	NSegments : IfcInteger := SIZEOF(Segments);
+	ClosedCurve : IfcLogical := Segments[NSegments].Transition <> Discontinuous;
+ WHERE
+	CurveContinuous : ((NOT ClosedCurve) AND (SIZEOF(QUERY(Temp <* Segments | Temp.Transition = Discontinuous)) = 1)) OR ((ClosedCurve) AND (SIZEOF(QUERY(Temp <* Segments | Temp.Transition = Discontinuous)) = 0));
+	SameDim : SIZEOF( QUERY( Temp <* Segments | Temp.Dim <> Segments[1].Dim)) = 0;
+END_ENTITY;
+
+ENTITY IfcCompositeCurveOnSurface
+ SUPERTYPE OF (ONEOF
+    (IfcBoundaryCurve))
+ SUBTYPE OF (IfcCompositeCurve);
+ DERIVE
+	BasisSurface : SET [0:1] OF IfcSurface := IfcGetBasisSurface(SELF);
+ WHERE
+	SameSurface : SIZEOF(BasisSurface) > 0;
+END_ENTITY;
+
+ENTITY IfcCompositeCurveSegment
+ SUPERTYPE OF (ONEOF
+    (IfcReparametrisedCompositeCurveSegment))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Transition : IfcTransitionCode;
+	SameSense : IfcBoolean;
+	ParentCurve : IfcCurve;
+ DERIVE
+	Dim : IfcDimensionCount := ParentCurve.Dim;
+ INVERSE
+	UsingCurves : SET [1:?] OF IfcCompositeCurve FOR Segments;
+ WHERE
+	ParentIsBoundedCurve : ('IFC4.IFCBOUNDEDCURVE' IN TYPEOF(ParentCurve));
+END_ENTITY;
+
+ENTITY IfcCompositeProfileDef
+ SUBTYPE OF (IfcProfileDef);
+	Profiles : SET [2:?] OF IfcProfileDef;
+	Label : OPTIONAL IfcLabel;
+ WHERE
+	InvariantProfileType : SIZEOF(QUERY(temp <* Profiles | temp.ProfileType <> Profiles[1].ProfileType)) = 0;
+	NoRecursion : SIZEOF(QUERY(temp <* Profiles | 'IFC4.IFCCOMPOSITEPROFILEDEF' IN TYPEOF(temp))) = 0;
+END_ENTITY;
+
+ENTITY IfcCompressor
+ SUBTYPE OF (IfcFlowMovingDevice);
+	PredefinedType : OPTIONAL IfcCompressorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCompressorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCompressorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCOMPRESSORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCompressorType
+ SUBTYPE OF (IfcFlowMovingDeviceType);
+	PredefinedType : IfcCompressorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCompressorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCompressorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCondenser
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcCondenserTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCondenserTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCondenserTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCONDENSERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCondenserType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcCondenserTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCondenserTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCondenserTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcConic
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCircle
+    ,IfcEllipse))
+ SUBTYPE OF (IfcCurve);
+	Position : IfcAxis2Placement;
+END_ENTITY;
+
+ENTITY IfcConnectedFaceSet
+ SUPERTYPE OF (ONEOF
+    (IfcClosedShell
+    ,IfcOpenShell))
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+	CfsFaces : SET [1:?] OF IfcFace;
+END_ENTITY;
+
+ENTITY IfcConnectionCurveGeometry
+ SUBTYPE OF (IfcConnectionGeometry);
+	CurveOnRelatingElement : IfcCurveOrEdgeCurve;
+	CurveOnRelatedElement : OPTIONAL IfcCurveOrEdgeCurve;
+END_ENTITY;
+
+ENTITY IfcConnectionGeometry
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcConnectionCurveGeometry
+    ,IfcConnectionPointGeometry
+    ,IfcConnectionSurfaceGeometry
+    ,IfcConnectionVolumeGeometry));
+END_ENTITY;
+
+ENTITY IfcConnectionPointEccentricity
+ SUBTYPE OF (IfcConnectionPointGeometry);
+	EccentricityInX : OPTIONAL IfcLengthMeasure;
+	EccentricityInY : OPTIONAL IfcLengthMeasure;
+	EccentricityInZ : OPTIONAL IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcConnectionPointGeometry
+ SUPERTYPE OF (ONEOF
+    (IfcConnectionPointEccentricity))
+ SUBTYPE OF (IfcConnectionGeometry);
+	PointOnRelatingElement : IfcPointOrVertexPoint;
+	PointOnRelatedElement : OPTIONAL IfcPointOrVertexPoint;
+END_ENTITY;
+
+ENTITY IfcConnectionSurfaceGeometry
+ SUBTYPE OF (IfcConnectionGeometry);
+	SurfaceOnRelatingElement : IfcSurfaceOrFaceSurface;
+	SurfaceOnRelatedElement : OPTIONAL IfcSurfaceOrFaceSurface;
+END_ENTITY;
+
+ENTITY IfcConnectionVolumeGeometry
+ SUBTYPE OF (IfcConnectionGeometry);
+	VolumeOnRelatingElement : IfcSolidOrShell;
+	VolumeOnRelatedElement : OPTIONAL IfcSolidOrShell;
+END_ENTITY;
+
+ENTITY IfcConstraint
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcMetric
+    ,IfcObjective));
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	ConstraintGrade : IfcConstraintEnum;
+	ConstraintSource : OPTIONAL IfcLabel;
+	CreatingActor : OPTIONAL IfcActorSelect;
+	CreationTime : OPTIONAL IfcDateTime;
+	UserDefinedGrade : OPTIONAL IfcLabel;
+ INVERSE
+	HasExternalReferences : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+	PropertiesForConstraint : SET [0:?] OF IfcResourceConstraintRelationship FOR RelatingConstraint;
+ WHERE
+	WR11 : (ConstraintGrade <> IfcConstraintEnum.USERDEFINED) OR
+((ConstraintGrade = IfcConstraintEnum.USERDEFINED) AND EXISTS(SELF\IfcConstraint.UserDefinedGrade));
+END_ENTITY;
+
+ENTITY IfcConstructionEquipmentResource
+ SUBTYPE OF (IfcConstructionResource);
+	PredefinedType : OPTIONAL IfcConstructionEquipmentResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcConstructionEquipmentResourceType
+ SUBTYPE OF (IfcConstructionResourceType);
+	PredefinedType : IfcConstructionEquipmentResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcConstructionEquipmentResourceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeResource.ResourceType));
+END_ENTITY;
+
+ENTITY IfcConstructionMaterialResource
+ SUBTYPE OF (IfcConstructionResource);
+	PredefinedType : OPTIONAL IfcConstructionMaterialResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcConstructionMaterialResourceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcConstructionMaterialResourceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcConstructionMaterialResourceType
+ SUBTYPE OF (IfcConstructionResourceType);
+	PredefinedType : IfcConstructionMaterialResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcConstructionMaterialResourceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcConstructionMaterialResourceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeResource.ResourceType));
+END_ENTITY;
+
+ENTITY IfcConstructionProductResource
+ SUBTYPE OF (IfcConstructionResource);
+	PredefinedType : OPTIONAL IfcConstructionProductResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcConstructionProductResourceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcConstructionProductResourceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcConstructionProductResourceType
+ SUBTYPE OF (IfcConstructionResourceType);
+	PredefinedType : IfcConstructionProductResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcConstructionProductResourceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcConstructionProductResourceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeResource.ResourceType));
+END_ENTITY;
+
+ENTITY IfcConstructionResource
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcConstructionEquipmentResource
+    ,IfcConstructionMaterialResource
+    ,IfcConstructionProductResource
+    ,IfcCrewResource
+    ,IfcLaborResource
+    ,IfcSubContractResource))
+ SUBTYPE OF (IfcResource);
+	Usage : OPTIONAL IfcResourceTime;
+	BaseCosts : OPTIONAL LIST [1:?] OF IfcAppliedValue;
+	BaseQuantity : OPTIONAL IfcPhysicalQuantity;
+END_ENTITY;
+
+ENTITY IfcConstructionResourceType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcConstructionEquipmentResourceType
+    ,IfcConstructionMaterialResourceType
+    ,IfcConstructionProductResourceType
+    ,IfcCrewResourceType
+    ,IfcLaborResourceType
+    ,IfcSubContractResourceType))
+ SUBTYPE OF (IfcTypeResource);
+	BaseCosts : OPTIONAL LIST [1:?] OF IfcAppliedValue;
+	BaseQuantity : OPTIONAL IfcPhysicalQuantity;
+END_ENTITY;
+
+ENTITY IfcContext
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcProject
+    ,IfcProjectLibrary))
+ SUBTYPE OF (IfcObjectDefinition);
+	ObjectType : OPTIONAL IfcLabel;
+	LongName : OPTIONAL IfcLabel;
+	Phase : OPTIONAL IfcLabel;
+	RepresentationContexts : OPTIONAL SET [1:?] OF IfcRepresentationContext;
+	UnitsInContext : OPTIONAL IfcUnitAssignment;
+ INVERSE
+	IsDefinedBy : SET [0:?] OF IfcRelDefinesByProperties FOR RelatedObjects;
+	Declares : SET [0:?] OF IfcRelDeclares FOR RelatingContext;
+END_ENTITY;
+
+ENTITY IfcContextDependentUnit
+ SUBTYPE OF (IfcNamedUnit);
+	Name : IfcLabel;
+ INVERSE
+	HasExternalReference : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+END_ENTITY;
+
+ENTITY IfcControl
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcActionRequest
+    ,IfcCostItem
+    ,IfcCostSchedule
+    ,IfcPerformanceHistory
+    ,IfcPermit
+    ,IfcProjectOrder
+    ,IfcWorkCalendar
+    ,IfcWorkControl))
+ SUBTYPE OF (IfcObject);
+	Identification : OPTIONAL IfcIdentifier;
+ INVERSE
+	Controls : SET [0:?] OF IfcRelAssignsToControl FOR RelatingControl;
+END_ENTITY;
+
+ENTITY IfcController
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcControllerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcControllerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcControllerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCCONTROLLERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcControllerType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcControllerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcControllerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcControllerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcConversionBasedUnit
+ SUPERTYPE OF (ONEOF
+    (IfcConversionBasedUnitWithOffset))
+ SUBTYPE OF (IfcNamedUnit);
+	Name : IfcLabel;
+	ConversionFactor : IfcMeasureWithUnit;
+ INVERSE
+	HasExternalReference : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+END_ENTITY;
+
+ENTITY IfcConversionBasedUnitWithOffset
+ SUBTYPE OF (IfcConversionBasedUnit);
+	ConversionOffset : IfcReal;
+END_ENTITY;
+
+ENTITY IfcCooledBeam
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcCooledBeamTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCooledBeamTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCooledBeamTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCOOLEDBEAMTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCooledBeamType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcCooledBeamTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCooledBeamTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCooledBeamTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCoolingTower
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcCoolingTowerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCoolingTowerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCoolingTowerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCCOOLINGTOWERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCoolingTowerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcCoolingTowerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCoolingTowerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCoolingTowerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCoordinateOperation
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcMapConversion));
+	SourceCRS : IfcCoordinateReferenceSystemSelect;
+	TargetCRS : IfcCoordinateReferenceSystem;
+END_ENTITY;
+
+ENTITY IfcCoordinateReferenceSystem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcProjectedCRS));
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	GeodeticDatum : OPTIONAL IfcIdentifier;
+	VerticalDatum : OPTIONAL IfcIdentifier;
+ INVERSE
+	HasCoordinateOperation : SET [0:1] OF IfcCoordinateOperation FOR SourceCRS;
+END_ENTITY;
+
+ENTITY IfcCostItem
+ SUBTYPE OF (IfcControl);
+	PredefinedType : OPTIONAL IfcCostItemTypeEnum;
+	CostValues : OPTIONAL LIST [1:?] OF IfcCostValue;
+	CostQuantities : OPTIONAL LIST [1:?] OF IfcPhysicalQuantity;
+END_ENTITY;
+
+ENTITY IfcCostSchedule
+ SUBTYPE OF (IfcControl);
+	PredefinedType : OPTIONAL IfcCostScheduleTypeEnum;
+	Status : OPTIONAL IfcLabel;
+	SubmittedOn : OPTIONAL IfcDateTime;
+	UpdateDate : OPTIONAL IfcDateTime;
+END_ENTITY;
+
+ENTITY IfcCostValue
+ SUBTYPE OF (IfcAppliedValue);
+END_ENTITY;
+
+ENTITY IfcCovering
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcCoveringTypeEnum;
+ INVERSE
+	CoversSpaces : SET [0:1] OF IfcRelCoversSpaces FOR RelatedCoverings;
+	CoversElements : SET [0:1] OF IfcRelCoversBldgElements FOR RelatedCoverings;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCoveringTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCoveringTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCCOVERINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCoveringType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcCoveringTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCoveringTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCoveringTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCrewResource
+ SUBTYPE OF (IfcConstructionResource);
+	PredefinedType : OPTIONAL IfcCrewResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcCrewResourceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcCrewResourceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcCrewResourceType
+ SUBTYPE OF (IfcConstructionResourceType);
+	PredefinedType : IfcCrewResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCrewResourceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCrewResourceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeResource.ResourceType));
+END_ENTITY;
+
+ENTITY IfcCsgPrimitive3D
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBlock
+    ,IfcRectangularPyramid
+    ,IfcRightCircularCone
+    ,IfcRightCircularCylinder
+    ,IfcSphere))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Position : IfcAxis2Placement3D;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcCsgSolid
+ SUBTYPE OF (IfcSolidModel);
+	TreeRootExpression : IfcCsgSelect;
+END_ENTITY;
+
+ENTITY IfcCurrencyRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingMonetaryUnit : IfcMonetaryUnit;
+	RelatedMonetaryUnit : IfcMonetaryUnit;
+	ExchangeRate : IfcPositiveRatioMeasure;
+	RateDateTime : OPTIONAL IfcDateTime;
+	RateSource : OPTIONAL IfcLibraryInformation;
+END_ENTITY;
+
+ENTITY IfcCurtainWall
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcCurtainWallTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcCurtainWallTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcCurtainWallTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCCURTAINWALLTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcCurtainWallType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcCurtainWallTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcCurtainWallTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcCurtainWallTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcCurve
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBoundedCurve
+    ,IfcConic
+    ,IfcLine
+    ,IfcOffsetCurve2D
+    ,IfcOffsetCurve3D
+    ,IfcPcurve
+    ,IfcSurfaceCurve))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+ DERIVE
+	Dim : IfcDimensionCount := IfcCurveDim(SELF);
+END_ENTITY;
+
+ENTITY IfcCurveBoundedPlane
+ SUBTYPE OF (IfcBoundedSurface);
+	BasisSurface : IfcPlane;
+	OuterBoundary : IfcCurve;
+	InnerBoundaries : SET [0:?] OF IfcCurve;
+END_ENTITY;
+
+ENTITY IfcCurveBoundedSurface
+ SUBTYPE OF (IfcBoundedSurface);
+	BasisSurface : IfcSurface;
+	Boundaries : SET [1:?] OF IfcBoundaryCurve;
+	ImplicitOuter : IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcCurveStyle
+ SUBTYPE OF (IfcPresentationStyle);
+	CurveFont : OPTIONAL IfcCurveFontOrScaledCurveFontSelect;
+	CurveWidth : OPTIONAL IfcSizeSelect;
+	CurveColour : OPTIONAL IfcColour;
+	ModelOrDraughting : OPTIONAL IfcBoolean;
+ WHERE
+	MeasureOfWidth : (NOT(EXISTS(CurveWidth))) OR
+('IFC4.IFCPOSITIVELENGTHMEASURE' IN TYPEOF(CurveWidth)) OR 
+ (('IFC4.IFCDESCRIPTIVEMEASURE' IN TYPEOF(CurveWidth)) AND
+ (CurveWidth = 'by layer'));
+	IdentifiableCurveStyle : EXISTS(CurveFont) OR EXISTS(CurveWidth) OR EXISTS(CurveColour);
+END_ENTITY;
+
+ENTITY IfcCurveStyleFont
+ SUBTYPE OF (IfcPresentationItem);
+	Name : OPTIONAL IfcLabel;
+	PatternList : LIST [1:?] OF IfcCurveStyleFontPattern;
+END_ENTITY;
+
+ENTITY IfcCurveStyleFontAndScaling
+ SUBTYPE OF (IfcPresentationItem);
+	Name : OPTIONAL IfcLabel;
+	CurveFont : IfcCurveStyleFontSelect;
+	CurveFontScaling : IfcPositiveRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcCurveStyleFontPattern
+ SUBTYPE OF (IfcPresentationItem);
+	VisibleSegmentLength : IfcLengthMeasure;
+	InvisibleSegmentLength : IfcPositiveLengthMeasure;
+ WHERE
+	VisibleLengthGreaterEqualZero : VisibleSegmentLength >= 0.;
+END_ENTITY;
+
+ENTITY IfcCylindricalSurface
+ SUBTYPE OF (IfcElementarySurface);
+	Radius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcDamper
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcDamperTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcDamperTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcDamperTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCDAMPERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDamperType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcDamperTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDamperTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDamperTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcDerivedProfileDef
+ SUPERTYPE OF (ONEOF
+    (IfcMirroredProfileDef))
+ SUBTYPE OF (IfcProfileDef);
+	ParentProfile : IfcProfileDef;
+	Operator : IfcCartesianTransformationOperator2D;
+	Label : OPTIONAL IfcLabel;
+ WHERE
+	InvariantProfileType : SELF\IfcProfileDef.ProfileType = ParentProfile.ProfileType;
+END_ENTITY;
+
+ENTITY IfcDerivedUnit;
+	Elements : SET [1:?] OF IfcDerivedUnitElement;
+	UnitType : IfcDerivedUnitEnum;
+	UserDefinedType : OPTIONAL IfcLabel;
+ DERIVE
+	Dimensions : IfcDimensionalExponents := IfcDeriveDimensionalExponents(Elements);
+ WHERE
+	WR1 : (SIZEOF (Elements) > 1) OR ((SIZEOF (Elements) = 1) AND (Elements[1].Exponent <> 1 ));
+	WR2 : (UnitType <> IfcDerivedUnitEnum.USERDEFINED) OR
+((UnitType = IfcDerivedUnitEnum.USERDEFINED) AND 
+ (EXISTS(SELF.UserDefinedType)));
+END_ENTITY;
+
+ENTITY IfcDerivedUnitElement;
+	Unit : IfcNamedUnit;
+	Exponent : INTEGER;
+END_ENTITY;
+
+ENTITY IfcDimensionalExponents;
+	LengthExponent : INTEGER;
+	MassExponent : INTEGER;
+	TimeExponent : INTEGER;
+	ElectricCurrentExponent : INTEGER;
+	ThermodynamicTemperatureExponent : INTEGER;
+	AmountOfSubstanceExponent : INTEGER;
+	LuminousIntensityExponent : INTEGER;
+END_ENTITY;
+
+ENTITY IfcDirection
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	DirectionRatios : LIST [2:3] OF IfcReal;
+ DERIVE
+	Dim : IfcDimensionCount := HIINDEX(DirectionRatios);
+ WHERE
+	MagnitudeGreaterZero : SIZEOF(QUERY(Tmp <* DirectionRatios | Tmp <> 0.0)) > 0;
+END_ENTITY;
+
+ENTITY IfcDiscreteAccessory
+ SUBTYPE OF (IfcElementComponent);
+	PredefinedType : OPTIONAL IfcDiscreteAccessoryTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+(PredefinedType <> IfcDiscreteAccessoryTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDiscreteAccessoryTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCDISCRETEACCESSORYTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDiscreteAccessoryType
+ SUBTYPE OF (IfcElementComponentType);
+	PredefinedType : IfcDiscreteAccessoryTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDiscreteAccessoryTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDiscreteAccessoryTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcDistributionChamberElement
+ SUBTYPE OF (IfcDistributionFlowElement);
+	PredefinedType : OPTIONAL IfcDistributionChamberElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcDistributionChamberElementTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcDistributionChamberElementTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCDISTRIBUTIONCHAMBERELEMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDistributionChamberElementType
+ SUBTYPE OF (IfcDistributionFlowElementType);
+	PredefinedType : IfcDistributionChamberElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDistributionChamberElementTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDistributionChamberElementTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcDistributionCircuit
+ SUBTYPE OF (IfcDistributionSystem);
+END_ENTITY;
+
+ENTITY IfcDistributionControlElement
+ SUPERTYPE OF (ONEOF
+    (IfcActuator
+    ,IfcAlarm
+    ,IfcController
+    ,IfcFlowInstrument
+    ,IfcProtectiveDeviceTrippingUnit
+    ,IfcSensor
+    ,IfcUnitaryControlElement))
+ SUBTYPE OF (IfcDistributionElement);
+ INVERSE
+	AssignedToFlowElement : SET [0:1] OF IfcRelFlowControlElements FOR RelatedControlElements;
+END_ENTITY;
+
+ENTITY IfcDistributionControlElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcActuatorType
+    ,IfcAlarmType
+    ,IfcControllerType
+    ,IfcFlowInstrumentType
+    ,IfcProtectiveDeviceTrippingUnitType
+    ,IfcSensorType
+    ,IfcUnitaryControlElementType))
+ SUBTYPE OF (IfcDistributionElementType);
+END_ENTITY;
+
+ENTITY IfcDistributionElement
+ SUPERTYPE OF (ONEOF
+    (IfcDistributionControlElement
+    ,IfcDistributionFlowElement))
+ SUBTYPE OF (IfcElement);
+ INVERSE
+	HasPorts : SET [0:?] OF IfcRelConnectsPortToElement FOR RelatedElement;
+END_ENTITY;
+
+ENTITY IfcDistributionElementType
+ SUPERTYPE OF (ONEOF
+    (IfcDistributionControlElementType
+    ,IfcDistributionFlowElementType))
+ SUBTYPE OF (IfcElementType);
+END_ENTITY;
+
+ENTITY IfcDistributionFlowElement
+ SUPERTYPE OF (ONEOF
+    (IfcDistributionChamberElement
+    ,IfcEnergyConversionDevice
+    ,IfcFlowController
+    ,IfcFlowFitting
+    ,IfcFlowMovingDevice
+    ,IfcFlowSegment
+    ,IfcFlowStorageDevice
+    ,IfcFlowTerminal
+    ,IfcFlowTreatmentDevice))
+ SUBTYPE OF (IfcDistributionElement);
+ INVERSE
+	HasControlElements : SET [0:1] OF IfcRelFlowControlElements FOR RelatingFlowElement;
+END_ENTITY;
+
+ENTITY IfcDistributionFlowElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcDistributionChamberElementType
+    ,IfcEnergyConversionDeviceType
+    ,IfcFlowControllerType
+    ,IfcFlowFittingType
+    ,IfcFlowMovingDeviceType
+    ,IfcFlowSegmentType
+    ,IfcFlowStorageDeviceType
+    ,IfcFlowTerminalType
+    ,IfcFlowTreatmentDeviceType))
+ SUBTYPE OF (IfcDistributionElementType);
+END_ENTITY;
+
+ENTITY IfcDistributionPort
+ SUBTYPE OF (IfcPort);
+	FlowDirection : OPTIONAL IfcFlowDirectionEnum;
+	PredefinedType : OPTIONAL IfcDistributionPortTypeEnum;
+	SystemType : OPTIONAL IfcDistributionSystemEnum;
+END_ENTITY;
+
+ENTITY IfcDistributionSystem
+ SUPERTYPE OF (ONEOF
+    (IfcDistributionCircuit))
+ SUBTYPE OF (IfcSystem);
+	LongName : OPTIONAL IfcLabel;
+	PredefinedType : OPTIONAL IfcDistributionSystemEnum;
+END_ENTITY;
+
+ENTITY IfcDocumentInformation
+ SUBTYPE OF (IfcExternalInformation);
+	Identification : IfcIdentifier;
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	Location : OPTIONAL IfcURIReference;
+	Purpose : OPTIONAL IfcText;
+	IntendedUse : OPTIONAL IfcText;
+	Scope : OPTIONAL IfcText;
+	Revision : OPTIONAL IfcLabel;
+	DocumentOwner : OPTIONAL IfcActorSelect;
+	Editors : OPTIONAL SET [1:?] OF IfcActorSelect;
+	CreationTime : OPTIONAL IfcDateTime;
+	LastRevisionTime : OPTIONAL IfcDateTime;
+	ElectronicFormat : OPTIONAL IfcIdentifier;
+	ValidFrom : OPTIONAL IfcDate;
+	ValidUntil : OPTIONAL IfcDate;
+	Confidentiality : OPTIONAL IfcDocumentConfidentialityEnum;
+	Status : OPTIONAL IfcDocumentStatusEnum;
+ INVERSE
+	DocumentInfoForObjects : SET [0:?] OF IfcRelAssociatesDocument FOR RelatingDocument;
+	HasDocumentReferences : SET [0:?] OF IfcDocumentReference FOR ReferencedDocument;
+	IsPointedTo : SET [0:?] OF IfcDocumentInformationRelationship FOR RelatedDocuments;
+	IsPointer : SET [0:1] OF IfcDocumentInformationRelationship FOR RelatingDocument;
+END_ENTITY;
+
+ENTITY IfcDocumentInformationRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingDocument : IfcDocumentInformation;
+	RelatedDocuments : SET [1:?] OF IfcDocumentInformation;
+	RelationshipType : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcDocumentReference
+ SUBTYPE OF (IfcExternalReference);
+	Description : OPTIONAL IfcText;
+	ReferencedDocument : OPTIONAL IfcDocumentInformation;
+ INVERSE
+	DocumentRefForObjects : SET [0:?] OF IfcRelAssociatesDocument FOR RelatingDocument;
+ WHERE
+	WR1 : EXISTS(Name) XOR EXISTS(ReferencedDocument);
+END_ENTITY;
+
+ENTITY IfcDoor
+ SUPERTYPE OF (ONEOF
+    (IfcDoorStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	OverallHeight : OPTIONAL IfcPositiveLengthMeasure;
+	OverallWidth : OPTIONAL IfcPositiveLengthMeasure;
+	PredefinedType : OPTIONAL IfcDoorTypeEnum;
+	OperationType : OPTIONAL IfcDoorTypeOperationEnum;
+	UserDefinedOperationType : OPTIONAL IfcLabel;
+ WHERE
+	CorrectStyleAssigned : (SIZEOF(IsTypedBy) = 0) 
+OR ('IFC4.IFCDOORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDoorLiningProperties
+ SUBTYPE OF (IfcPreDefinedPropertySet);
+	LiningDepth : OPTIONAL IfcPositiveLengthMeasure;
+	LiningThickness : OPTIONAL IfcNonNegativeLengthMeasure;
+	ThresholdDepth : OPTIONAL IfcPositiveLengthMeasure;
+	ThresholdThickness : OPTIONAL IfcNonNegativeLengthMeasure;
+	TransomThickness : OPTIONAL IfcNonNegativeLengthMeasure;
+	TransomOffset : OPTIONAL IfcLengthMeasure;
+	LiningOffset : OPTIONAL IfcLengthMeasure;
+	ThresholdOffset : OPTIONAL IfcLengthMeasure;
+	CasingThickness : OPTIONAL IfcPositiveLengthMeasure;
+	CasingDepth : OPTIONAL IfcPositiveLengthMeasure;
+	ShapeAspectStyle : OPTIONAL IfcShapeAspect;
+	LiningToPanelOffsetX : OPTIONAL IfcLengthMeasure;
+	LiningToPanelOffsetY : OPTIONAL IfcLengthMeasure;
+ WHERE
+	WR31 : NOT(EXISTS(LiningDepth) AND NOT(EXISTS(LiningThickness)));
+	WR32 : NOT(EXISTS(ThresholdDepth) AND NOT(EXISTS(ThresholdThickness)));
+	WR33 : (EXISTS(TransomOffset) AND EXISTS(TransomThickness)) XOR
+(NOT(EXISTS(TransomOffset)) AND NOT(EXISTS(TransomThickness)));
+	WR34 : (EXISTS(CasingDepth) AND EXISTS(CasingThickness)) XOR
+(NOT(EXISTS(CasingDepth)) AND NOT(EXISTS(CasingThickness)));
+	WR35 : (EXISTS(SELF\IfcPropertySetDefinition.DefinesType[1])) 
+AND 
+(
+ ('IFC4.IFCDOORTYPE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+  OR
+ ('IFC4.IFCDOORSTYLE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+);
+END_ENTITY;
+
+ENTITY IfcDoorPanelProperties
+ SUBTYPE OF (IfcPreDefinedPropertySet);
+	PanelDepth : OPTIONAL IfcPositiveLengthMeasure;
+	PanelOperation : IfcDoorPanelOperationEnum;
+	PanelWidth : OPTIONAL IfcNormalisedRatioMeasure;
+	PanelPosition : IfcDoorPanelPositionEnum;
+	ShapeAspectStyle : OPTIONAL IfcShapeAspect;
+ WHERE
+	ApplicableToType : (EXISTS(SELF\IfcPropertySetDefinition.DefinesType[1])) 
+AND 
+(
+ ('IFC4.IFCDOORTYPE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+  OR
+ ('IFC4.IFCDOORSTYLE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+);
+END_ENTITY;
+
+ENTITY IfcDoorStandardCase
+ SUBTYPE OF (IfcDoor);
+END_ENTITY;
+
+ENTITY IfcDoorStyle
+ SUBTYPE OF (IfcTypeProduct);
+	OperationType : IfcDoorStyleOperationEnum;
+	ConstructionType : IfcDoorStyleConstructionEnum;
+	ParameterTakesPrecedence : IfcBoolean;
+	Sizeable : IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcDoorType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcDoorTypeEnum;
+	OperationType : IfcDoorTypeOperationEnum;
+	ParameterTakesPrecedence : OPTIONAL IfcBoolean;
+	UserDefinedOperationType : OPTIONAL IfcLabel;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDoorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDoorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcDraughtingPreDefinedColour
+ SUBTYPE OF (IfcPreDefinedColour);
+ WHERE
+	PreDefinedColourNames : SELF\IfcPreDefinedItem.Name IN ['black','red','green','blue','yellow',
+     'magenta','cyan','white','by layer'];
+END_ENTITY;
+
+ENTITY IfcDraughtingPreDefinedCurveFont
+ SUBTYPE OF (IfcPreDefinedCurveFont);
+ WHERE
+	PreDefinedCurveFontNames : SELF\IfcPredefinedItem.Name IN
+       ['continuous',
+        'chain',
+        'chain double dash',
+        'dashed',
+        'dotted',
+        'by layer'];
+END_ENTITY;
+
+ENTITY IfcDuctFitting
+ SUBTYPE OF (IfcFlowFitting);
+	PredefinedType : OPTIONAL IfcDuctFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcDuctFittingTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcDuctFittingTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCDUCTFITTINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDuctFittingType
+ SUBTYPE OF (IfcFlowFittingType);
+	PredefinedType : IfcDuctFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDuctFittingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDuctFittingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcDuctSegment
+ SUBTYPE OF (IfcFlowSegment);
+	PredefinedType : OPTIONAL IfcDuctSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcDuctSegmentTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcDuctSegmentTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCDUCTSEGMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDuctSegmentType
+ SUBTYPE OF (IfcFlowSegmentType);
+	PredefinedType : IfcDuctSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDuctSegmentTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDuctSegmentTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcDuctSilencer
+ SUBTYPE OF (IfcFlowTreatmentDevice);
+	PredefinedType : OPTIONAL IfcDuctSilencerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcDuctSilencerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcDuctSilencerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCDUCTSILENCERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcDuctSilencerType
+ SUBTYPE OF (IfcFlowTreatmentDeviceType);
+	PredefinedType : IfcDuctSilencerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcDuctSilencerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcDuctSilencerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcEdge
+ SUPERTYPE OF (ONEOF
+    (IfcEdgeCurve
+    ,IfcOrientedEdge
+    ,IfcSubedge))
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+	EdgeStart : IfcVertex;
+	EdgeEnd : IfcVertex;
+END_ENTITY;
+
+ENTITY IfcEdgeCurve
+ SUBTYPE OF (IfcEdge);
+	EdgeGeometry : IfcCurve;
+	SameSense : IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcEdgeLoop
+ SUBTYPE OF (IfcLoop);
+	EdgeList : LIST [1:?] OF IfcOrientedEdge;
+ DERIVE
+	Ne : IfcInteger := SIZEOF(EdgeList);
+ WHERE
+	IsClosed : (EdgeList[1].EdgeStart) :=: (EdgeList[Ne].EdgeEnd);
+	IsContinuous : IfcLoopHeadToTail(SELF);
+END_ENTITY;
+
+ENTITY IfcElectricAppliance
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcElectricApplianceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcElectricApplianceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcElectricApplianceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCELECTRICAPPLIANCETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElectricApplianceType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcElectricApplianceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElectricApplianceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcElectricApplianceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElectricDistributionBoard
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcElectricDistributionBoardTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcElectricDistributionBoardTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcElectricDistributionBoardTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCELECTRICDISTRIBUTIONBOARDTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElectricDistributionBoardType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcElectricDistributionBoardTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElectricDistributionBoardTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcElectricDistributionBoardTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElectricFlowStorageDevice
+ SUBTYPE OF (IfcFlowStorageDevice);
+	PredefinedType : OPTIONAL IfcElectricFlowStorageDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCELECTRICFLOWSTORAGEDEVICETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElectricFlowStorageDeviceType
+ SUBTYPE OF (IfcFlowStorageDeviceType);
+	PredefinedType : IfcElectricFlowStorageDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElectricGenerator
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcElectricGeneratorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcElectricGeneratorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcElectricGeneratorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCELECTRICGENERATORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElectricGeneratorType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcElectricGeneratorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElectricGeneratorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcElectricGeneratorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElectricMotor
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcElectricMotorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcElectricMotorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcElectricMotorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCELECTRICMOTORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElectricMotorType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcElectricMotorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElectricMotorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcElectricMotorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElectricTimeControl
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcElectricTimeControlTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcElectricTimeControlTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcElectricTimeControlTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCELECTRICTIMECONTROLTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElectricTimeControlType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcElectricTimeControlTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElectricTimeControlTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcElectricTimeControlTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBuildingElement
+    ,IfcCivilElement
+    ,IfcDistributionElement
+    ,IfcElementAssembly
+    ,IfcElementComponent
+    ,IfcFeatureElement
+    ,IfcFurnishingElement
+    ,IfcGeographicElement
+    ,IfcTransportElement
+    ,IfcVirtualElement))
+ SUBTYPE OF (IfcProduct);
+	Tag : OPTIONAL IfcIdentifier;
+ INVERSE
+	FillsVoids : SET [0:1] OF IfcRelFillsElement FOR RelatedBuildingElement;
+	ConnectedTo : SET [0:?] OF IfcRelConnectsElements FOR RelatingElement;
+	IsInterferedByElements : SET [0:?] OF IfcRelInterferesElements FOR RelatedElement;
+	InterferesElements : SET [0:?] OF IfcRelInterferesElements FOR RelatingElement;
+	HasProjections : SET [0:?] OF IfcRelProjectsElement FOR RelatingElement;
+	ReferencedInStructures : SET [0:?] OF IfcRelReferencedInSpatialStructure FOR RelatedElements;
+	HasOpenings : SET [0:?] OF IfcRelVoidsElement FOR RelatingBuildingElement;
+	IsConnectionRealization : SET [0:?] OF IfcRelConnectsWithRealizingElements FOR RealizingElements;
+	ProvidesBoundaries : SET [0:?] OF IfcRelSpaceBoundary FOR RelatedBuildingElement;
+	ConnectedFrom : SET [0:?] OF IfcRelConnectsElements FOR RelatedElement;
+	ContainedInStructure : SET [0:1] OF IfcRelContainedInSpatialStructure FOR RelatedElements;
+	HasCoverings : SET [0:?] OF IfcRelCoversBldgElements FOR RelatingBuildingElement;
+END_ENTITY;
+
+ENTITY IfcElementAssembly
+ SUBTYPE OF (IfcElement);
+	AssemblyPlace : OPTIONAL IfcAssemblyPlaceEnum;
+	PredefinedType : OPTIONAL IfcElementAssemblyTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcElementAssemblyTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcElementAssemblyTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCELEMENTASSEMBLYTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcElementAssemblyType
+ SUBTYPE OF (IfcElementType);
+	PredefinedType : IfcElementAssemblyTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcElementAssemblyTypeEnum.USERDEFINED) OR 
+((PredefinedType = IfcElementAssemblyTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcElementComponent
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBuildingElementPart
+    ,IfcDiscreteAccessory
+    ,IfcFastener
+    ,IfcMechanicalFastener
+    ,IfcReinforcingElement
+    ,IfcVibrationIsolator))
+ SUBTYPE OF (IfcElement);
+END_ENTITY;
+
+ENTITY IfcElementComponentType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBuildingElementPartType
+    ,IfcDiscreteAccessoryType
+    ,IfcFastenerType
+    ,IfcMechanicalFastenerType
+    ,IfcReinforcingElementType
+    ,IfcVibrationIsolatorType))
+ SUBTYPE OF (IfcElementType);
+END_ENTITY;
+
+ENTITY IfcElementQuantity
+ SUBTYPE OF (IfcQuantitySet);
+	MethodOfMeasurement : OPTIONAL IfcLabel;
+	Quantities : SET [1:?] OF IfcPhysicalQuantity;
+ WHERE
+	UniqueQuantityNames : IfcUniqueQuantityNames(Quantities);
+END_ENTITY;
+
+ENTITY IfcElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBuildingElementType
+    ,IfcCivilElementType
+    ,IfcDistributionElementType
+    ,IfcElementAssemblyType
+    ,IfcElementComponentType
+    ,IfcFurnishingElementType
+    ,IfcGeographicElementType
+    ,IfcTransportElementType))
+ SUBTYPE OF (IfcTypeProduct);
+	ElementType : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcElementarySurface
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCylindricalSurface
+    ,IfcPlane
+    ,IfcSphericalSurface
+    ,IfcToroidalSurface))
+ SUBTYPE OF (IfcSurface);
+	Position : IfcAxis2Placement3D;
+END_ENTITY;
+
+ENTITY IfcEllipse
+ SUBTYPE OF (IfcConic);
+	SemiAxis1 : IfcPositiveLengthMeasure;
+	SemiAxis2 : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcEllipseProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	SemiAxis1 : IfcPositiveLengthMeasure;
+	SemiAxis2 : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcEnergyConversionDevice
+ SUPERTYPE OF (ONEOF
+    (IfcAirToAirHeatRecovery
+    ,IfcBoiler
+    ,IfcBurner
+    ,IfcChiller
+    ,IfcCoil
+    ,IfcCondenser
+    ,IfcCooledBeam
+    ,IfcCoolingTower
+    ,IfcElectricGenerator
+    ,IfcElectricMotor
+    ,IfcEngine
+    ,IfcEvaporativeCooler
+    ,IfcEvaporator
+    ,IfcHeatExchanger
+    ,IfcHumidifier
+    ,IfcMotorConnection
+    ,IfcSolarDevice
+    ,IfcTransformer
+    ,IfcTubeBundle
+    ,IfcUnitaryEquipment))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcEnergyConversionDeviceType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAirToAirHeatRecoveryType
+    ,IfcBoilerType
+    ,IfcBurnerType
+    ,IfcChillerType
+    ,IfcCoilType
+    ,IfcCondenserType
+    ,IfcCooledBeamType
+    ,IfcCoolingTowerType
+    ,IfcElectricGeneratorType
+    ,IfcElectricMotorType
+    ,IfcEngineType
+    ,IfcEvaporativeCoolerType
+    ,IfcEvaporatorType
+    ,IfcHeatExchangerType
+    ,IfcHumidifierType
+    ,IfcMotorConnectionType
+    ,IfcSolarDeviceType
+    ,IfcTransformerType
+    ,IfcTubeBundleType
+    ,IfcUnitaryEquipmentType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcEngine
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcEngineTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcEngineTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcEngineTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCENGINETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcEngineType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcEngineTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcEngineTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcEngineTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcEvaporativeCooler
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcEvaporativeCoolerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcEvaporativeCoolerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcEvaporativeCoolerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCEVAPORATIVECOOLERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcEvaporativeCoolerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcEvaporativeCoolerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcEvaporativeCoolerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcEvaporativeCoolerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcEvaporator
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcEvaporatorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcEvaporatorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcEvaporatorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCEVAPORATORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcEvaporatorType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcEvaporatorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcEvaporatorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcEvaporatorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcEvent
+ SUBTYPE OF (IfcProcess);
+	PredefinedType : OPTIONAL IfcEventTypeEnum;
+	EventTriggerType : OPTIONAL IfcEventTriggerTypeEnum;
+	UserDefinedEventTriggerType : OPTIONAL IfcLabel;
+	EventOccurenceTime : OPTIONAL IfcEventTime;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR (PredefinedType <> IfcEventTypeEnum.USERDEFINED) OR ((PredefinedType = IfcEventTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : NOT(EXISTS(EventTriggerType)) OR (EventTriggerType <> IfcEventTriggerTypeEnum.USERDEFINED) OR ((EventTriggerType = IfcEventTriggerTypeEnum.USERDEFINED) AND EXISTS(UserDefinedEventTriggerType));
+END_ENTITY;
+
+ENTITY IfcEventTime
+ SUBTYPE OF (IfcSchedulingTime);
+	ActualDate : OPTIONAL IfcDateTime;
+	EarlyDate : OPTIONAL IfcDateTime;
+	LateDate : OPTIONAL IfcDateTime;
+	ScheduleDate : OPTIONAL IfcDateTime;
+END_ENTITY;
+
+ENTITY IfcEventType
+ SUBTYPE OF (IfcTypeProcess);
+	PredefinedType : IfcEventTypeEnum;
+	EventTriggerType : IfcEventTriggerTypeEnum;
+	UserDefinedEventTriggerType : OPTIONAL IfcLabel;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcEventTypeEnum.USERDEFINED) OR ((PredefinedType = IfcEventTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeProcess.ProcessType));
+	CorrectEventTriggerType : (EventTriggerType <> IfcEventTriggerTypeEnum.USERDEFINED) OR ((EventTriggerType = IfcEventTriggerTypeEnum.USERDEFINED) AND EXISTS(UserDefinedEventTriggerType));
+END_ENTITY;
+
+ENTITY IfcExtendedProperties
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcMaterialProperties
+    ,IfcProfileProperties))
+ SUBTYPE OF (IfcPropertyAbstraction);
+	Name : OPTIONAL IfcIdentifier;
+	Description : OPTIONAL IfcText;
+	Properties : SET [1:?] OF IfcProperty;
+END_ENTITY;
+
+ENTITY IfcExternalInformation
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcClassification
+    ,IfcDocumentInformation
+    ,IfcLibraryInformation));
+END_ENTITY;
+
+ENTITY IfcExternalReference
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcClassificationReference
+    ,IfcDocumentReference
+    ,IfcExternallyDefinedHatchStyle
+    ,IfcExternallyDefinedSurfaceStyle
+    ,IfcExternallyDefinedTextFont
+    ,IfcLibraryReference));
+	Location : OPTIONAL IfcURIReference;
+	Identification : OPTIONAL IfcIdentifier;
+	Name : OPTIONAL IfcLabel;
+ INVERSE
+	ExternalReferenceForResources : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatingReference;
+ WHERE
+	WR1 : EXISTS(Identification) OR EXISTS(Location) OR EXISTS(Name);
+END_ENTITY;
+
+ENTITY IfcExternalReferenceRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingReference : IfcExternalReference;
+	RelatedResourceObjects : SET [1:?] OF IfcResourceObjectSelect;
+END_ENTITY;
+
+ENTITY IfcExternalSpatialElement
+ SUBTYPE OF (IfcExternalSpatialStructureElement);
+	PredefinedType : OPTIONAL IfcExternalSpatialElementTypeEnum;
+ INVERSE
+	BoundedBy : SET [0:?] OF IfcRelSpaceBoundary FOR RelatingSpace;
+END_ENTITY;
+
+ENTITY IfcExternalSpatialStructureElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcExternalSpatialElement))
+ SUBTYPE OF (IfcSpatialElement);
+END_ENTITY;
+
+ENTITY IfcExternallyDefinedHatchStyle
+ SUBTYPE OF (IfcExternalReference);
+END_ENTITY;
+
+ENTITY IfcExternallyDefinedSurfaceStyle
+ SUBTYPE OF (IfcExternalReference);
+END_ENTITY;
+
+ENTITY IfcExternallyDefinedTextFont
+ SUBTYPE OF (IfcExternalReference);
+END_ENTITY;
+
+ENTITY IfcExtrudedAreaSolid
+ SUPERTYPE OF (ONEOF
+    (IfcExtrudedAreaSolidTapered))
+ SUBTYPE OF (IfcSweptAreaSolid);
+	ExtrudedDirection : IfcDirection;
+	Depth : IfcPositiveLengthMeasure;
+ WHERE
+	ValidExtrusionDirection : IfcDotProduct(IfcRepresentationItem() || IfcGeometricRepresentationItem() || IfcDirection([0.0,0.0,1.0]), SELF.ExtrudedDirection) <> 0.0;
+END_ENTITY;
+
+ENTITY IfcExtrudedAreaSolidTapered
+ SUBTYPE OF (IfcExtrudedAreaSolid);
+	EndSweptArea : IfcProfileDef;
+ WHERE
+	CorrectProfileAssignment : IfcTaperedSweptAreaProfiles(SELF\IfcSweptAreaSolid.SweptArea, SELF.EndSweptArea);
+END_ENTITY;
+
+ENTITY IfcFace
+ SUPERTYPE OF (ONEOF
+    (IfcFaceSurface))
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+	Bounds : SET [1:?] OF IfcFaceBound;
+ INVERSE
+	HasTextureMaps : SET [0:?] OF IfcTextureMap FOR MappedTo;
+ WHERE
+	HasOuterBound : SIZEOF(QUERY(temp <* Bounds | 'IFC4.IFCFACEOUTERBOUND' IN TYPEOF(temp))) <= 1;
+END_ENTITY;
+
+ENTITY IfcFaceBasedSurfaceModel
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	FbsmFaces : SET [1:?] OF IfcConnectedFaceSet;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcFaceBound
+ SUPERTYPE OF (ONEOF
+    (IfcFaceOuterBound))
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+	Bound : IfcLoop;
+	Orientation : IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcFaceOuterBound
+ SUBTYPE OF (IfcFaceBound);
+END_ENTITY;
+
+ENTITY IfcFaceSurface
+ SUPERTYPE OF (ONEOF
+    (IfcAdvancedFace))
+ SUBTYPE OF (IfcFace);
+	FaceSurface : IfcSurface;
+	SameSense : IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcFacetedBrep
+ SUPERTYPE OF (ONEOF
+    (IfcFacetedBrepWithVoids))
+ SUBTYPE OF (IfcManifoldSolidBrep);
+END_ENTITY;
+
+ENTITY IfcFacetedBrepWithVoids
+ SUBTYPE OF (IfcFacetedBrep);
+	Voids : SET [1:?] OF IfcClosedShell;
+END_ENTITY;
+
+ENTITY IfcFailureConnectionCondition
+ SUBTYPE OF (IfcStructuralConnectionCondition);
+	TensionFailureX : OPTIONAL IfcForceMeasure;
+	TensionFailureY : OPTIONAL IfcForceMeasure;
+	TensionFailureZ : OPTIONAL IfcForceMeasure;
+	CompressionFailureX : OPTIONAL IfcForceMeasure;
+	CompressionFailureY : OPTIONAL IfcForceMeasure;
+	CompressionFailureZ : OPTIONAL IfcForceMeasure;
+END_ENTITY;
+
+ENTITY IfcFan
+ SUBTYPE OF (IfcFlowMovingDevice);
+	PredefinedType : OPTIONAL IfcFanTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcFanTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcFanTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCFANTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFanType
+ SUBTYPE OF (IfcFlowMovingDeviceType);
+	PredefinedType : IfcFanTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFanTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFanTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFastener
+ SUBTYPE OF (IfcElementComponent);
+	PredefinedType : OPTIONAL IfcFastenerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+(PredefinedType <> IfcFastenerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFastenerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCFASTENERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFastenerType
+ SUBTYPE OF (IfcElementComponentType);
+	PredefinedType : IfcFastenerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFastenerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFastenerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFeatureElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcFeatureElementAddition
+    ,IfcFeatureElementSubtraction
+    ,IfcSurfaceFeature))
+ SUBTYPE OF (IfcElement);
+END_ENTITY;
+
+ENTITY IfcFeatureElementAddition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcProjectionElement))
+ SUBTYPE OF (IfcFeatureElement);
+ INVERSE
+	ProjectsElements : IfcRelProjectsElement FOR RelatedFeatureElement;
+END_ENTITY;
+
+ENTITY IfcFeatureElementSubtraction
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcOpeningElement
+    ,IfcVoidingFeature))
+ SUBTYPE OF (IfcFeatureElement);
+ INVERSE
+	VoidsElements : IfcRelVoidsElement FOR RelatedOpeningElement;
+ WHERE
+	HasNoSubtraction : SIZEOF(SELF\IfcElement.HasOpenings) = 0;
+	IsNotFilling : SIZEOF(SELF\IfcElement.FillsVoids) = 0;
+END_ENTITY;
+
+ENTITY IfcFillAreaStyle
+ SUBTYPE OF (IfcPresentationStyle);
+	FillStyles : SET [1:?] OF IfcFillStyleSelect;
+	ModelorDraughting : OPTIONAL IfcBoolean;
+ WHERE
+	MaxOneColour : SIZEOF(QUERY(Style <* SELF.FillStyles |
+  'IFC4.IFCCOLOUR' IN
+   TYPEOF(Style)
+  )) <= 1;
+	MaxOneExtHatchStyle : SIZEOF(QUERY(Style <* SELF.FillStyles |
+  'IFC4.IFCEXTERNALLYDEFINEDHATCHSTYLE' IN
+   TYPEOF(Style)
+  )) <= 1;
+	ConsistentHatchStyleDef : IfcCorrectFillAreaStyle(SELF.FillStyles);
+END_ENTITY;
+
+ENTITY IfcFillAreaStyleHatching
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	HatchLineAppearance : IfcCurveStyle;
+	StartOfNextHatchLine : IfcHatchLineDistanceSelect;
+	PointOfReferenceHatchLine : OPTIONAL IfcCartesianPoint;
+	PatternStart : OPTIONAL IfcCartesianPoint;
+	HatchLineAngle : IfcPlaneAngleMeasure;
+ WHERE
+	PatternStart2D : NOT(EXISTS(PatternStart)) OR (PatternStart.Dim = 2);
+	RefHatchLine2D : NOT(EXISTS(PointOfReferenceHatchLine)) OR (PointOfReferenceHatchLine.Dim = 2);
+END_ENTITY;
+
+ENTITY IfcFillAreaStyleTiles
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	TilingPattern : LIST [2:2] OF IfcVector;
+	Tiles : SET [1:?] OF IfcStyledItem;
+	TilingScale : IfcPositiveRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcFilter
+ SUBTYPE OF (IfcFlowTreatmentDevice);
+	PredefinedType : OPTIONAL IfcFilterTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcFilterTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcFilterTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCFILTERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFilterType
+ SUBTYPE OF (IfcFlowTreatmentDeviceType);
+	PredefinedType : IfcFilterTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFilterTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFilterTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFireSuppressionTerminal
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcFireSuppressionTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcFireSuppressionTerminalTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcFireSuppressionTerminalTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCFIRESUPPRESSIONTERMINALTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFireSuppressionTerminalType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcFireSuppressionTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFireSuppressionTerminalTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFireSuppressionTerminalTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFixedReferenceSweptAreaSolid
+ SUBTYPE OF (IfcSweptAreaSolid);
+	Directrix : IfcCurve;
+	StartParam : OPTIONAL IfcParameterValue;
+	EndParam : OPTIONAL IfcParameterValue;
+	FixedReference : IfcDirection;
+ WHERE
+	DirectrixBounded : (EXISTS(StartParam) AND EXISTS(EndParam)) OR 
+(SIZEOF(['IFC4.IFCCONIC', 'IFC4.IFCBOUNDEDCURVE'] * TYPEOF(Directrix)) = 1);
+END_ENTITY;
+
+ENTITY IfcFlowController
+ SUPERTYPE OF (ONEOF
+    (IfcAirTerminalBox
+    ,IfcDamper
+    ,IfcElectricDistributionBoard
+    ,IfcElectricTimeControl
+    ,IfcFlowMeter
+    ,IfcProtectiveDevice
+    ,IfcSwitchingDevice
+    ,IfcValve))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowControllerType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAirTerminalBoxType
+    ,IfcDamperType
+    ,IfcElectricDistributionBoardType
+    ,IfcElectricTimeControlType
+    ,IfcFlowMeterType
+    ,IfcProtectiveDeviceType
+    ,IfcSwitchingDeviceType
+    ,IfcValveType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFlowFitting
+ SUPERTYPE OF (ONEOF
+    (IfcCableCarrierFitting
+    ,IfcCableFitting
+    ,IfcDuctFitting
+    ,IfcJunctionBox
+    ,IfcPipeFitting))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowFittingType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCableCarrierFittingType
+    ,IfcCableFittingType
+    ,IfcDuctFittingType
+    ,IfcJunctionBoxType
+    ,IfcPipeFittingType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFlowInstrument
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcFlowInstrumentTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcFlowInstrumentTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcFlowInstrumentTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCFLOWINSTRUMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFlowInstrumentType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcFlowInstrumentTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFlowInstrumentTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFlowInstrumentTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFlowMeter
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcFlowMeterTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcFlowMeterTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcFlowMeterTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCFLOWMETERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFlowMeterType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcFlowMeterTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFlowMeterTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFlowMeterTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFlowMovingDevice
+ SUPERTYPE OF (ONEOF
+    (IfcCompressor
+    ,IfcFan
+    ,IfcPump))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowMovingDeviceType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCompressorType
+    ,IfcFanType
+    ,IfcPumpType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFlowSegment
+ SUPERTYPE OF (ONEOF
+    (IfcCableCarrierSegment
+    ,IfcCableSegment
+    ,IfcDuctSegment
+    ,IfcPipeSegment))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowSegmentType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCableCarrierSegmentType
+    ,IfcCableSegmentType
+    ,IfcDuctSegmentType
+    ,IfcPipeSegmentType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFlowStorageDevice
+ SUPERTYPE OF (ONEOF
+    (IfcElectricFlowStorageDevice
+    ,IfcTank))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowStorageDeviceType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcElectricFlowStorageDeviceType
+    ,IfcTankType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFlowTerminal
+ SUPERTYPE OF (ONEOF
+    (IfcAirTerminal
+    ,IfcAudioVisualAppliance
+    ,IfcCommunicationsAppliance
+    ,IfcElectricAppliance
+    ,IfcFireSuppressionTerminal
+    ,IfcLamp
+    ,IfcLightFixture
+    ,IfcMedicalDevice
+    ,IfcOutlet
+    ,IfcSanitaryTerminal
+    ,IfcSpaceHeater
+    ,IfcStackTerminal
+    ,IfcWasteTerminal))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowTerminalType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAirTerminalType
+    ,IfcAudioVisualApplianceType
+    ,IfcCommunicationsApplianceType
+    ,IfcElectricApplianceType
+    ,IfcFireSuppressionTerminalType
+    ,IfcLampType
+    ,IfcLightFixtureType
+    ,IfcMedicalDeviceType
+    ,IfcOutletType
+    ,IfcSanitaryTerminalType
+    ,IfcSpaceHeaterType
+    ,IfcStackTerminalType
+    ,IfcWasteTerminalType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFlowTreatmentDevice
+ SUPERTYPE OF (ONEOF
+    (IfcDuctSilencer
+    ,IfcFilter
+    ,IfcInterceptor))
+ SUBTYPE OF (IfcDistributionFlowElement);
+END_ENTITY;
+
+ENTITY IfcFlowTreatmentDeviceType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcDuctSilencerType
+    ,IfcFilterType
+    ,IfcInterceptorType))
+ SUBTYPE OF (IfcDistributionFlowElementType);
+END_ENTITY;
+
+ENTITY IfcFooting
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcFootingTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT EXISTS(PredefinedType) OR
+(PredefinedType <> IfcFootingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFootingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCFOOTINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFootingType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcFootingTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFootingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFootingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcFurnishingElement
+ SUPERTYPE OF (ONEOF
+    (IfcFurniture
+    ,IfcSystemFurnitureElement))
+ SUBTYPE OF (IfcElement);
+END_ENTITY;
+
+ENTITY IfcFurnishingElementType
+ SUPERTYPE OF (ONEOF
+    (IfcFurnitureType
+    ,IfcSystemFurnitureElementType))
+ SUBTYPE OF (IfcElementType);
+END_ENTITY;
+
+ENTITY IfcFurniture
+ SUBTYPE OF (IfcFurnishingElement);
+	PredefinedType : OPTIONAL IfcFurnitureTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcFurnitureTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcFurnitureTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+   ('IFC4.IFCFURNITURETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcFurnitureType
+ SUBTYPE OF (IfcFurnishingElementType);
+	AssemblyPlace : IfcAssemblyPlaceEnum;
+	PredefinedType : OPTIONAL IfcFurnitureTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcFurnitureTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcFurnitureTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcGeographicElement
+ SUBTYPE OF (IfcElement);
+	PredefinedType : OPTIONAL IfcGeographicElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcGeographicElementTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcGeographicElementTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCGEOGRAPHICELEMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcGeographicElementType
+ SUBTYPE OF (IfcElementType);
+	PredefinedType : IfcGeographicElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcGeographicElementTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcGeographicElementTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcGeometricCurveSet
+ SUBTYPE OF (IfcGeometricSet);
+ WHERE
+	NoSurfaces : SIZEOF(QUERY(Temp <* SELF\IfcGeometricSet.Elements |
+'IFC4.IFCSURFACE' IN TYPEOF(Temp))) = 0;
+END_ENTITY;
+
+ENTITY IfcGeometricRepresentationContext
+ SUPERTYPE OF (ONEOF
+    (IfcGeometricRepresentationSubContext))
+ SUBTYPE OF (IfcRepresentationContext);
+	CoordinateSpaceDimension : IfcDimensionCount;
+	Precision : OPTIONAL IfcReal;
+	WorldCoordinateSystem : IfcAxis2Placement;
+	TrueNorth : OPTIONAL IfcDirection;
+ INVERSE
+	HasSubContexts : SET [0:?] OF IfcGeometricRepresentationSubContext FOR ParentContext;
+	HasCoordinateOperation : SET [0:1] OF IfcCoordinateOperation FOR SourceCRS;
+ WHERE
+	North2D : NOT(EXISTS(TrueNorth)) OR (HIINDEX(TrueNorth.DirectionRatios) = 2);
+END_ENTITY;
+
+ENTITY IfcGeometricRepresentationItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAnnotationFillArea
+    ,IfcBooleanResult
+    ,IfcBoundingBox
+    ,IfcCartesianPointList
+    ,IfcCartesianTransformationOperator
+    ,IfcCompositeCurveSegment
+    ,IfcCsgPrimitive3D
+    ,IfcCurve
+    ,IfcDirection
+    ,IfcFaceBasedSurfaceModel
+    ,IfcFillAreaStyleHatching
+    ,IfcFillAreaStyleTiles
+    ,IfcGeometricSet
+    ,IfcHalfSpaceSolid
+    ,IfcLightSource
+    ,IfcPlacement
+    ,IfcPlanarExtent
+    ,IfcPoint
+    ,IfcSectionedSpine
+    ,IfcShellBasedSurfaceModel
+    ,IfcSolidModel
+    ,IfcSurface
+    ,IfcTessellatedItem
+    ,IfcTextLiteral
+    ,IfcVector))
+ SUBTYPE OF (IfcRepresentationItem);
+END_ENTITY;
+
+ENTITY IfcGeometricRepresentationSubContext
+ SUBTYPE OF (IfcGeometricRepresentationContext);
+	ParentContext : IfcGeometricRepresentationContext;
+	TargetScale : OPTIONAL IfcPositiveRatioMeasure;
+	TargetView : IfcGeometricProjectionEnum;
+	UserDefinedTargetView : OPTIONAL IfcLabel;
+ DERIVE
+	SELF\IfcGeometricRepresentationContext.WorldCoordinateSystem : IfcAxis2Placement := ParentContext.WorldCoordinateSystem;
+	SELF\IfcGeometricRepresentationContext.CoordinateSpaceDimension : IfcDimensionCount := ParentContext.CoordinateSpaceDimension;
+	SELF\IfcGeometricRepresentationContext.TrueNorth : IfcDirection := NVL(ParentContext.TrueNorth, IfcConvertDirectionInto2D(SELF\IfcGeometricRepresentationContext.WorldCoordinateSystem.P[2]));
+	SELF\IfcGeometricRepresentationContext.Precision : IfcReal := NVL(ParentContext.Precision,1.E-5);
+ WHERE
+	ParentNoSub : NOT('IFC4.IFCGEOMETRICREPRESENTATIONSUBCONTEXT' IN TYPEOF(ParentContext));
+	UserTargetProvided : (TargetView <> IfcGeometricProjectionEnum.USERDEFINED) OR 
+((TargetView =  IfcGeometricProjectionEnum.USERDEFINED) AND EXISTS(UserDefinedTargetView));
+	NoCoordOperation : SIZEOF(SELF\IfcGeometricRepresentationContext.HasCoordinateOperation) = 0;
+END_ENTITY;
+
+ENTITY IfcGeometricSet
+ SUPERTYPE OF (ONEOF
+    (IfcGeometricCurveSet))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Elements : SET [1:?] OF IfcGeometricSetSelect;
+ DERIVE
+	Dim : IfcDimensionCount := Elements[1].Dim;
+ WHERE
+	ConsistentDim : SIZEOF(QUERY(Temp <* Elements |
+  Temp.Dim <> Elements[1].Dim))
+= 0;
+END_ENTITY;
+
+ENTITY IfcGrid
+ SUBTYPE OF (IfcProduct);
+	UAxes : LIST [1:?] OF UNIQUE IfcGridAxis;
+	VAxes : LIST [1:?] OF UNIQUE IfcGridAxis;
+	WAxes : OPTIONAL LIST [1:?] OF UNIQUE IfcGridAxis;
+	PredefinedType : OPTIONAL IfcGridTypeEnum;
+ INVERSE
+	ContainedInStructure : SET [0:1] OF IfcRelContainedInSpatialStructure FOR RelatedElements;
+ WHERE
+	HasPlacement : EXISTS(SELF\IfcProduct.ObjectPlacement);
+END_ENTITY;
+
+ENTITY IfcGridAxis;
+	AxisTag : OPTIONAL IfcLabel;
+	AxisCurve : IfcCurve;
+	SameSense : IfcBoolean;
+ INVERSE
+	PartOfW : SET [0:1] OF IfcGrid FOR WAxes;
+	PartOfV : SET [0:1] OF IfcGrid FOR VAxes;
+	PartOfU : SET [0:1] OF IfcGrid FOR UAxes;
+	HasIntersections : SET [0:?] OF IfcVirtualGridIntersection FOR IntersectingAxes;
+ WHERE
+	WR1 : AxisCurve.Dim = 2;
+	WR2 : (SIZEOF(PartOfU) = 1) XOR (SIZEOF(PartOfV) = 1) XOR (SIZEOF(PartOfW) = 1);
+END_ENTITY;
+
+ENTITY IfcGridPlacement
+ SUBTYPE OF (IfcObjectPlacement);
+	PlacementLocation : IfcVirtualGridIntersection;
+	PlacementRefDirection : OPTIONAL IfcGridPlacementDirectionSelect;
+END_ENTITY;
+
+ENTITY IfcGroup
+ SUPERTYPE OF (ONEOF
+    (IfcAsset
+    ,IfcInventory
+    ,IfcStructuralLoadGroup
+    ,IfcStructuralResultGroup
+    ,IfcSystem))
+ SUBTYPE OF (IfcObject);
+ INVERSE
+	IsGroupedBy : SET [0:?] OF IfcRelAssignsToGroup FOR RelatingGroup;
+END_ENTITY;
+
+ENTITY IfcHalfSpaceSolid
+ SUPERTYPE OF (ONEOF
+    (IfcBoxedHalfSpace
+    ,IfcPolygonalBoundedHalfSpace))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	BaseSurface : IfcSurface;
+	AgreementFlag : IfcBoolean;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcHeatExchanger
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcHeatExchangerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcHeatExchangerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcHeatExchangerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCHEATEXCHANGERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcHeatExchangerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcHeatExchangerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcHeatExchangerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcHeatExchangerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcHumidifier
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcHumidifierTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcHumidifierTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcHumidifierTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCHUMIDIFIERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcHumidifierType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcHumidifierTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcHumidifierTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcHumidifierTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcIShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	OverallWidth : IfcPositiveLengthMeasure;
+	OverallDepth : IfcPositiveLengthMeasure;
+	WebThickness : IfcPositiveLengthMeasure;
+	FlangeThickness : IfcPositiveLengthMeasure;
+	FilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	FlangeEdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	FlangeSlope : OPTIONAL IfcPlaneAngleMeasure;
+ WHERE
+	ValidFlangeThickness : (2. * FlangeThickness) < OverallDepth;
+	ValidWebThickness : WebThickness < OverallWidth;
+	ValidFilletRadius : NOT(EXISTS(FilletRadius)) OR
+((FilletRadius <= (OverallWidth - WebThickness)/2.) AND 
+ (FilletRadius <= (OverallDepth - (2. * FlangeThickness))/2.));
+END_ENTITY;
+
+ENTITY IfcImageTexture
+ SUBTYPE OF (IfcSurfaceTexture);
+	URLReference : IfcURIReference;
+END_ENTITY;
+
+ENTITY IfcIndexedColourMap
+ SUBTYPE OF (IfcPresentationItem);
+	MappedTo : IfcTessellatedFaceSet;
+	Opacity : OPTIONAL IfcNormalisedRatioMeasure;
+	Colours : IfcColourRgbList;
+	ColourIndex : LIST [1:?] OF IfcPositiveInteger;
+END_ENTITY;
+
+ENTITY IfcIndexedPolyCurve
+ SUBTYPE OF (IfcBoundedCurve);
+	Points : IfcCartesianPointList;
+	Segments : OPTIONAL LIST [1:?] OF IfcSegmentIndexSelect;
+	SelfIntersect : OPTIONAL IfcBoolean;
+ WHERE
+	Consecutive : (SIZEOF(Segments) = 0) OR IfcConsecutiveSegments(Segments);
+END_ENTITY;
+
+ENTITY IfcIndexedPolygonalFace
+ SUPERTYPE OF (ONEOF
+    (IfcIndexedPolygonalFaceWithVoids))
+ SUBTYPE OF (IfcTessellatedItem);
+	CoordIndex : LIST [3:?] OF IfcPositiveInteger;
+ INVERSE
+	ToFaceSet : SET [1:?] OF IfcPolygonalFaceSet FOR Faces;
+END_ENTITY;
+
+ENTITY IfcIndexedPolygonalFaceWithVoids
+ SUBTYPE OF (IfcIndexedPolygonalFace);
+	InnerCoordIndices : LIST [1:?] OF LIST [3:?] OF UNIQUE IfcPositiveInteger;
+END_ENTITY;
+
+ENTITY IfcIndexedTextureMap
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcIndexedTriangleTextureMap))
+ SUBTYPE OF (IfcTextureCoordinate);
+	MappedTo : IfcTessellatedFaceSet;
+	TexCoords : IfcTextureVertexList;
+END_ENTITY;
+
+ENTITY IfcIndexedTriangleTextureMap
+ SUBTYPE OF (IfcIndexedTextureMap);
+	TexCoordIndex : OPTIONAL LIST [1:?] OF LIST [3:3] OF IfcPositiveInteger;
+END_ENTITY;
+
+ENTITY IfcInterceptor
+ SUBTYPE OF (IfcFlowTreatmentDevice);
+	PredefinedType : OPTIONAL IfcInterceptorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcInterceptorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcInterceptorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCINTERCEPTORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcInterceptorType
+ SUBTYPE OF (IfcFlowTreatmentDeviceType);
+	PredefinedType : IfcInterceptorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcInterceptorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcInterceptorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcIntersectionCurve
+ SUBTYPE OF (IfcSurfaceCurve);
+ WHERE
+	TwoPCurves : SIZEOF(SELF\IfcSurfaceCurve.AssociatedGeometry) = 2;
+	DistinctSurfaces : IfcAssociatedSurface(SELF\IfcSurfaceCurve.AssociatedGeometry[1]) <> IfcAssociatedSurface(SELF\IfcSurfaceCurve.AssociatedGeometry[2]);
+END_ENTITY;
+
+ENTITY IfcInventory
+ SUBTYPE OF (IfcGroup);
+	PredefinedType : OPTIONAL IfcInventoryTypeEnum;
+	Jurisdiction : OPTIONAL IfcActorSelect;
+	ResponsiblePersons : OPTIONAL SET [1:?] OF IfcPerson;
+	LastUpdateDate : OPTIONAL IfcDate;
+	CurrentValue : OPTIONAL IfcCostValue;
+	OriginalValue : OPTIONAL IfcCostValue;
+END_ENTITY;
+
+ENTITY IfcIrregularTimeSeries
+ SUBTYPE OF (IfcTimeSeries);
+	Values : LIST [1:?] OF IfcIrregularTimeSeriesValue;
+END_ENTITY;
+
+ENTITY IfcIrregularTimeSeriesValue;
+	TimeStamp : IfcDateTime;
+	ListValues : LIST [1:?] OF IfcValue;
+END_ENTITY;
+
+ENTITY IfcJunctionBox
+ SUBTYPE OF (IfcFlowFitting);
+	PredefinedType : OPTIONAL IfcJunctionBoxTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcJunctionBoxTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcJunctionBoxTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCJUNCTIONBOXTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcJunctionBoxType
+ SUBTYPE OF (IfcFlowFittingType);
+	PredefinedType : IfcJunctionBoxTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcJunctionBoxTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcJunctionBoxTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcLShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	Depth : IfcPositiveLengthMeasure;
+	Width : OPTIONAL IfcPositiveLengthMeasure;
+	Thickness : IfcPositiveLengthMeasure;
+	FilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	EdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	LegSlope : OPTIONAL IfcPlaneAngleMeasure;
+ WHERE
+	ValidThickness : (Thickness < Depth) AND (NOT(EXISTS(Width)) OR (Thickness < Width));
+END_ENTITY;
+
+ENTITY IfcLaborResource
+ SUBTYPE OF (IfcConstructionResource);
+	PredefinedType : OPTIONAL IfcLaborResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcLaborResourceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcLaborResourceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcLaborResourceType
+ SUBTYPE OF (IfcConstructionResourceType);
+	PredefinedType : IfcLaborResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcLaborResourceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcLaborResourceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeResource.ResourceType));
+END_ENTITY;
+
+ENTITY IfcLagTime
+ SUBTYPE OF (IfcSchedulingTime);
+	LagValue : IfcTimeOrRatioSelect;
+	DurationType : IfcTaskDurationEnum;
+END_ENTITY;
+
+ENTITY IfcLamp
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcLampTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcLampTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcLampTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCLAMPTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcLampType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcLampTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcLampTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcLampTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcLibraryInformation
+ SUBTYPE OF (IfcExternalInformation);
+	Name : IfcLabel;
+	Version : OPTIONAL IfcLabel;
+	Publisher : OPTIONAL IfcActorSelect;
+	VersionDate : OPTIONAL IfcDateTime;
+	Location : OPTIONAL IfcURIReference;
+	Description : OPTIONAL IfcText;
+ INVERSE
+	LibraryInfoForObjects : SET [0:?] OF IfcRelAssociatesLibrary FOR RelatingLibrary;
+	HasLibraryReferences : SET [0:?] OF IfcLibraryReference FOR ReferencedLibrary;
+END_ENTITY;
+
+ENTITY IfcLibraryReference
+ SUBTYPE OF (IfcExternalReference);
+	Description : OPTIONAL IfcText;
+	Language : OPTIONAL IfcLanguageId;
+	ReferencedLibrary : OPTIONAL IfcLibraryInformation;
+ INVERSE
+	LibraryRefForObjects : SET [0:?] OF IfcRelAssociatesLibrary FOR RelatingLibrary;
+END_ENTITY;
+
+ENTITY IfcLightDistributionData;
+	MainPlaneAngle : IfcPlaneAngleMeasure;
+	SecondaryPlaneAngle : LIST [1:?] OF IfcPlaneAngleMeasure;
+	LuminousIntensity : LIST [1:?] OF IfcLuminousIntensityDistributionMeasure;
+END_ENTITY;
+
+ENTITY IfcLightFixture
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcLightFixtureTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcLightFixtureTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcLightFixtureTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCLIGHTFIXTURETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcLightFixtureType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcLightFixtureTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcLightFixtureTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcLightFixtureTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcLightIntensityDistribution;
+	LightDistributionCurve : IfcLightDistributionCurveEnum;
+	DistributionData : LIST [1:?] OF IfcLightDistributionData;
+END_ENTITY;
+
+ENTITY IfcLightSource
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcLightSourceAmbient
+    ,IfcLightSourceDirectional
+    ,IfcLightSourceGoniometric
+    ,IfcLightSourcePositional))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Name : OPTIONAL IfcLabel;
+	LightColour : IfcColourRgb;
+	AmbientIntensity : OPTIONAL IfcNormalisedRatioMeasure;
+	Intensity : OPTIONAL IfcNormalisedRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcLightSourceAmbient
+ SUBTYPE OF (IfcLightSource);
+END_ENTITY;
+
+ENTITY IfcLightSourceDirectional
+ SUBTYPE OF (IfcLightSource);
+	Orientation : IfcDirection;
+END_ENTITY;
+
+ENTITY IfcLightSourceGoniometric
+ SUBTYPE OF (IfcLightSource);
+	Position : IfcAxis2Placement3D;
+	ColourAppearance : OPTIONAL IfcColourRgb;
+	ColourTemperature : IfcThermodynamicTemperatureMeasure;
+	LuminousFlux : IfcLuminousFluxMeasure;
+	LightEmissionSource : IfcLightEmissionSourceEnum;
+	LightDistributionDataSource : IfcLightDistributionDataSourceSelect;
+END_ENTITY;
+
+ENTITY IfcLightSourcePositional
+ SUPERTYPE OF (ONEOF
+    (IfcLightSourceSpot))
+ SUBTYPE OF (IfcLightSource);
+	Position : IfcCartesianPoint;
+	Radius : IfcPositiveLengthMeasure;
+	ConstantAttenuation : IfcReal;
+	DistanceAttenuation : IfcReal;
+	QuadricAttenuation : IfcReal;
+END_ENTITY;
+
+ENTITY IfcLightSourceSpot
+ SUBTYPE OF (IfcLightSourcePositional);
+	Orientation : IfcDirection;
+	ConcentrationExponent : OPTIONAL IfcReal;
+	SpreadAngle : IfcPositivePlaneAngleMeasure;
+	BeamWidthAngle : IfcPositivePlaneAngleMeasure;
+END_ENTITY;
+
+ENTITY IfcLine
+ SUBTYPE OF (IfcCurve);
+	Pnt : IfcCartesianPoint;
+	Dir : IfcVector;
+ WHERE
+	SameDim : Dir.Dim = Pnt.Dim;
+END_ENTITY;
+
+ENTITY IfcLocalPlacement
+ SUBTYPE OF (IfcObjectPlacement);
+	PlacementRelTo : OPTIONAL IfcObjectPlacement;
+	RelativePlacement : IfcAxis2Placement;
+ WHERE
+	WR21 : IfcCorrectLocalPlacement(RelativePlacement, PlacementRelTo);
+END_ENTITY;
+
+ENTITY IfcLoop
+ SUPERTYPE OF (ONEOF
+    (IfcEdgeLoop
+    ,IfcPolyLoop
+    ,IfcVertexLoop))
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+END_ENTITY;
+
+ENTITY IfcManifoldSolidBrep
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAdvancedBrep
+    ,IfcFacetedBrep))
+ SUBTYPE OF (IfcSolidModel);
+	Outer : IfcClosedShell;
+END_ENTITY;
+
+ENTITY IfcMapConversion
+ SUBTYPE OF (IfcCoordinateOperation);
+	Eastings : IfcLengthMeasure;
+	Northings : IfcLengthMeasure;
+	OrthogonalHeight : IfcLengthMeasure;
+	XAxisAbscissa : OPTIONAL IfcReal;
+	XAxisOrdinate : OPTIONAL IfcReal;
+	Scale : OPTIONAL IfcReal;
+END_ENTITY;
+
+ENTITY IfcMappedItem
+ SUBTYPE OF (IfcRepresentationItem);
+	MappingSource : IfcRepresentationMap;
+	MappingTarget : IfcCartesianTransformationOperator;
+END_ENTITY;
+
+ENTITY IfcMaterial
+ SUBTYPE OF (IfcMaterialDefinition);
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	Category : OPTIONAL IfcLabel;
+ INVERSE
+	HasRepresentation : SET [0:1] OF IfcMaterialDefinitionRepresentation FOR RepresentedMaterial;
+	IsRelatedWith : SET [0:?] OF IfcMaterialRelationship FOR RelatedMaterials;
+	RelatesTo : SET [0:1] OF IfcMaterialRelationship FOR RelatingMaterial;
+END_ENTITY;
+
+ENTITY IfcMaterialClassificationRelationship;
+	MaterialClassifications : SET [1:?] OF IfcClassificationSelect;
+	ClassifiedMaterial : IfcMaterial;
+END_ENTITY;
+
+ENTITY IfcMaterialConstituent
+ SUBTYPE OF (IfcMaterialDefinition);
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	Material : IfcMaterial;
+	Fraction : OPTIONAL IfcNormalisedRatioMeasure;
+	Category : OPTIONAL IfcLabel;
+ INVERSE
+	ToMaterialConstituentSet : IfcMaterialConstituentSet FOR MaterialConstituents;
+END_ENTITY;
+
+ENTITY IfcMaterialConstituentSet
+ SUBTYPE OF (IfcMaterialDefinition);
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	MaterialConstituents : OPTIONAL SET [1:?] OF IfcMaterialConstituent;
+END_ENTITY;
+
+ENTITY IfcMaterialDefinition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcMaterial
+    ,IfcMaterialConstituent
+    ,IfcMaterialConstituentSet
+    ,IfcMaterialLayer
+    ,IfcMaterialLayerSet
+    ,IfcMaterialProfile
+    ,IfcMaterialProfileSet));
+ INVERSE
+	AssociatedTo : SET [0:?] OF IfcRelAssociatesMaterial FOR RelatingMaterial;
+	HasExternalReferences : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+	HasProperties : SET [0:?] OF IfcMaterialProperties FOR Material;
+END_ENTITY;
+
+ENTITY IfcMaterialDefinitionRepresentation
+ SUBTYPE OF (IfcProductRepresentation);
+	RepresentedMaterial : IfcMaterial;
+ WHERE
+	OnlyStyledRepresentations : SIZEOF(QUERY(temp <* Representations | 
+  (NOT('IFC4.IFCSTYLEDREPRESENTATION' IN TYPEOF(temp)))
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcMaterialLayer
+ SUPERTYPE OF (ONEOF
+    (IfcMaterialLayerWithOffsets))
+ SUBTYPE OF (IfcMaterialDefinition);
+	Material : OPTIONAL IfcMaterial;
+	LayerThickness : IfcNonNegativeLengthMeasure;
+	IsVentilated : OPTIONAL IfcLogical;
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	Category : OPTIONAL IfcLabel;
+	Priority : OPTIONAL IfcInteger;
+ INVERSE
+	ToMaterialLayerSet : IfcMaterialLayerSet FOR MaterialLayers;
+ WHERE
+	NormalizedPriority : NOT(EXISTS(Priority)) OR {0 <= Priority <= 100};
+END_ENTITY;
+
+ENTITY IfcMaterialLayerSet
+ SUBTYPE OF (IfcMaterialDefinition);
+	MaterialLayers : LIST [1:?] OF IfcMaterialLayer;
+	LayerSetName : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+ DERIVE
+	TotalThickness : IfcLengthMeasure := IfcMlsTotalThickness(SELF);
+END_ENTITY;
+
+ENTITY IfcMaterialLayerSetUsage
+ SUBTYPE OF (IfcMaterialUsageDefinition);
+	ForLayerSet : IfcMaterialLayerSet;
+	LayerSetDirection : IfcLayerSetDirectionEnum;
+	DirectionSense : IfcDirectionSenseEnum;
+	OffsetFromReferenceLine : IfcLengthMeasure;
+	ReferenceExtent : OPTIONAL IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcMaterialLayerWithOffsets
+ SUBTYPE OF (IfcMaterialLayer);
+	OffsetDirection : IfcLayerSetDirectionEnum;
+	OffsetValues : ARRAY [1:2] OF IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcMaterialList;
+	Materials : LIST [1:?] OF IfcMaterial;
+END_ENTITY;
+
+ENTITY IfcMaterialProfile
+ SUPERTYPE OF (ONEOF
+    (IfcMaterialProfileWithOffsets))
+ SUBTYPE OF (IfcMaterialDefinition);
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	Material : OPTIONAL IfcMaterial;
+	Profile : IfcProfileDef;
+	Priority : OPTIONAL IfcInteger;
+	Category : OPTIONAL IfcLabel;
+ INVERSE
+	ToMaterialProfileSet : IfcMaterialProfileSet FOR MaterialProfiles;
+ WHERE
+	NormalizedPriority : NOT(EXISTS(Priority)) OR {0 <= Priority <= 100};
+END_ENTITY;
+
+ENTITY IfcMaterialProfileSet
+ SUBTYPE OF (IfcMaterialDefinition);
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	MaterialProfiles : LIST [1:?] OF IfcMaterialProfile;
+	CompositeProfile : OPTIONAL IfcCompositeProfileDef;
+END_ENTITY;
+
+ENTITY IfcMaterialProfileSetUsage
+ SUPERTYPE OF (ONEOF
+    (IfcMaterialProfileSetUsageTapering))
+ SUBTYPE OF (IfcMaterialUsageDefinition);
+	ForProfileSet : IfcMaterialProfileSet;
+	CardinalPoint : OPTIONAL IfcCardinalPointReference;
+	ReferenceExtent : OPTIONAL IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcMaterialProfileSetUsageTapering
+ SUBTYPE OF (IfcMaterialProfileSetUsage);
+	ForProfileEndSet : IfcMaterialProfileSet;
+	CardinalEndPoint : OPTIONAL IfcCardinalPointReference;
+END_ENTITY;
+
+ENTITY IfcMaterialProfileWithOffsets
+ SUBTYPE OF (IfcMaterialProfile);
+	OffsetValues : ARRAY [1:2] OF IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcMaterialProperties
+ SUBTYPE OF (IfcExtendedProperties);
+	Material : IfcMaterialDefinition;
+END_ENTITY;
+
+ENTITY IfcMaterialRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingMaterial : IfcMaterial;
+	RelatedMaterials : SET [1:?] OF IfcMaterial;
+	Expression : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcMaterialUsageDefinition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcMaterialLayerSetUsage
+    ,IfcMaterialProfileSetUsage));
+ INVERSE
+	AssociatedTo : SET [1:?] OF IfcRelAssociatesMaterial FOR RelatingMaterial;
+END_ENTITY;
+
+ENTITY IfcMeasureWithUnit;
+	ValueComponent : IfcValue;
+	UnitComponent : IfcUnit;
+END_ENTITY;
+
+ENTITY IfcMechanicalFastener
+ SUBTYPE OF (IfcElementComponent);
+	NominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	NominalLength : OPTIONAL IfcPositiveLengthMeasure;
+	PredefinedType : OPTIONAL IfcMechanicalFastenerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+(PredefinedType <> IfcMechanicalFastenerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcMechanicalFastenerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCMECHANICALFASTENERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcMechanicalFastenerType
+ SUBTYPE OF (IfcElementComponentType);
+	PredefinedType : IfcMechanicalFastenerTypeEnum;
+	NominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	NominalLength : OPTIONAL IfcPositiveLengthMeasure;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcMechanicalFastenerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcMechanicalFastenerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcMedicalDevice
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcMedicalDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcMedicalDeviceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcMedicalDeviceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCMEDICALDEVICETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcMedicalDeviceType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcMedicalDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcMedicalDeviceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcMedicalDeviceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcMember
+ SUPERTYPE OF (ONEOF
+    (IfcMemberStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcMemberTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcMemberTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcMemberTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCMEMBERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcMemberStandardCase
+ SUBTYPE OF (IfcMember);
+ WHERE
+	HasMaterialProfileSetUsage : SIZEOF (QUERY(temp <* USEDIN(SELF, 'IFC4.IFCRELASSOCIATES.RELATEDOBJECTS') |
+              ('IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)) AND
+              ('IFC4.IFCMATERIALPROFILESETUSAGE' IN TYPEOF(temp.RelatingMaterial))
+              )) = 1;
+END_ENTITY;
+
+ENTITY IfcMemberType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcMemberTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcMemberTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcMemberTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcMetric
+ SUBTYPE OF (IfcConstraint);
+	Benchmark : IfcBenchmarkEnum;
+	ValueSource : OPTIONAL IfcLabel;
+	DataValue : OPTIONAL IfcMetricValueSelect;
+	ReferencePath : OPTIONAL IfcReference;
+END_ENTITY;
+
+ENTITY IfcMirroredProfileDef
+ SUBTYPE OF (IfcDerivedProfileDef);
+ DERIVE
+	SELF\IfcDerivedProfileDef.Operator : IfcCartesianTransformationOperator2D := 
+IfcRepresentationItem() || IfcGeometricRepresentationItem() ||
+IfcCartesianTransformationOperator(
+    -- Axis1
+    IfcRepresentationItem() || IfcGeometricRepresentationItem() ||
+    IfcDirection([-1., 0.]),
+    -- Axis2
+    IfcRepresentationItem() || IfcGeometricRepresentationItem() ||
+    IfcDirection([ 0., 1.]),
+    -- LocalOrigin
+    IfcRepresentationItem() || IfcGeometricRepresentationItem() ||
+    IfcPoint() || IfcCartesianPoint([0., 0.]),
+    -- Scale
+    1.) ||
+IfcCartesianTransformationOperator2D();
+END_ENTITY;
+
+ENTITY IfcMonetaryUnit;
+	Currency : IfcLabel;
+END_ENTITY;
+
+ENTITY IfcMotorConnection
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcMotorConnectionTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcMotorConnectionTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcMotorConnectionTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCMOTORCONNECTIONTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcMotorConnectionType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcMotorConnectionTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcMotorConnectionTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcMotorConnectionTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcNamedUnit
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcContextDependentUnit
+    ,IfcConversionBasedUnit
+    ,IfcSIUnit));
+	Dimensions : IfcDimensionalExponents;
+	UnitType : IfcUnitEnum;
+ WHERE
+	WR1 : IfcCorrectDimensions (SELF.UnitType, SELF.Dimensions);
+END_ENTITY;
+
+ENTITY IfcObject
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcActor
+    ,IfcControl
+    ,IfcGroup
+    ,IfcProcess
+    ,IfcProduct
+    ,IfcResource))
+ SUBTYPE OF (IfcObjectDefinition);
+	ObjectType : OPTIONAL IfcLabel;
+ INVERSE
+	IsDeclaredBy : SET [0:1] OF IfcRelDefinesByObject FOR RelatedObjects;
+	Declares : SET [0:?] OF IfcRelDefinesByObject FOR RelatingObject;
+	IsTypedBy : SET [0:1] OF IfcRelDefinesByType FOR RelatedObjects;
+	IsDefinedBy : SET [0:?] OF IfcRelDefinesByProperties FOR RelatedObjects;
+ WHERE
+	UniquePropertySetNames : ((SIZEOF(IsDefinedBy) = 0) OR IfcUniqueDefinitionNames(IsDefinedBy));
+END_ENTITY;
+
+ENTITY IfcObjectDefinition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcContext
+    ,IfcObject
+    ,IfcTypeObject))
+ SUBTYPE OF (IfcRoot);
+ INVERSE
+	HasAssignments : SET [0:?] OF IfcRelAssigns FOR RelatedObjects;
+	Nests : SET [0:1] OF IfcRelNests FOR RelatedObjects;
+	IsNestedBy : SET [0:?] OF IfcRelNests FOR RelatingObject;
+	HasContext : SET [0:1] OF IfcRelDeclares FOR RelatedDefinitions;
+	IsDecomposedBy : SET [0:?] OF IfcRelAggregates FOR RelatingObject;
+	Decomposes : SET [0:1] OF IfcRelAggregates FOR RelatedObjects;
+	HasAssociations : SET [0:?] OF IfcRelAssociates FOR RelatedObjects;
+END_ENTITY;
+
+ENTITY IfcObjectPlacement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcGridPlacement
+    ,IfcLocalPlacement));
+ INVERSE
+	PlacesObject : SET [0:?] OF IfcProduct FOR ObjectPlacement;
+	ReferencedByPlacements : SET [0:?] OF IfcLocalPlacement FOR PlacementRelTo;
+END_ENTITY;
+
+ENTITY IfcObjective
+ SUBTYPE OF (IfcConstraint);
+	BenchmarkValues : OPTIONAL LIST [1:?] OF IfcConstraint;
+	LogicalAggregator : OPTIONAL IfcLogicalOperatorEnum;
+	ObjectiveQualifier : IfcObjectiveEnum;
+	UserDefinedQualifier : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : (ObjectiveQualifier <> IfcObjectiveEnum.USERDEFINED) OR
+((ObjectiveQualifier = IfcObjectiveEnum.USERDEFINED) AND EXISTS(SELF\IfcObjective.UserDefinedQualifier));
+END_ENTITY;
+
+ENTITY IfcOccupant
+ SUBTYPE OF (IfcActor);
+	PredefinedType : OPTIONAL IfcOccupantTypeEnum;
+ WHERE
+	WR31 : NOT(PredefinedType = IfcOccupantTypeEnum.USERDEFINED) 
+OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcOffsetCurve2D
+ SUBTYPE OF (IfcCurve);
+	BasisCurve : IfcCurve;
+	Distance : IfcLengthMeasure;
+	SelfIntersect : IfcLogical;
+ WHERE
+	DimIs2D : BasisCurve.Dim = 2;
+END_ENTITY;
+
+ENTITY IfcOffsetCurve3D
+ SUBTYPE OF (IfcCurve);
+	BasisCurve : IfcCurve;
+	Distance : IfcLengthMeasure;
+	SelfIntersect : IfcLogical;
+	RefDirection : IfcDirection;
+ WHERE
+	DimIs2D : BasisCurve.Dim = 3;
+END_ENTITY;
+
+ENTITY IfcOpenShell
+ SUBTYPE OF (IfcConnectedFaceSet);
+END_ENTITY;
+
+ENTITY IfcOpeningElement
+ SUPERTYPE OF (ONEOF
+    (IfcOpeningStandardCase))
+ SUBTYPE OF (IfcFeatureElementSubtraction);
+	PredefinedType : OPTIONAL IfcOpeningElementTypeEnum;
+ INVERSE
+	HasFillings : SET [0:?] OF IfcRelFillsElement FOR RelatingOpeningElement;
+END_ENTITY;
+
+ENTITY IfcOpeningStandardCase
+ SUBTYPE OF (IfcOpeningElement);
+END_ENTITY;
+
+ENTITY IfcOrganization;
+	Identification : OPTIONAL IfcIdentifier;
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	Roles : OPTIONAL LIST [1:?] OF IfcActorRole;
+	Addresses : OPTIONAL LIST [1:?] OF IfcAddress;
+ INVERSE
+	IsRelatedBy : SET [0:?] OF IfcOrganizationRelationship FOR RelatedOrganizations;
+	Relates : SET [0:?] OF IfcOrganizationRelationship FOR RelatingOrganization;
+	Engages : SET [0:?] OF IfcPersonAndOrganization FOR TheOrganization;
+END_ENTITY;
+
+ENTITY IfcOrganizationRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingOrganization : IfcOrganization;
+	RelatedOrganizations : SET [1:?] OF IfcOrganization;
+END_ENTITY;
+
+ENTITY IfcOrientedEdge
+ SUBTYPE OF (IfcEdge);
+	EdgeElement : IfcEdge;
+	Orientation : IfcBoolean;
+ DERIVE
+	SELF\IfcEdge.EdgeStart : IfcVertex := IfcBooleanChoose 
+(Orientation, EdgeElement.EdgeStart, EdgeElement.EdgeEnd);
+	SELF\IfcEdge.EdgeEnd : IfcVertex := IfcBooleanChoose 
+(Orientation, EdgeElement.EdgeEnd, EdgeElement.EdgeStart);
+ WHERE
+	EdgeElementNotOriented : NOT('IFC4.IFCORIENTEDEDGE' IN TYPEOF(EdgeElement));
+END_ENTITY;
+
+ENTITY IfcOuterBoundaryCurve
+ SUBTYPE OF (IfcBoundaryCurve);
+END_ENTITY;
+
+ENTITY IfcOutlet
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcOutletTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcOutletTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcOutletTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCOUTLETTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcOutletType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcOutletTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcOutletTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcOutletTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcOwnerHistory;
+	OwningUser : IfcPersonAndOrganization;
+	OwningApplication : IfcApplication;
+	State : OPTIONAL IfcStateEnum;
+	ChangeAction : OPTIONAL IfcChangeActionEnum;
+	LastModifiedDate : OPTIONAL IfcTimeStamp;
+	LastModifyingUser : OPTIONAL IfcPersonAndOrganization;
+	LastModifyingApplication : OPTIONAL IfcApplication;
+	CreationDate : IfcTimeStamp;
+ WHERE
+	CorrectChangeAction : (EXISTS(LastModifiedDate)) OR
+(NOT(EXISTS(LastModifiedDate)) AND NOT(EXISTS(ChangeAction))) OR
+(NOT(EXISTS(LastModifiedDate)) AND EXISTS(ChangeAction) AND ((ChangeAction = IfcChangeActionEnum.NOTDEFINED) OR (ChangeAction = IfcChangeActionEnum.NOCHANGE)));
+END_ENTITY;
+
+ENTITY IfcParameterizedProfileDef
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAsymmetricIShapeProfileDef
+    ,IfcCShapeProfileDef
+    ,IfcCircleProfileDef
+    ,IfcEllipseProfileDef
+    ,IfcIShapeProfileDef
+    ,IfcLShapeProfileDef
+    ,IfcRectangleProfileDef
+    ,IfcTShapeProfileDef
+    ,IfcTrapeziumProfileDef
+    ,IfcUShapeProfileDef
+    ,IfcZShapeProfileDef))
+ SUBTYPE OF (IfcProfileDef);
+	Position : OPTIONAL IfcAxis2Placement2D;
+END_ENTITY;
+
+ENTITY IfcPath
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+	EdgeList : LIST [1:?] OF UNIQUE IfcOrientedEdge;
+ WHERE
+	IsContinuous : IfcPathHeadToTail(SELF);
+END_ENTITY;
+
+ENTITY IfcPcurve
+ SUBTYPE OF (IfcCurve);
+	BasisSurface : IfcSurface;
+	ReferenceCurve : IfcCurve;
+ WHERE
+	DimIs2D : ReferenceCurve.Dim = 2;
+END_ENTITY;
+
+ENTITY IfcPerformanceHistory
+ SUBTYPE OF (IfcControl);
+	LifeCyclePhase : IfcLabel;
+	PredefinedType : OPTIONAL IfcPerformanceHistoryTypeEnum;
+END_ENTITY;
+
+ENTITY IfcPermeableCoveringProperties
+ SUBTYPE OF (IfcPreDefinedPropertySet);
+	OperationType : IfcPermeableCoveringOperationEnum;
+	PanelPosition : IfcWindowPanelPositionEnum;
+	FrameDepth : OPTIONAL IfcPositiveLengthMeasure;
+	FrameThickness : OPTIONAL IfcPositiveLengthMeasure;
+	ShapeAspectStyle : OPTIONAL IfcShapeAspect;
+END_ENTITY;
+
+ENTITY IfcPermit
+ SUBTYPE OF (IfcControl);
+	PredefinedType : OPTIONAL IfcPermitTypeEnum;
+	Status : OPTIONAL IfcLabel;
+	LongDescription : OPTIONAL IfcText;
+END_ENTITY;
+
+ENTITY IfcPerson;
+	Identification : OPTIONAL IfcIdentifier;
+	FamilyName : OPTIONAL IfcLabel;
+	GivenName : OPTIONAL IfcLabel;
+	MiddleNames : OPTIONAL LIST [1:?] OF IfcLabel;
+	PrefixTitles : OPTIONAL LIST [1:?] OF IfcLabel;
+	SuffixTitles : OPTIONAL LIST [1:?] OF IfcLabel;
+	Roles : OPTIONAL LIST [1:?] OF IfcActorRole;
+	Addresses : OPTIONAL LIST [1:?] OF IfcAddress;
+ INVERSE
+	EngagedIn : SET [0:?] OF IfcPersonAndOrganization FOR ThePerson;
+ WHERE
+	IdentifiablePerson : EXISTS(Identification) OR EXISTS(FamilyName) OR EXISTS(GivenName);
+	ValidSetOfNames : NOT EXISTS(MiddleNames) OR EXISTS(FamilyName) OR EXISTS(GivenName);
+END_ENTITY;
+
+ENTITY IfcPersonAndOrganization;
+	ThePerson : IfcPerson;
+	TheOrganization : IfcOrganization;
+	Roles : OPTIONAL LIST [1:?] OF IfcActorRole;
+END_ENTITY;
+
+ENTITY IfcPhysicalComplexQuantity
+ SUBTYPE OF (IfcPhysicalQuantity);
+	HasQuantities : SET [1:?] OF IfcPhysicalQuantity;
+	Discrimination : IfcLabel;
+	Quality : OPTIONAL IfcLabel;
+	Usage : OPTIONAL IfcLabel;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(temp <* HasQuantities | SELF :=: temp)) = 0;
+	UniqueQuantityNames : IfcUniqueQuantityNames(HasQuantities);
+END_ENTITY;
+
+ENTITY IfcPhysicalQuantity
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPhysicalComplexQuantity
+    ,IfcPhysicalSimpleQuantity));
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+ INVERSE
+	HasExternalReferences : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+	PartOfComplex : SET [0:1] OF IfcPhysicalComplexQuantity FOR HasQuantities;
+END_ENTITY;
+
+ENTITY IfcPhysicalSimpleQuantity
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcQuantityArea
+    ,IfcQuantityCount
+    ,IfcQuantityLength
+    ,IfcQuantityTime
+    ,IfcQuantityVolume
+    ,IfcQuantityWeight))
+ SUBTYPE OF (IfcPhysicalQuantity);
+	Unit : OPTIONAL IfcNamedUnit;
+END_ENTITY;
+
+ENTITY IfcPile
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcPileTypeEnum;
+	ConstructionType : OPTIONAL IfcPileConstructionEnum;
+ WHERE
+	CorrectPredefinedType : NOT EXISTS(PredefinedType) OR
+(PredefinedType <> IfcPileTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcPileTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCPILETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcPileType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcPileTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcPileTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcPileTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcPipeFitting
+ SUBTYPE OF (IfcFlowFitting);
+	PredefinedType : OPTIONAL IfcPipeFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcPipeFittingTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcPipeFittingTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCPIPEFITTINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcPipeFittingType
+ SUBTYPE OF (IfcFlowFittingType);
+	PredefinedType : IfcPipeFittingTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcPipeFittingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcPipeFittingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcPipeSegment
+ SUBTYPE OF (IfcFlowSegment);
+	PredefinedType : OPTIONAL IfcPipeSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcPipeSegmentTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcPipeSegmentTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCPIPESEGMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcPipeSegmentType
+ SUBTYPE OF (IfcFlowSegmentType);
+	PredefinedType : IfcPipeSegmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcPipeSegmentTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcPipeSegmentTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcPixelTexture
+ SUBTYPE OF (IfcSurfaceTexture);
+	Width : IfcInteger;
+	Height : IfcInteger;
+	ColourComponents : IfcInteger;
+	Pixel : LIST [1:?] OF IfcBinary;
+ WHERE
+	MinPixelInS : Width >= 1;
+	MinPixelInT : Height >= 1;
+	NumberOfColours : {1 <= ColourComponents <= 4};
+	SizeOfPixelList : SIZEOF(Pixel) = (Width * Height);
+	PixelAsByteAndSameLength : SIZEOF(QUERY(temp<* Pixel |
+ (BLENGTH(temp) MOD 8 = 0) AND
+ (BLENGTH(temp) = BLENGTH(Pixel[1]))
+)) = SIZEOF(Pixel);
+END_ENTITY;
+
+ENTITY IfcPlacement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAxis1Placement
+    ,IfcAxis2Placement2D
+    ,IfcAxis2Placement3D))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Location : IfcCartesianPoint;
+ DERIVE
+	Dim : IfcDimensionCount := Location.Dim;
+END_ENTITY;
+
+ENTITY IfcPlanarBox
+ SUBTYPE OF (IfcPlanarExtent);
+	Placement : IfcAxis2Placement;
+END_ENTITY;
+
+ENTITY IfcPlanarExtent
+ SUPERTYPE OF (ONEOF
+    (IfcPlanarBox))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	SizeInX : IfcLengthMeasure;
+	SizeInY : IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcPlane
+ SUBTYPE OF (IfcElementarySurface);
+END_ENTITY;
+
+ENTITY IfcPlate
+ SUPERTYPE OF (ONEOF
+    (IfcPlateStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcPlateTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcPlateTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcPlateTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCPLATETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcPlateStandardCase
+ SUBTYPE OF (IfcPlate);
+ WHERE
+	HasMaterialLayerSetUsage : SIZEOF (QUERY(temp <* USEDIN(SELF, 'IFC4.IFCRELASSOCIATES.RELATEDOBJECTS') |
+              ('IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)) AND
+              ('IFC4.IFCMATERIALLAYERSETUSAGE' IN TYPEOF(temp.RelatingMaterial))
+              )) = 1;
+END_ENTITY;
+
+ENTITY IfcPlateType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcPlateTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcPlateTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcPlateTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcPoint
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCartesianPoint
+    ,IfcPointOnCurve
+    ,IfcPointOnSurface))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+END_ENTITY;
+
+ENTITY IfcPointOnCurve
+ SUBTYPE OF (IfcPoint);
+	BasisCurve : IfcCurve;
+	PointParameter : IfcParameterValue;
+ DERIVE
+	Dim : IfcDimensionCount := BasisCurve.Dim;
+END_ENTITY;
+
+ENTITY IfcPointOnSurface
+ SUBTYPE OF (IfcPoint);
+	BasisSurface : IfcSurface;
+	PointParameterU : IfcParameterValue;
+	PointParameterV : IfcParameterValue;
+ DERIVE
+	Dim : IfcDimensionCount := BasisSurface.Dim;
+END_ENTITY;
+
+ENTITY IfcPolyLoop
+ SUBTYPE OF (IfcLoop);
+	Polygon : LIST [3:?] OF UNIQUE IfcCartesianPoint;
+ WHERE
+	AllPointsSameDim : SIZEOF(QUERY(Temp <* Polygon | Temp.Dim <> Polygon[1].Dim)) = 0;
+END_ENTITY;
+
+ENTITY IfcPolygonalBoundedHalfSpace
+ SUBTYPE OF (IfcHalfSpaceSolid);
+	Position : IfcAxis2Placement3D;
+	PolygonalBoundary : IfcBoundedCurve;
+ WHERE
+	BoundaryDim : PolygonalBoundary.Dim = 2;
+	BoundaryType : SIZEOF(TYPEOF(PolygonalBoundary) * [
+  'IFC4.IFCPOLYLINE', 
+  'IFC4.IFCCOMPOSITECURVE']
+) = 1;
+END_ENTITY;
+
+ENTITY IfcPolygonalFaceSet
+ SUBTYPE OF (IfcTessellatedFaceSet);
+	Closed : OPTIONAL IfcBoolean;
+	Faces : LIST [1:?] OF IfcIndexedPolygonalFace;
+	PnIndex : OPTIONAL LIST [1:?] OF IfcPositiveInteger;
+END_ENTITY;
+
+ENTITY IfcPolyline
+ SUBTYPE OF (IfcBoundedCurve);
+	Points : LIST [2:?] OF IfcCartesianPoint;
+ WHERE
+	SameDim : SIZEOF(QUERY(Temp <* Points | Temp.Dim <> Points[1].Dim)) = 0;
+END_ENTITY;
+
+ENTITY IfcPort
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcDistributionPort))
+ SUBTYPE OF (IfcProduct);
+ INVERSE
+	ContainedIn : SET [0:1] OF IfcRelConnectsPortToElement FOR RelatingPort;
+	ConnectedFrom : SET [0:1] OF IfcRelConnectsPorts FOR RelatedPort;
+	ConnectedTo : SET [0:1] OF IfcRelConnectsPorts FOR RelatingPort;
+END_ENTITY;
+
+ENTITY IfcPostalAddress
+ SUBTYPE OF (IfcAddress);
+	InternalLocation : OPTIONAL IfcLabel;
+	AddressLines : OPTIONAL LIST [1:?] OF IfcLabel;
+	PostalBox : OPTIONAL IfcLabel;
+	Town : OPTIONAL IfcLabel;
+	Region : OPTIONAL IfcLabel;
+	PostalCode : OPTIONAL IfcLabel;
+	Country : OPTIONAL IfcLabel;
+ WHERE
+	WR1 : EXISTS (InternalLocation) OR 
+EXISTS (AddressLines) OR
+EXISTS (PostalBox) OR
+EXISTS (PostalCode) OR
+EXISTS (Town) OR 
+EXISTS (Region) OR  
+EXISTS (Country);
+END_ENTITY;
+
+ENTITY IfcPreDefinedColour
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcDraughtingPreDefinedColour))
+ SUBTYPE OF (IfcPreDefinedItem);
+END_ENTITY;
+
+ENTITY IfcPreDefinedCurveFont
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcDraughtingPreDefinedCurveFont))
+ SUBTYPE OF (IfcPreDefinedItem);
+END_ENTITY;
+
+ENTITY IfcPreDefinedItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPreDefinedColour
+    ,IfcPreDefinedCurveFont
+    ,IfcPreDefinedTextFont))
+ SUBTYPE OF (IfcPresentationItem);
+	Name : IfcLabel;
+END_ENTITY;
+
+ENTITY IfcPreDefinedProperties
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcReinforcementBarProperties
+    ,IfcSectionProperties
+    ,IfcSectionReinforcementProperties))
+ SUBTYPE OF (IfcPropertyAbstraction);
+END_ENTITY;
+
+ENTITY IfcPreDefinedPropertySet
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcDoorLiningProperties
+    ,IfcDoorPanelProperties
+    ,IfcPermeableCoveringProperties
+    ,IfcReinforcementDefinitionProperties
+    ,IfcWindowLiningProperties
+    ,IfcWindowPanelProperties))
+ SUBTYPE OF (IfcPropertySetDefinition);
+END_ENTITY;
+
+ENTITY IfcPreDefinedTextFont
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcTextStyleFontModel))
+ SUBTYPE OF (IfcPreDefinedItem);
+END_ENTITY;
+
+ENTITY IfcPresentationItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcColourRgbList
+    ,IfcColourSpecification
+    ,IfcCurveStyleFont
+    ,IfcCurveStyleFontAndScaling
+    ,IfcCurveStyleFontPattern
+    ,IfcIndexedColourMap
+    ,IfcPreDefinedItem
+    ,IfcSurfaceStyleLighting
+    ,IfcSurfaceStyleRefraction
+    ,IfcSurfaceStyleShading
+    ,IfcSurfaceStyleWithTextures
+    ,IfcSurfaceTexture
+    ,IfcTextStyleForDefinedFont
+    ,IfcTextStyleTextModel
+    ,IfcTextureCoordinate
+    ,IfcTextureVertex
+    ,IfcTextureVertexList));
+END_ENTITY;
+
+ENTITY IfcPresentationLayerAssignment
+ SUPERTYPE OF (ONEOF
+    (IfcPresentationLayerWithStyle));
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	AssignedItems : SET [1:?] OF IfcLayeredItem;
+	Identifier : OPTIONAL IfcIdentifier;
+ WHERE
+	ApplicableItems : SIZEOF(QUERY(temp <* AssignedItems | (
+  SIZEOF(TYPEOF(temp) * [
+    'IFC4.IFCSHAPEREPRESENTATION',
+    'IFC4.IFCGEOMETRICREPRESENTATIONITEM',
+    'IFC4.IFCMAPPEDITEM']) = 1)
+)) = SIZEOF(AssignedItems);
+END_ENTITY;
+
+ENTITY IfcPresentationLayerWithStyle
+ SUBTYPE OF (IfcPresentationLayerAssignment);
+	LayerOn : IfcLogical;
+	LayerFrozen : IfcLogical;
+	LayerBlocked : IfcLogical;
+	LayerStyles : SET [0:?] OF IfcPresentationStyle;
+ WHERE
+	ApplicableOnlyToItems : SIZEOF(QUERY(temp <* AssignedItems | (
+  SIZEOF(TYPEOF(temp) * [
+    'IFC4.IFCGEOMETRICREPRESENTATIONITEM',
+    'IFC4.IFCMAPPEDITEM']) = 1)
+)) = SIZEOF(AssignedItems);
+END_ENTITY;
+
+ENTITY IfcPresentationStyle
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCurveStyle
+    ,IfcFillAreaStyle
+    ,IfcSurfaceStyle
+    ,IfcTextStyle));
+	Name : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcPresentationStyleAssignment;
+	Styles : SET [1:?] OF IfcPresentationStyleSelect;
+END_ENTITY;
+
+ENTITY IfcProcedure
+ SUBTYPE OF (IfcProcess);
+	PredefinedType : OPTIONAL IfcProcedureTypeEnum;
+ WHERE
+	HasName : EXISTS(SELF\IfcRoot.Name);
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR (PredefinedType <> IfcProcedureTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcProcedureTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcProcedureType
+ SUBTYPE OF (IfcTypeProcess);
+	PredefinedType : IfcProcedureTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcProcedureTypeEnum.USERDEFINED) OR ((PredefinedType = IfcProcedureTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeProcess.ProcessType));
+END_ENTITY;
+
+ENTITY IfcProcess
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcEvent
+    ,IfcProcedure
+    ,IfcTask))
+ SUBTYPE OF (IfcObject);
+	Identification : OPTIONAL IfcIdentifier;
+	LongDescription : OPTIONAL IfcText;
+ INVERSE
+	IsPredecessorTo : SET [0:?] OF IfcRelSequence FOR RelatingProcess;
+	IsSuccessorFrom : SET [0:?] OF IfcRelSequence FOR RelatedProcess;
+	OperatesOn : SET [0:?] OF IfcRelAssignsToProcess FOR RelatingProcess;
+END_ENTITY;
+
+ENTITY IfcProduct
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcAnnotation
+    ,IfcElement
+    ,IfcGrid
+    ,IfcPort
+    ,IfcProxy
+    ,IfcSpatialElement
+    ,IfcStructuralActivity
+    ,IfcStructuralItem))
+ SUBTYPE OF (IfcObject);
+	ObjectPlacement : OPTIONAL IfcObjectPlacement;
+	Representation : OPTIONAL IfcProductRepresentation;
+ INVERSE
+	ReferencedBy : SET [0:?] OF IfcRelAssignsToProduct FOR RelatingProduct;
+ WHERE
+	PlacementForShapeRepresentation : (EXISTS(Representation) AND EXISTS(ObjectPlacement))
+            OR (EXISTS(Representation) AND 
+			   (SIZEOF(QUERY(temp <* Representation.Representations | 'IFC4.IFCSHAPEREPRESENTATION' IN TYPEOF(temp))) = 0))
+            OR (NOT(EXISTS(Representation)));
+END_ENTITY;
+
+ENTITY IfcProductDefinitionShape
+ SUBTYPE OF (IfcProductRepresentation);
+ INVERSE
+	ShapeOfProduct : SET [1:?] OF IfcProduct FOR Representation;
+	HasShapeAspects : SET [0:?] OF IfcShapeAspect FOR PartOfProductDefinitionShape;
+ WHERE
+	OnlyShapeModel : SIZEOF(QUERY(temp <* Representations | 
+  (NOT('IFC4.IFCSHAPEMODEL' IN TYPEOF(temp)))
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcProductRepresentation
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcMaterialDefinitionRepresentation
+    ,IfcProductDefinitionShape));
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	Representations : LIST [1:?] OF IfcRepresentation;
+END_ENTITY;
+
+ENTITY IfcProfileDef
+ SUPERTYPE OF (ONEOF
+    (IfcArbitraryClosedProfileDef
+    ,IfcArbitraryOpenProfileDef
+    ,IfcCompositeProfileDef
+    ,IfcDerivedProfileDef
+    ,IfcParameterizedProfileDef));
+	ProfileType : IfcProfileTypeEnum;
+	ProfileName : OPTIONAL IfcLabel;
+ INVERSE
+	HasExternalReference : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+	HasProperties : SET [0:?] OF IfcProfileProperties FOR ProfileDefinition;
+END_ENTITY;
+
+ENTITY IfcProfileProperties
+ SUBTYPE OF (IfcExtendedProperties);
+	ProfileDefinition : IfcProfileDef;
+END_ENTITY;
+
+ENTITY IfcProject
+ SUBTYPE OF (IfcContext);
+ WHERE
+	HasName : EXISTS(SELF\IfcRoot.Name);
+	CorrectContext : NOT(EXISTS(SELF\IfcContext.RepresentationContexts)) OR
+(SIZEOF(QUERY(Temp <* SELF\IfcContext.RepresentationContexts |
+ 'IFC4.IFCGEOMETRICREPRESENTATIONSUBCONTEXT' IN TYPEOF(Temp)
+  )) = 0);
+	NoDecomposition : SIZEOF(SELF\IfcObjectDefinition.Decomposes) = 0;
+END_ENTITY;
+
+ENTITY IfcProjectLibrary
+ SUBTYPE OF (IfcContext);
+END_ENTITY;
+
+ENTITY IfcProjectOrder
+ SUBTYPE OF (IfcControl);
+	PredefinedType : OPTIONAL IfcProjectOrderTypeEnum;
+	Status : OPTIONAL IfcLabel;
+	LongDescription : OPTIONAL IfcText;
+END_ENTITY;
+
+ENTITY IfcProjectedCRS
+ SUBTYPE OF (IfcCoordinateReferenceSystem);
+	MapProjection : OPTIONAL IfcIdentifier;
+	MapZone : OPTIONAL IfcIdentifier;
+	MapUnit : OPTIONAL IfcNamedUnit;
+ WHERE
+	IsLengthUnit : NOT(EXISTS(MapUnit)) OR (MapUnit.UnitType = IfcUnitEnum.LENGTHUNIT);
+END_ENTITY;
+
+ENTITY IfcProjectionElement
+ SUBTYPE OF (IfcFeatureElementAddition);
+	PredefinedType : OPTIONAL IfcProjectionElementTypeEnum;
+END_ENTITY;
+
+ENTITY IfcProperty
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcComplexProperty
+    ,IfcSimpleProperty))
+ SUBTYPE OF (IfcPropertyAbstraction);
+	Name : IfcIdentifier;
+	Description : OPTIONAL IfcText;
+ INVERSE
+	PartOfPset : SET [0:?] OF IfcPropertySet FOR HasProperties;
+	PropertyForDependance : SET [0:?] OF IfcPropertyDependencyRelationship FOR DependingProperty;
+	PropertyDependsOn : SET [0:?] OF IfcPropertyDependencyRelationship FOR DependantProperty;
+	PartOfComplex : SET [0:?] OF IfcComplexProperty FOR HasProperties;
+	HasConstraints : SET [0:?] OF IfcResourceConstraintRelationship FOR RelatedResourceObjects;
+	HasApprovals : SET [0:?] OF IfcResourceApprovalRelationship FOR RelatedResourceObjects;
+END_ENTITY;
+
+ENTITY IfcPropertyAbstraction
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcExtendedProperties
+    ,IfcPreDefinedProperties
+    ,IfcProperty
+    ,IfcPropertyEnumeration));
+ INVERSE
+	HasExternalReferences : SET [0:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+END_ENTITY;
+
+ENTITY IfcPropertyBoundedValue
+ SUBTYPE OF (IfcSimpleProperty);
+	UpperBoundValue : OPTIONAL IfcValue;
+	LowerBoundValue : OPTIONAL IfcValue;
+	Unit : OPTIONAL IfcUnit;
+	SetPointValue : OPTIONAL IfcValue;
+ WHERE
+	SameUnitUpperLower : NOT(EXISTS(UpperBoundValue)) OR NOT(EXISTS(LowerBoundValue)) OR
+(TYPEOF(UpperBoundValue) = TYPEOF(LowerBoundValue));
+	SameUnitUpperSet : NOT(EXISTS(UpperBoundValue)) OR NOT(EXISTS(SetPointValue)) OR
+(TYPEOF(UpperBoundValue) = TYPEOF(SetPointValue));
+	SameUnitLowerSet : NOT(EXISTS(LowerBoundValue)) OR NOT(EXISTS(SetPointValue)) OR
+(TYPEOF(LowerBoundValue) = TYPEOF(SetPointValue));
+END_ENTITY;
+
+ENTITY IfcPropertyDefinition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPropertySetDefinition
+    ,IfcPropertyTemplateDefinition))
+ SUBTYPE OF (IfcRoot);
+ INVERSE
+	HasContext : SET [0:1] OF IfcRelDeclares FOR RelatedDefinitions;
+	HasAssociations : SET [0:?] OF IfcRelAssociates FOR RelatedObjects;
+END_ENTITY;
+
+ENTITY IfcPropertyDependencyRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	DependingProperty : IfcProperty;
+	DependantProperty : IfcProperty;
+	Expression : OPTIONAL IfcText;
+ WHERE
+	NoSelfReference : DependingProperty :<>: DependantProperty;
+END_ENTITY;
+
+ENTITY IfcPropertyEnumeratedValue
+ SUBTYPE OF (IfcSimpleProperty);
+	EnumerationValues : OPTIONAL LIST [1:?] OF IfcValue;
+	EnumerationReference : OPTIONAL IfcPropertyEnumeration;
+ WHERE
+	WR21 : NOT(EXISTS(EnumerationReference)) 
+OR  NOT(EXISTS(EnumerationValues)) 
+OR  (SIZEOF(QUERY(temp <* EnumerationValues |
+    temp IN EnumerationReference.EnumerationValues))
+    = SIZEOF(EnumerationValues));
+END_ENTITY;
+
+ENTITY IfcPropertyEnumeration
+ SUBTYPE OF (IfcPropertyAbstraction);
+	Name : IfcLabel;
+	EnumerationValues : LIST [1:?] OF UNIQUE IfcValue;
+	Unit : OPTIONAL IfcUnit;
+ UNIQUE
+	UR1 : Name;
+ WHERE
+	WR01 : SIZEOF(QUERY(temp <* SELF.EnumerationValues | 
+  NOT(TYPEOF(SELF.EnumerationValues[1]) = TYPEOF(temp))
+  )) = 0;
+END_ENTITY;
+
+ENTITY IfcPropertyListValue
+ SUBTYPE OF (IfcSimpleProperty);
+	ListValues : OPTIONAL LIST [1:?] OF IfcValue;
+	Unit : OPTIONAL IfcUnit;
+ WHERE
+	WR31 : SIZEOF(QUERY(temp <* SELF.ListValues | 
+  NOT(TYPEOF(SELF.ListValues[1]) = TYPEOF(temp))
+  )) = 0;
+END_ENTITY;
+
+ENTITY IfcPropertyReferenceValue
+ SUBTYPE OF (IfcSimpleProperty);
+	UsageName : OPTIONAL IfcText;
+	PropertyReference : OPTIONAL IfcObjectReferenceSelect;
+END_ENTITY;
+
+ENTITY IfcPropertySet
+ SUBTYPE OF (IfcPropertySetDefinition);
+	HasProperties : SET [1:?] OF IfcProperty;
+ WHERE
+	ExistsName : EXISTS(SELF\IfcRoot.Name);
+	UniquePropertyNames : IfcUniquePropertyName(HasProperties);
+END_ENTITY;
+
+ENTITY IfcPropertySetDefinition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPreDefinedPropertySet
+    ,IfcPropertySet
+    ,IfcQuantitySet))
+ SUBTYPE OF (IfcPropertyDefinition);
+ INVERSE
+	DefinesType : SET [0:?] OF IfcTypeObject FOR HasPropertySets;
+	IsDefinedBy : SET [0:?] OF IfcRelDefinesByTemplate FOR RelatedPropertySets;
+	DefinesOccurrence : SET [0:?] OF IfcRelDefinesByProperties FOR RelatingPropertyDefinition;
+END_ENTITY;
+
+ENTITY IfcPropertySetTemplate
+ SUBTYPE OF (IfcPropertyTemplateDefinition);
+	TemplateType : OPTIONAL IfcPropertySetTemplateTypeEnum;
+	ApplicableEntity : OPTIONAL IfcIdentifier;
+	HasPropertyTemplates : SET [1:?] OF IfcPropertyTemplate;
+ INVERSE
+	Defines : SET [0:?] OF IfcRelDefinesByTemplate FOR RelatingTemplate;
+ WHERE
+	ExistsName : EXISTS(SELF\IfcRoot.Name);
+	UniquePropertyNames : IfcUniquePropertyTemplateNames(HasPropertyTemplates);
+END_ENTITY;
+
+ENTITY IfcPropertySingleValue
+ SUBTYPE OF (IfcSimpleProperty);
+	NominalValue : OPTIONAL IfcValue;
+	Unit : OPTIONAL IfcUnit;
+END_ENTITY;
+
+ENTITY IfcPropertyTableValue
+ SUBTYPE OF (IfcSimpleProperty);
+	DefiningValues : OPTIONAL LIST [1:?] OF UNIQUE IfcValue;
+	DefinedValues : OPTIONAL LIST [1:?] OF IfcValue;
+	Expression : OPTIONAL IfcText;
+	DefiningUnit : OPTIONAL IfcUnit;
+	DefinedUnit : OPTIONAL IfcUnit;
+	CurveInterpolation : OPTIONAL IfcCurveInterpolationEnum;
+ WHERE
+	WR21 : (NOT(EXISTS(DefiningValues)) AND NOT(EXISTS(DefinedValues)))
+OR (SIZEOF(DefiningValues) = SIZEOF(DefinedValues));
+	WR22 : NOT(EXISTS(DefiningValues)) OR 
+(SIZEOF(QUERY(temp <* SELF.DefiningValues | TYPEOF(temp) <> TYPEOF(SELF.DefiningValues[1])
+)) = 0);
+	WR23 : NOT(EXISTS(DefinedValues)) OR 
+(SIZEOF(QUERY(temp <* SELF.DefinedValues | TYPEOF(temp) <> TYPEOF(SELF.DefinedValues[1])
+)) = 0);
+END_ENTITY;
+
+ENTITY IfcPropertyTemplate
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcComplexPropertyTemplate
+    ,IfcSimplePropertyTemplate))
+ SUBTYPE OF (IfcPropertyTemplateDefinition);
+ INVERSE
+	PartOfComplexTemplate : SET [0:?] OF IfcComplexPropertyTemplate FOR HasPropertyTemplates;
+	PartOfPsetTemplate : SET [0:?] OF IfcPropertySetTemplate FOR HasPropertyTemplates;
+END_ENTITY;
+
+ENTITY IfcPropertyTemplateDefinition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPropertySetTemplate
+    ,IfcPropertyTemplate))
+ SUBTYPE OF (IfcPropertyDefinition);
+END_ENTITY;
+
+ENTITY IfcProtectiveDevice
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcProtectiveDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcProtectiveDeviceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcProtectiveDeviceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCPROTECTIVEDEVICETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcProtectiveDeviceTrippingUnit
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcProtectiveDeviceTrippingUnitTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCPROTECTIVEDEVICETRIPPINGUNITTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcProtectiveDeviceTrippingUnitType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcProtectiveDeviceTrippingUnitTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcProtectiveDeviceType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcProtectiveDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcProtectiveDeviceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcProtectiveDeviceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcProxy
+ SUBTYPE OF (IfcProduct);
+	ProxyType : IfcObjectTypeEnum;
+	Tag : OPTIONAL IfcLabel;
+ WHERE
+	WR1 : EXISTS(SELF\IfcRoot.Name);
+END_ENTITY;
+
+ENTITY IfcPump
+ SUBTYPE OF (IfcFlowMovingDevice);
+	PredefinedType : OPTIONAL IfcPumpTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcPumpTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcPumpTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCPUMPTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcPumpType
+ SUBTYPE OF (IfcFlowMovingDeviceType);
+	PredefinedType : IfcPumpTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcPumpTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcPumpTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcQuantityArea
+ SUBTYPE OF (IfcPhysicalSimpleQuantity);
+	AreaValue : IfcAreaMeasure;
+	Formula : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : NOT(EXISTS(SELF\IfcPhysicalSimpleQuantity.Unit)) OR
+   (SELF\IfcPhysicalSimpleQuantity.Unit.UnitType = IfcUnitEnum.AREAUNIT);
+	WR22 : AreaValue >= 0.;
+END_ENTITY;
+
+ENTITY IfcQuantityCount
+ SUBTYPE OF (IfcPhysicalSimpleQuantity);
+	CountValue : IfcCountMeasure;
+	Formula : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : CountValue >= 0.;
+END_ENTITY;
+
+ENTITY IfcQuantityLength
+ SUBTYPE OF (IfcPhysicalSimpleQuantity);
+	LengthValue : IfcLengthMeasure;
+	Formula : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : NOT(EXISTS(SELF\IfcPhysicalSimpleQuantity.Unit)) OR
+   (SELF\IfcPhysicalSimpleQuantity.Unit.UnitType = IfcUnitEnum.LENGTHUNIT);
+	WR22 : LengthValue >= 0.;
+END_ENTITY;
+
+ENTITY IfcQuantitySet
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcElementQuantity))
+ SUBTYPE OF (IfcPropertySetDefinition);
+END_ENTITY;
+
+ENTITY IfcQuantityTime
+ SUBTYPE OF (IfcPhysicalSimpleQuantity);
+	TimeValue : IfcTimeMeasure;
+	Formula : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : NOT(EXISTS(SELF\IfcPhysicalSimpleQuantity.Unit)) OR
+   (SELF\IfcPhysicalSimpleQuantity.Unit.UnitType = IfcUnitEnum.TIMEUNIT);
+	WR22 : TimeValue >= 0.;
+END_ENTITY;
+
+ENTITY IfcQuantityVolume
+ SUBTYPE OF (IfcPhysicalSimpleQuantity);
+	VolumeValue : IfcVolumeMeasure;
+	Formula : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : NOT(EXISTS(SELF\IfcPhysicalSimpleQuantity.Unit)) OR
+   (SELF\IfcPhysicalSimpleQuantity.Unit.UnitType = IfcUnitEnum.VOLUMEUNIT);
+	WR22 : VolumeValue >= 0.;
+END_ENTITY;
+
+ENTITY IfcQuantityWeight
+ SUBTYPE OF (IfcPhysicalSimpleQuantity);
+	WeightValue : IfcMassMeasure;
+	Formula : OPTIONAL IfcLabel;
+ WHERE
+	WR21 : NOT(EXISTS(SELF\IfcPhysicalSimpleQuantity.Unit)) OR
+   (SELF\IfcPhysicalSimpleQuantity.Unit.UnitType = IfcUnitEnum.MASSUNIT);
+	WR22 : WeightValue >= 0.;
+END_ENTITY;
+
+ENTITY IfcRailing
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcRailingTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcRailingTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcRailingTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCRAILINGTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcRailingType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcRailingTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcRailingTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcRailingTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcRamp
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcRampTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcRampTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcRampTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCRAMPTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcRampFlight
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcRampFlightTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcRampFlightTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcRampFlightTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCRAMPFLIGHTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcRampFlightType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcRampFlightTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcRampFlightTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcRampFlightTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcRampType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcRampTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcRampTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcRampTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcRationalBSplineCurveWithKnots
+ SUBTYPE OF (IfcBSplineCurveWithKnots);
+	WeightsData : LIST [2:?] OF IfcReal;
+ DERIVE
+	Weights : ARRAY [0:UpperIndexOnControlPoints] OF IfcReal := IfcListToArray(WeightsData,0,SELF\IfcBSplineCurve.UpperIndexOnControlPoints);
+ WHERE
+	SameNumOfWeightsAndPoints : SIZEOF(WeightsData) = SIZEOF(SELF\IfcBSplineCurve.ControlPointsList);
+	WeightsGreaterZero : IfcCurveWeightsPositive(SELF);
+END_ENTITY;
+
+ENTITY IfcRationalBSplineSurfaceWithKnots
+ SUBTYPE OF (IfcBSplineSurfaceWithKnots);
+	WeightsData : LIST [2:?] OF LIST [2:?] OF IfcReal;
+ DERIVE
+	Weights : ARRAY [0:UUpper] OF ARRAY [0:VUpper] OF IfcReal := IfcMakeArrayOfArray(WeightsData,0,UUpper,0,VUpper);
+ WHERE
+	CorrespondingWeightsDataLists : (SIZEOF(WeightsData) = SIZEOF(SELF\IfcBSplineSurface.ControlPointsList))
+AND 
+(SIZEOF(WeightsData[1]) = SIZEOF(SELF\IfcBSplineSurface.ControlPointsList[1]));
+	WeightValuesGreaterZero : IfcSurfaceWeightsPositive(SELF);
+END_ENTITY;
+
+ENTITY IfcRectangleHollowProfileDef
+ SUBTYPE OF (IfcRectangleProfileDef);
+	WallThickness : IfcPositiveLengthMeasure;
+	InnerFilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	OuterFilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+ WHERE
+	ValidWallThickness : (WallThickness < (SELF\IfcRectangleProfileDef.XDim/2.)) AND 
+(WallThickness < (SELF\IfcRectangleProfileDef.YDim/2.));
+	ValidInnerRadius : NOT(EXISTS(InnerFilletRadius)) OR 
+((InnerFilletRadius <= (SELF\IfcRectangleProfileDef.XDim/2. - WallThickness)) AND 
+ (InnerFilletRadius <= (SELF\IfcRectangleProfileDef.YDim/2. - WallThickness)));
+	ValidOuterRadius : NOT(EXISTS(OuterFilletRadius)) OR 
+((OuterFilletRadius <= (SELF\IfcRectangleProfileDef.XDim/2.)) AND 
+ (OuterFilletRadius <= (SELF\IfcRectangleProfileDef.YDim/2.)));
+END_ENTITY;
+
+ENTITY IfcRectangleProfileDef
+ SUPERTYPE OF (ONEOF
+    (IfcRectangleHollowProfileDef
+    ,IfcRoundedRectangleProfileDef))
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	XDim : IfcPositiveLengthMeasure;
+	YDim : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcRectangularPyramid
+ SUBTYPE OF (IfcCsgPrimitive3D);
+	XLength : IfcPositiveLengthMeasure;
+	YLength : IfcPositiveLengthMeasure;
+	Height : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcRectangularTrimmedSurface
+ SUBTYPE OF (IfcBoundedSurface);
+	BasisSurface : IfcSurface;
+	U1 : IfcParameterValue;
+	V1 : IfcParameterValue;
+	U2 : IfcParameterValue;
+	V2 : IfcParameterValue;
+	Usense : IfcBoolean;
+	Vsense : IfcBoolean;
+ WHERE
+	U1AndU2Different : U1 <> U2;
+	V1AndV2Different : V1 <> V2;
+	UsenseCompatible : (('IFC4.IFCELEMENTARYSURFACE' IN TYPEOF(BasisSurface)) AND
+         (NOT ('IFC4.IFCPLANE' IN TYPEOF(BasisSurface)))) OR
+         ('IFC4.IFCSURFACEOFREVOLUTION' IN TYPEOF(BasisSurface)) OR
+         (Usense = (U2 > U1));
+	VsenseCompatible : Vsense = (V2 > V1);
+END_ENTITY;
+
+ENTITY IfcRecurrencePattern;
+	RecurrenceType : IfcRecurrenceTypeEnum;
+	DayComponent : OPTIONAL SET [1:?] OF IfcDayInMonthNumber;
+	WeekdayComponent : OPTIONAL SET [1:?] OF IfcDayInWeekNumber;
+	MonthComponent : OPTIONAL SET [1:?] OF IfcMonthInYearNumber;
+	Position : OPTIONAL IfcInteger;
+	Interval : OPTIONAL IfcInteger;
+	Occurrences : OPTIONAL IfcInteger;
+	TimePeriods : OPTIONAL LIST [1:?] OF IfcTimePeriod;
+END_ENTITY;
+
+ENTITY IfcReference;
+	TypeIdentifier : OPTIONAL IfcIdentifier;
+	AttributeIdentifier : OPTIONAL IfcIdentifier;
+	InstanceName : OPTIONAL IfcLabel;
+	ListPositions : OPTIONAL LIST [1:?] OF IfcInteger;
+	InnerReference : OPTIONAL IfcReference;
+END_ENTITY;
+
+ENTITY IfcRegularTimeSeries
+ SUBTYPE OF (IfcTimeSeries);
+	TimeStep : IfcTimeMeasure;
+	Values : LIST [1:?] OF IfcTimeSeriesValue;
+END_ENTITY;
+
+ENTITY IfcReinforcementBarProperties
+ SUBTYPE OF (IfcPreDefinedProperties);
+	TotalCrossSectionArea : IfcAreaMeasure;
+	SteelGrade : IfcLabel;
+	BarSurface : OPTIONAL IfcReinforcingBarSurfaceEnum;
+	EffectiveDepth : OPTIONAL IfcLengthMeasure;
+	NominalBarDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	BarCount : OPTIONAL IfcCountMeasure;
+END_ENTITY;
+
+ENTITY IfcReinforcementDefinitionProperties
+ SUBTYPE OF (IfcPreDefinedPropertySet);
+	DefinitionType : OPTIONAL IfcLabel;
+	ReinforcementSectionDefinitions : LIST [1:?] OF IfcSectionReinforcementProperties;
+END_ENTITY;
+
+ENTITY IfcReinforcingBar
+ SUBTYPE OF (IfcReinforcingElement);
+	NominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	CrossSectionArea : OPTIONAL IfcAreaMeasure;
+	BarLength : OPTIONAL IfcPositiveLengthMeasure;
+	PredefinedType : OPTIONAL IfcReinforcingBarTypeEnum;
+	BarSurface : OPTIONAL IfcReinforcingBarSurfaceEnum;
+ WHERE
+	CorrectPredefinedType : NOT EXISTS(PredefinedType) OR
+(PredefinedType <> IfcReinforcingBarTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcReinforcingBarTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCREINFORCINGBARTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcReinforcingBarType
+ SUBTYPE OF (IfcReinforcingElementType);
+	PredefinedType : IfcReinforcingBarTypeEnum;
+	NominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	CrossSectionArea : OPTIONAL IfcAreaMeasure;
+	BarLength : OPTIONAL IfcPositiveLengthMeasure;
+	BarSurface : OPTIONAL IfcReinforcingBarSurfaceEnum;
+	BendingShapeCode : OPTIONAL IfcLabel;
+	BendingParameters : OPTIONAL LIST [1:?] OF IfcBendingParameterSelect;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcReinforcingBarTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcReinforcingBarTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+	BendingShapeCodeProvided : NOT EXISTS(BendingParameters) OR EXISTS(BendingShapeCode);
+END_ENTITY;
+
+ENTITY IfcReinforcingElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcReinforcingBar
+    ,IfcReinforcingMesh
+    ,IfcTendon
+    ,IfcTendonAnchor))
+ SUBTYPE OF (IfcElementComponent);
+	SteelGrade : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcReinforcingElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcReinforcingBarType
+    ,IfcReinforcingMeshType
+    ,IfcTendonAnchorType
+    ,IfcTendonType))
+ SUBTYPE OF (IfcElementComponentType);
+END_ENTITY;
+
+ENTITY IfcReinforcingMesh
+ SUBTYPE OF (IfcReinforcingElement);
+	MeshLength : OPTIONAL IfcPositiveLengthMeasure;
+	MeshWidth : OPTIONAL IfcPositiveLengthMeasure;
+	LongitudinalBarNominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	TransverseBarNominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	LongitudinalBarCrossSectionArea : OPTIONAL IfcAreaMeasure;
+	TransverseBarCrossSectionArea : OPTIONAL IfcAreaMeasure;
+	LongitudinalBarSpacing : OPTIONAL IfcPositiveLengthMeasure;
+	TransverseBarSpacing : OPTIONAL IfcPositiveLengthMeasure;
+	PredefinedType : OPTIONAL IfcReinforcingMeshTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT EXISTS(PredefinedType) OR
+(PredefinedType <> IfcReinforcingMeshTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcReinforcingMeshTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCREINFORCINGMESHTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcReinforcingMeshType
+ SUBTYPE OF (IfcReinforcingElementType);
+	PredefinedType : IfcReinforcingMeshTypeEnum;
+	MeshLength : OPTIONAL IfcPositiveLengthMeasure;
+	MeshWidth : OPTIONAL IfcPositiveLengthMeasure;
+	LongitudinalBarNominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	TransverseBarNominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	LongitudinalBarCrossSectionArea : OPTIONAL IfcAreaMeasure;
+	TransverseBarCrossSectionArea : OPTIONAL IfcAreaMeasure;
+	LongitudinalBarSpacing : OPTIONAL IfcPositiveLengthMeasure;
+	TransverseBarSpacing : OPTIONAL IfcPositiveLengthMeasure;
+	BendingShapeCode : OPTIONAL IfcLabel;
+	BendingParameters : OPTIONAL LIST [1:?] OF IfcBendingParameterSelect;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcReinforcingMeshTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcReinforcingMeshTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+	BendingShapeCodeProvided : NOT EXISTS(BendingParameters) OR EXISTS(BendingShapeCode);
+END_ENTITY;
+
+ENTITY IfcRelAggregates
+ SUBTYPE OF (IfcRelDecomposes);
+	RelatingObject : IfcObjectDefinition;
+	RelatedObjects : SET [1:?] OF IfcObjectDefinition;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* RelatedObjects | RelatingObject :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssigns
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcRelAssignsToActor
+    ,IfcRelAssignsToControl
+    ,IfcRelAssignsToGroup
+    ,IfcRelAssignsToProcess
+    ,IfcRelAssignsToProduct
+    ,IfcRelAssignsToResource))
+ SUBTYPE OF (IfcRelationship);
+	RelatedObjects : SET [1:?] OF IfcObjectDefinition;
+	RelatedObjectsType : OPTIONAL IfcObjectTypeEnum;
+ WHERE
+	WR1 : IfcCorrectObjectAssignment(RelatedObjectsType, RelatedObjects);
+END_ENTITY;
+
+ENTITY IfcRelAssignsToActor
+ SUBTYPE OF (IfcRelAssigns);
+	RelatingActor : IfcActor;
+	ActingRole : OPTIONAL IfcActorRole;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* SELF\IfcRelAssigns.RelatedObjects | RelatingActor :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssignsToControl
+ SUBTYPE OF (IfcRelAssigns);
+	RelatingControl : IfcControl;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* SELF\IfcRelAssigns.RelatedObjects | RelatingControl :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssignsToGroup
+ SUPERTYPE OF (ONEOF
+    (IfcRelAssignsToGroupByFactor))
+ SUBTYPE OF (IfcRelAssigns);
+	RelatingGroup : IfcGroup;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* SELF\IfcRelAssigns.RelatedObjects | RelatingGroup :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssignsToGroupByFactor
+ SUBTYPE OF (IfcRelAssignsToGroup);
+	Factor : IfcRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcRelAssignsToProcess
+ SUBTYPE OF (IfcRelAssigns);
+	RelatingProcess : IfcProcessSelect;
+	QuantityInProcess : OPTIONAL IfcMeasureWithUnit;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* SELF\IfcRelAssigns.RelatedObjects | RelatingProcess :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssignsToProduct
+ SUBTYPE OF (IfcRelAssigns);
+	RelatingProduct : IfcProductSelect;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* SELF\IfcRelAssigns.RelatedObjects | RelatingProduct :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssignsToResource
+ SUBTYPE OF (IfcRelAssigns);
+	RelatingResource : IfcResourceSelect;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* SELF\IfcRelAssigns.RelatedObjects | RelatingResource :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelAssociates
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcRelAssociatesApproval
+    ,IfcRelAssociatesClassification
+    ,IfcRelAssociatesConstraint
+    ,IfcRelAssociatesDocument
+    ,IfcRelAssociatesLibrary
+    ,IfcRelAssociatesMaterial))
+ SUBTYPE OF (IfcRelationship);
+	RelatedObjects : SET [1:?] OF IfcDefinitionSelect;
+END_ENTITY;
+
+ENTITY IfcRelAssociatesApproval
+ SUBTYPE OF (IfcRelAssociates);
+	RelatingApproval : IfcApproval;
+END_ENTITY;
+
+ENTITY IfcRelAssociatesClassification
+ SUBTYPE OF (IfcRelAssociates);
+	RelatingClassification : IfcClassificationSelect;
+END_ENTITY;
+
+ENTITY IfcRelAssociatesConstraint
+ SUBTYPE OF (IfcRelAssociates);
+	Intent : OPTIONAL IfcLabel;
+	RelatingConstraint : IfcConstraint;
+END_ENTITY;
+
+ENTITY IfcRelAssociatesDocument
+ SUBTYPE OF (IfcRelAssociates);
+	RelatingDocument : IfcDocumentSelect;
+END_ENTITY;
+
+ENTITY IfcRelAssociatesLibrary
+ SUBTYPE OF (IfcRelAssociates);
+	RelatingLibrary : IfcLibrarySelect;
+END_ENTITY;
+
+ENTITY IfcRelAssociatesMaterial
+ SUBTYPE OF (IfcRelAssociates);
+	RelatingMaterial : IfcMaterialSelect;
+ WHERE
+	NoVoidElement : SIZEOF(QUERY(temp <* SELF\IfcRelAssociates.RelatedObjects | 
+  ('IFC4.IFCFEATUREELEMENTSUBTRACTION' IN TYPEOF(temp)) OR 
+  ('IFC4.IFCVIRTUALELEMENT' IN TYPEOF(temp)) 
+)) = 0;
+	AllowedElements : SIZEOF(QUERY(temp <* SELF\IfcRelAssociates.RelatedObjects | (
+  SIZEOF(TYPEOF(temp) * [   
+    'IFC4.IFCELEMENT', 
+    'IFC4.IFCELEMENTTYPE',
+    'IFC4.IFCWINDOWSTYLE',
+    'IFC4.IFCDOORSTYLE',
+    'IFC4.IFCSTRUCTURALMEMBER',
+    'IFC4.IFCPORT']) = 0) 
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelConnects
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcRelConnectsElements
+    ,IfcRelConnectsPortToElement
+    ,IfcRelConnectsPorts
+    ,IfcRelConnectsStructuralActivity
+    ,IfcRelConnectsStructuralMember
+    ,IfcRelContainedInSpatialStructure
+    ,IfcRelCoversBldgElements
+    ,IfcRelCoversSpaces
+    ,IfcRelFillsElement
+    ,IfcRelFlowControlElements
+    ,IfcRelInterferesElements
+    ,IfcRelReferencedInSpatialStructure
+    ,IfcRelSequence
+    ,IfcRelServicesBuildings
+    ,IfcRelSpaceBoundary))
+ SUBTYPE OF (IfcRelationship);
+END_ENTITY;
+
+ENTITY IfcRelConnectsElements
+ SUPERTYPE OF (ONEOF
+    (IfcRelConnectsPathElements
+    ,IfcRelConnectsWithRealizingElements))
+ SUBTYPE OF (IfcRelConnects);
+	ConnectionGeometry : OPTIONAL IfcConnectionGeometry;
+	RelatingElement : IfcElement;
+	RelatedElement : IfcElement;
+ WHERE
+	NoSelfReference : RelatingElement :<>: RelatedElement;
+END_ENTITY;
+
+ENTITY IfcRelConnectsPathElements
+ SUBTYPE OF (IfcRelConnectsElements);
+	RelatingPriorities : LIST [0:?] OF IfcInteger;
+	RelatedPriorities : LIST [0:?] OF IfcInteger;
+	RelatedConnectionType : IfcConnectionTypeEnum;
+	RelatingConnectionType : IfcConnectionTypeEnum;
+ WHERE
+	NormalizedRelatingPriorities : (SIZEOF(RelatingPriorities) = 0)
+OR
+(SIZEOF (QUERY (temp <* RelatingPriorities
+  | {0 <= temp <= 100}
+  )) = SIZEOF(RelatingPriorities));
+	NormalizedRelatedPriorities : (SIZEOF(RelatedPriorities) = 0)
+OR
+(SIZEOF (QUERY (temp <* RelatedPriorities
+  | {0 <= temp <= 100}
+  )) = SIZEOF(RelatedPriorities));
+END_ENTITY;
+
+ENTITY IfcRelConnectsPortToElement
+ SUBTYPE OF (IfcRelConnects);
+	RelatingPort : IfcPort;
+	RelatedElement : IfcDistributionElement;
+END_ENTITY;
+
+ENTITY IfcRelConnectsPorts
+ SUBTYPE OF (IfcRelConnects);
+	RelatingPort : IfcPort;
+	RelatedPort : IfcPort;
+	RealizingElement : OPTIONAL IfcElement;
+ WHERE
+	NoSelfReference : RelatingPort :<>: RelatedPort;
+END_ENTITY;
+
+ENTITY IfcRelConnectsStructuralActivity
+ SUBTYPE OF (IfcRelConnects);
+	RelatingElement : IfcStructuralActivityAssignmentSelect;
+	RelatedStructuralActivity : IfcStructuralActivity;
+END_ENTITY;
+
+ENTITY IfcRelConnectsStructuralMember
+ SUPERTYPE OF (ONEOF
+    (IfcRelConnectsWithEccentricity))
+ SUBTYPE OF (IfcRelConnects);
+	RelatingStructuralMember : IfcStructuralMember;
+	RelatedStructuralConnection : IfcStructuralConnection;
+	AppliedCondition : OPTIONAL IfcBoundaryCondition;
+	AdditionalConditions : OPTIONAL IfcStructuralConnectionCondition;
+	SupportedLength : OPTIONAL IfcLengthMeasure;
+	ConditionCoordinateSystem : OPTIONAL IfcAxis2Placement3D;
+END_ENTITY;
+
+ENTITY IfcRelConnectsWithEccentricity
+ SUBTYPE OF (IfcRelConnectsStructuralMember);
+	ConnectionConstraint : IfcConnectionGeometry;
+END_ENTITY;
+
+ENTITY IfcRelConnectsWithRealizingElements
+ SUBTYPE OF (IfcRelConnectsElements);
+	RealizingElements : SET [1:?] OF IfcElement;
+	ConnectionType : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcRelContainedInSpatialStructure
+ SUBTYPE OF (IfcRelConnects);
+	RelatedElements : SET [1:?] OF IfcProduct;
+	RelatingStructure : IfcSpatialElement;
+ WHERE
+	WR31 : SIZEOF(QUERY(temp <* RelatedElements | 'IFC4.IFCSPATIALSTRUCTUREELEMENT' IN TYPEOF(temp))) = 0;
+END_ENTITY;
+
+ENTITY IfcRelCoversBldgElements
+ SUBTYPE OF (IfcRelConnects);
+	RelatingBuildingElement : IfcElement;
+	RelatedCoverings : SET [1:?] OF IfcCovering;
+END_ENTITY;
+
+ENTITY IfcRelCoversSpaces
+ SUBTYPE OF (IfcRelConnects);
+	RelatingSpace : IfcSpace;
+	RelatedCoverings : SET [1:?] OF IfcCovering;
+END_ENTITY;
+
+ENTITY IfcRelDeclares
+ SUBTYPE OF (IfcRelationship);
+	RelatingContext : IfcContext;
+	RelatedDefinitions : SET [1:?] OF IfcDefinitionSelect;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* RelatedDefinitions | RelatingContext :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelDecomposes
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcRelAggregates
+    ,IfcRelNests
+    ,IfcRelProjectsElement
+    ,IfcRelVoidsElement))
+ SUBTYPE OF (IfcRelationship);
+END_ENTITY;
+
+ENTITY IfcRelDefines
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcRelDefinesByObject
+    ,IfcRelDefinesByProperties
+    ,IfcRelDefinesByTemplate
+    ,IfcRelDefinesByType))
+ SUBTYPE OF (IfcRelationship);
+END_ENTITY;
+
+ENTITY IfcRelDefinesByObject
+ SUBTYPE OF (IfcRelDefines);
+	RelatedObjects : SET [1:?] OF IfcObject;
+	RelatingObject : IfcObject;
+END_ENTITY;
+
+ENTITY IfcRelDefinesByProperties
+ SUBTYPE OF (IfcRelDefines);
+	RelatedObjects : SET [1:?] OF IfcObjectDefinition;
+	RelatingPropertyDefinition : IfcPropertySetDefinitionSelect;
+ WHERE
+	NoRelatedTypeObject : SIZEOF(QUERY(Types <* SELF\IfcRelDefinesByProperties.RelatedObjects |  'IFC4.IFCTYPEOBJECT' IN TYPEOF(Types))) = 0;
+END_ENTITY;
+
+ENTITY IfcRelDefinesByTemplate
+ SUBTYPE OF (IfcRelDefines);
+	RelatedPropertySets : SET [1:?] OF IfcPropertySetDefinition;
+	RelatingTemplate : IfcPropertySetTemplate;
+END_ENTITY;
+
+ENTITY IfcRelDefinesByType
+ SUBTYPE OF (IfcRelDefines);
+	RelatedObjects : SET [1:?] OF IfcObject;
+	RelatingType : IfcTypeObject;
+END_ENTITY;
+
+ENTITY IfcRelFillsElement
+ SUBTYPE OF (IfcRelConnects);
+	RelatingOpeningElement : IfcOpeningElement;
+	RelatedBuildingElement : IfcElement;
+END_ENTITY;
+
+ENTITY IfcRelFlowControlElements
+ SUBTYPE OF (IfcRelConnects);
+	RelatedControlElements : SET [1:?] OF IfcDistributionControlElement;
+	RelatingFlowElement : IfcDistributionFlowElement;
+END_ENTITY;
+
+ENTITY IfcRelInterferesElements
+ SUBTYPE OF (IfcRelConnects);
+	RelatingElement : IfcElement;
+	RelatedElement : IfcElement;
+	InterferenceGeometry : OPTIONAL IfcConnectionGeometry;
+	InterferenceType : OPTIONAL IfcIdentifier;
+	ImpliedOrder : LOGICAL;
+ WHERE
+	NotSelfReference : RelatingElement :<>: RelatedElement;
+END_ENTITY;
+
+ENTITY IfcRelNests
+ SUBTYPE OF (IfcRelDecomposes);
+	RelatingObject : IfcObjectDefinition;
+	RelatedObjects : LIST [1:?] OF IfcObjectDefinition;
+ WHERE
+	NoSelfReference : SIZEOF(QUERY(Temp <* RelatedObjects | RelatingObject :=: Temp)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelProjectsElement
+ SUBTYPE OF (IfcRelDecomposes);
+	RelatingElement : IfcElement;
+	RelatedFeatureElement : IfcFeatureElementAddition;
+END_ENTITY;
+
+ENTITY IfcRelReferencedInSpatialStructure
+ SUBTYPE OF (IfcRelConnects);
+	RelatedElements : SET [1:?] OF IfcProduct;
+	RelatingStructure : IfcSpatialElement;
+ WHERE
+	AllowedRelatedElements : SIZEOF(QUERY(temp <* RelatedElements | ('IFC4.IFCSPATIALSTRUCTUREELEMENT' IN TYPEOF(temp)) AND (NOT ('IFC4.IFCSPACE' IN TYPEOF(temp)))
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcRelSequence
+ SUBTYPE OF (IfcRelConnects);
+	RelatingProcess : IfcProcess;
+	RelatedProcess : IfcProcess;
+	TimeLag : OPTIONAL IfcLagTime;
+	SequenceType : OPTIONAL IfcSequenceEnum;
+	UserDefinedSequenceType : OPTIONAL IfcLabel;
+ WHERE
+	AvoidInconsistentSequence : RelatingProcess :<>: RelatedProcess;
+	CorrectSequenceType : (SequenceType <> IfcSequenceEnum.USERDEFINED) OR ((SequenceType = IfcSequenceEnum.USERDEFINED) AND EXISTS(UserDefinedSequenceType));
+END_ENTITY;
+
+ENTITY IfcRelServicesBuildings
+ SUBTYPE OF (IfcRelConnects);
+	RelatingSystem : IfcSystem;
+	RelatedBuildings : SET [1:?] OF IfcSpatialElement;
+END_ENTITY;
+
+ENTITY IfcRelSpaceBoundary
+ SUPERTYPE OF (ONEOF
+    (IfcRelSpaceBoundary1stLevel))
+ SUBTYPE OF (IfcRelConnects);
+	RelatingSpace : IfcSpaceBoundarySelect;
+	RelatedBuildingElement : IfcElement;
+	ConnectionGeometry : OPTIONAL IfcConnectionGeometry;
+	PhysicalOrVirtualBoundary : IfcPhysicalOrVirtualEnum;
+	InternalOrExternalBoundary : IfcInternalOrExternalEnum;
+ WHERE
+	CorrectPhysOrVirt : ((PhysicalOrVirtualBoundary = IfcPhysicalOrVirtualEnum.Physical) 
+  AND (NOT('IFC4.IFCVIRTUALELEMENT' IN TYPEOF(RelatedBuildingElement)))) 
+OR 
+((PhysicalOrVirtualBoundary = IfcPhysicalOrVirtualEnum.Virtual) 
+  AND (('IFC4.IFCVIRTUALELEMENT' IN TYPEOF(RelatedBuildingElement)) 
+  OR   ('IFC4.IFCOPENINGELEMENT' IN TYPEOF(RelatedBuildingElement)))) 
+OR 
+(PhysicalOrVirtualBoundary = IfcPhysicalOrVirtualEnum.NotDefined);
+END_ENTITY;
+
+ENTITY IfcRelSpaceBoundary1stLevel
+ SUPERTYPE OF (ONEOF
+    (IfcRelSpaceBoundary2ndLevel))
+ SUBTYPE OF (IfcRelSpaceBoundary);
+	ParentBoundary : OPTIONAL IfcRelSpaceBoundary1stLevel;
+ INVERSE
+	InnerBoundaries : SET [0:?] OF IfcRelSpaceBoundary1stLevel FOR ParentBoundary;
+END_ENTITY;
+
+ENTITY IfcRelSpaceBoundary2ndLevel
+ SUBTYPE OF (IfcRelSpaceBoundary1stLevel);
+	CorrespondingBoundary : OPTIONAL IfcRelSpaceBoundary2ndLevel;
+ INVERSE
+	Corresponds : SET [0:1] OF IfcRelSpaceBoundary2ndLevel FOR CorrespondingBoundary;
+END_ENTITY;
+
+ENTITY IfcRelVoidsElement
+ SUBTYPE OF (IfcRelDecomposes);
+	RelatingBuildingElement : IfcElement;
+	RelatedOpeningElement : IfcFeatureElementSubtraction;
+END_ENTITY;
+
+ENTITY IfcRelationship
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcRelAssigns
+    ,IfcRelAssociates
+    ,IfcRelConnects
+    ,IfcRelDeclares
+    ,IfcRelDecomposes
+    ,IfcRelDefines))
+ SUBTYPE OF (IfcRoot);
+END_ENTITY;
+
+ENTITY IfcReparametrisedCompositeCurveSegment
+ SUBTYPE OF (IfcCompositeCurveSegment);
+	ParamLength : IfcParameterValue;
+ WHERE
+	PositiveLengthParameter : ParamLength > 0.0;
+END_ENTITY;
+
+ENTITY IfcRepresentation
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcShapeModel
+    ,IfcStyleModel));
+	ContextOfItems : IfcRepresentationContext;
+	RepresentationIdentifier : OPTIONAL IfcLabel;
+	RepresentationType : OPTIONAL IfcLabel;
+	Items : SET [1:?] OF IfcRepresentationItem;
+ INVERSE
+	RepresentationMap : SET [0:1] OF IfcRepresentationMap FOR MappedRepresentation;
+	LayerAssignments : SET [0:?] OF IfcPresentationLayerAssignment FOR AssignedItems;
+	OfProductRepresentation : SET [0:?] OF IfcProductRepresentation FOR Representations;
+END_ENTITY;
+
+ENTITY IfcRepresentationContext
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcGeometricRepresentationContext));
+	ContextIdentifier : OPTIONAL IfcLabel;
+	ContextType : OPTIONAL IfcLabel;
+ INVERSE
+	RepresentationsInContext : SET [0:?] OF IfcRepresentation FOR ContextOfItems;
+END_ENTITY;
+
+ENTITY IfcRepresentationItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcGeometricRepresentationItem
+    ,IfcMappedItem
+    ,IfcStyledItem
+    ,IfcTopologicalRepresentationItem));
+ INVERSE
+	LayerAssignment : SET [0:1] OF IfcPresentationLayerAssignment FOR AssignedItems;
+	StyledByItem : SET [0:1] OF IfcStyledItem FOR Item;
+END_ENTITY;
+
+ENTITY IfcRepresentationMap;
+	MappingOrigin : IfcAxis2Placement;
+	MappedRepresentation : IfcRepresentation;
+ INVERSE
+	HasShapeAspects : SET [0:?] OF IfcShapeAspect FOR PartOfProductDefinitionShape;
+	MapUsage : SET [0:?] OF IfcMappedItem FOR MappingSource;
+ WHERE
+	ApplicableMappedRepr : 'IFC4.IFCSHAPEMODEL' IN TYPEOF(MappedRepresentation);
+END_ENTITY;
+
+ENTITY IfcResource
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcConstructionResource))
+ SUBTYPE OF (IfcObject);
+	Identification : OPTIONAL IfcIdentifier;
+	LongDescription : OPTIONAL IfcText;
+ INVERSE
+	ResourceOf : SET [0:?] OF IfcRelAssignsToResource FOR RelatingResource;
+END_ENTITY;
+
+ENTITY IfcResourceApprovalRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatedResourceObjects : SET [1:?] OF IfcResourceObjectSelect;
+	RelatingApproval : IfcApproval;
+END_ENTITY;
+
+ENTITY IfcResourceConstraintRelationship
+ SUBTYPE OF (IfcResourceLevelRelationship);
+	RelatingConstraint : IfcConstraint;
+	RelatedResourceObjects : SET [1:?] OF IfcResourceObjectSelect;
+END_ENTITY;
+
+ENTITY IfcResourceLevelRelationship
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcApprovalRelationship
+    ,IfcCurrencyRelationship
+    ,IfcDocumentInformationRelationship
+    ,IfcExternalReferenceRelationship
+    ,IfcMaterialRelationship
+    ,IfcOrganizationRelationship
+    ,IfcPropertyDependencyRelationship
+    ,IfcResourceApprovalRelationship
+    ,IfcResourceConstraintRelationship));
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+END_ENTITY;
+
+ENTITY IfcResourceTime
+ SUBTYPE OF (IfcSchedulingTime);
+	ScheduleWork : OPTIONAL IfcDuration;
+	ScheduleUsage : OPTIONAL IfcPositiveRatioMeasure;
+	ScheduleStart : OPTIONAL IfcDateTime;
+	ScheduleFinish : OPTIONAL IfcDateTime;
+	ScheduleContour : OPTIONAL IfcLabel;
+	LevelingDelay : OPTIONAL IfcDuration;
+	IsOverAllocated : OPTIONAL IfcBoolean;
+	StatusTime : OPTIONAL IfcDateTime;
+	ActualWork : OPTIONAL IfcDuration;
+	ActualUsage : OPTIONAL IfcPositiveRatioMeasure;
+	ActualStart : OPTIONAL IfcDateTime;
+	ActualFinish : OPTIONAL IfcDateTime;
+	RemainingWork : OPTIONAL IfcDuration;
+	RemainingUsage : OPTIONAL IfcPositiveRatioMeasure;
+	Completion : OPTIONAL IfcPositiveRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcRevolvedAreaSolid
+ SUPERTYPE OF (ONEOF
+    (IfcRevolvedAreaSolidTapered))
+ SUBTYPE OF (IfcSweptAreaSolid);
+	Axis : IfcAxis1Placement;
+	Angle : IfcPlaneAngleMeasure;
+ DERIVE
+	AxisLine : IfcLine := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcCurve() || IfcLine(Axis.Location, 
+  IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(Axis.Z,1.0));
+ WHERE
+	AxisStartInXY : Axis.Location.Coordinates[3] = 0.0;
+	AxisDirectionInXY : Axis.Z.DirectionRatios[3] = 0.0;
+END_ENTITY;
+
+ENTITY IfcRevolvedAreaSolidTapered
+ SUBTYPE OF (IfcRevolvedAreaSolid);
+	EndSweptArea : IfcProfileDef;
+ WHERE
+	CorrectProfileAssignment : IfcTaperedSweptAreaProfiles(SELF\IfcSweptAreaSolid.SweptArea, SELF.EndSweptArea);
+END_ENTITY;
+
+ENTITY IfcRightCircularCone
+ SUBTYPE OF (IfcCsgPrimitive3D);
+	Height : IfcPositiveLengthMeasure;
+	BottomRadius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcRightCircularCylinder
+ SUBTYPE OF (IfcCsgPrimitive3D);
+	Height : IfcPositiveLengthMeasure;
+	Radius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcRoof
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcRoofTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcRoofTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcRoofTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCROOFTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcRoofType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcRoofTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcRoofTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcRoofTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcRoot
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcObjectDefinition
+    ,IfcPropertyDefinition
+    ,IfcRelationship));
+	GlobalId : IfcGloballyUniqueId;
+	OwnerHistory : OPTIONAL IfcOwnerHistory;
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+ UNIQUE
+	UR1 : GlobalId;
+END_ENTITY;
+
+ENTITY IfcRoundedRectangleProfileDef
+ SUBTYPE OF (IfcRectangleProfileDef);
+	RoundingRadius : IfcPositiveLengthMeasure;
+ WHERE
+	ValidRadius : ((RoundingRadius <= (SELF\IfcRectangleProfileDef.XDim/2.)) AND 
+ (RoundingRadius <= (SELF\IfcRectangleProfileDef.YDim/2.)));
+END_ENTITY;
+
+ENTITY IfcSIUnit
+ SUBTYPE OF (IfcNamedUnit);
+	Prefix : OPTIONAL IfcSIPrefix;
+	Name : IfcSIUnitName;
+ DERIVE
+	SELF\IfcNamedUnit.Dimensions : IfcDimensionalExponents := IfcDimensionsForSiUnit (SELF.Name);
+END_ENTITY;
+
+ENTITY IfcSanitaryTerminal
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcSanitaryTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSanitaryTerminalTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSanitaryTerminalTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCSANITARYTERMINALTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSanitaryTerminalType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcSanitaryTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSanitaryTerminalTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSanitaryTerminalTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSchedulingTime
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcEventTime
+    ,IfcLagTime
+    ,IfcResourceTime
+    ,IfcTaskTime
+    ,IfcWorkTime));
+	Name : OPTIONAL IfcLabel;
+	DataOrigin : OPTIONAL IfcDataOriginEnum;
+	UserDefinedDataOrigin : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcSeamCurve
+ SUBTYPE OF (IfcSurfaceCurve);
+ WHERE
+	TwoPCurves : SIZEOF(SELF\IfcSurfaceCurve.AssociatedGeometry) = 2;
+	SameSurface : IfcAssociatedSurface(SELF\IfcSurfaceCurve.AssociatedGeometry[1]) = IfcAssociatedSurface(SELF\IfcSurfaceCurve.AssociatedGeometry[2]);
+END_ENTITY;
+
+ENTITY IfcSectionProperties
+ SUBTYPE OF (IfcPreDefinedProperties);
+	SectionType : IfcSectionTypeEnum;
+	StartProfile : IfcProfileDef;
+	EndProfile : OPTIONAL IfcProfileDef;
+END_ENTITY;
+
+ENTITY IfcSectionReinforcementProperties
+ SUBTYPE OF (IfcPreDefinedProperties);
+	LongitudinalStartPosition : IfcLengthMeasure;
+	LongitudinalEndPosition : IfcLengthMeasure;
+	TransversePosition : OPTIONAL IfcLengthMeasure;
+	ReinforcementRole : IfcReinforcingBarRoleEnum;
+	SectionDefinition : IfcSectionProperties;
+	CrossSectionReinforcementDefinitions : SET [1:?] OF IfcReinforcementBarProperties;
+END_ENTITY;
+
+ENTITY IfcSectionedSpine
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	SpineCurve : IfcCompositeCurve;
+	CrossSections : LIST [2:?] OF IfcProfileDef;
+	CrossSectionPositions : LIST [2:?] OF IfcAxis2Placement3D;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+ WHERE
+	CorrespondingSectionPositions : SIZEOF(CrossSections) = SIZEOF(CrossSectionPositions);
+	ConsistentProfileTypes : SIZEOF(QUERY(temp <* CrossSections | CrossSections[1].ProfileType <> temp.ProfileType)) = 0;
+	SpineCurveDim : SpineCurve.Dim = 3;
+END_ENTITY;
+
+ENTITY IfcSensor
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcSensorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSensorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSensorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCSENSORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSensorType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcSensorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSensorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSensorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcShadingDevice
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcShadingDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcShadingDeviceTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcShadingDeviceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCSHADINGDEVICETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcShadingDeviceType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcShadingDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcShadingDeviceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcShadingDeviceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcShapeAspect;
+	ShapeRepresentations : LIST [1:?] OF IfcShapeModel;
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	ProductDefinitional : IfcLogical;
+	PartOfProductDefinitionShape : OPTIONAL IfcProductRepresentationSelect;
+END_ENTITY;
+
+ENTITY IfcShapeModel
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcShapeRepresentation
+    ,IfcTopologyRepresentation))
+ SUBTYPE OF (IfcRepresentation);
+ INVERSE
+	OfShapeAspect : SET [0:1] OF IfcShapeAspect FOR ShapeRepresentations;
+ WHERE
+	WR11 : (SIZEOF(SELF\IfcRepresentation.OfProductRepresentation) = 1) XOR 
+(SIZEOF(SELF\IfcRepresentation.RepresentationMap) = 1) XOR
+(SIZEOF(OfShapeAspect) = 1);
+END_ENTITY;
+
+ENTITY IfcShapeRepresentation
+ SUBTYPE OF (IfcShapeModel);
+ WHERE
+	CorrectContext : 'IFC4.IFCGEOMETRICREPRESENTATIONCONTEXT' 
+IN TYPEOF(SELF\IfcRepresentation.ContextOfItems);
+	NoTopologicalItem : SIZEOF(QUERY(temp <* Items | 
+  ('IFC4.IFCTOPOLOGICALREPRESENTATIONITEM' IN TYPEOF(temp))
+    AND (NOT(SIZEOF(
+      ['IFC4.IFCVERTEXPOINT',
+       'IFC4.IFCEDGECURVE',
+       'IFC4.IFCFACESURFACE'] * TYPEOF(temp)) = 1))
+)) = 0;
+	HasRepresentationType : EXISTS(SELF\IfcRepresentation.RepresentationType);
+	HasRepresentationIdentifier : EXISTS(SELF\IfcRepresentation.RepresentationIdentifier);
+	CorrectItemsForType : IfcShapeRepresentationTypes(SELF\IfcRepresentation.RepresentationType, SELF\IfcRepresentation.Items);
+END_ENTITY;
+
+ENTITY IfcShellBasedSurfaceModel
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	SbsmBoundary : SET [1:?] OF IfcShell;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcSimpleProperty
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPropertyBoundedValue
+    ,IfcPropertyEnumeratedValue
+    ,IfcPropertyListValue
+    ,IfcPropertyReferenceValue
+    ,IfcPropertySingleValue
+    ,IfcPropertyTableValue))
+ SUBTYPE OF (IfcProperty);
+END_ENTITY;
+
+ENTITY IfcSimplePropertyTemplate
+ SUBTYPE OF (IfcPropertyTemplate);
+	TemplateType : OPTIONAL IfcSimplePropertyTemplateTypeEnum;
+	PrimaryMeasureType : OPTIONAL IfcLabel;
+	SecondaryMeasureType : OPTIONAL IfcLabel;
+	Enumerators : OPTIONAL IfcPropertyEnumeration;
+	PrimaryUnit : OPTIONAL IfcUnit;
+	SecondaryUnit : OPTIONAL IfcUnit;
+	Expression : OPTIONAL IfcLabel;
+	AccessState : OPTIONAL IfcStateEnum;
+END_ENTITY;
+
+ENTITY IfcSite
+ SUBTYPE OF (IfcSpatialStructureElement);
+	RefLatitude : OPTIONAL IfcCompoundPlaneAngleMeasure;
+	RefLongitude : OPTIONAL IfcCompoundPlaneAngleMeasure;
+	RefElevation : OPTIONAL IfcLengthMeasure;
+	LandTitleNumber : OPTIONAL IfcLabel;
+	SiteAddress : OPTIONAL IfcPostalAddress;
+END_ENTITY;
+
+ENTITY IfcSlab
+ SUPERTYPE OF (ONEOF
+    (IfcSlabElementedCase
+    ,IfcSlabStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcSlabTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcSlabTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcSlabTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCSLABTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSlabElementedCase
+ SUBTYPE OF (IfcSlab);
+ WHERE
+	HasDecomposition : HIINDEX(SELF\IfcObjectDefinition.IsDecomposedBy) > 0;
+END_ENTITY;
+
+ENTITY IfcSlabStandardCase
+ SUBTYPE OF (IfcSlab);
+ WHERE
+	HasMaterialLayerSetusage : SIZEOF (QUERY(temp <* USEDIN(SELF, 'IFC4.IFCRELASSOCIATES.RELATEDOBJECTS') |
+              ('IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)) AND
+              ('IFC4.IFCMATERIALLAYERSETUSAGE' IN TYPEOF(temp.RelatingMaterial))
+              )) = 1;
+END_ENTITY;
+
+ENTITY IfcSlabType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcSlabTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSlabTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSlabTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSlippageConnectionCondition
+ SUBTYPE OF (IfcStructuralConnectionCondition);
+	SlippageX : OPTIONAL IfcLengthMeasure;
+	SlippageY : OPTIONAL IfcLengthMeasure;
+	SlippageZ : OPTIONAL IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcSolarDevice
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcSolarDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSolarDeviceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSolarDeviceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCSOLARDEVICETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSolarDeviceType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcSolarDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSolarDeviceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSolarDeviceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSolidModel
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcCsgSolid
+    ,IfcManifoldSolidBrep
+    ,IfcSweptAreaSolid
+    ,IfcSweptDiskSolid))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcSpace
+ SUBTYPE OF (IfcSpatialStructureElement);
+	PredefinedType : OPTIONAL IfcSpaceTypeEnum;
+	ElevationWithFlooring : OPTIONAL IfcLengthMeasure;
+ INVERSE
+	HasCoverings : SET [0:?] OF IfcRelCoversSpaces FOR RelatingSpace;
+	BoundedBy : SET [0:?] OF IfcRelSpaceBoundary FOR RelatingSpace;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcSpaceTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcSpaceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCSPACETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSpaceHeater
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcSpaceHeaterTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSpaceHeaterTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSpaceHeaterTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCSPACEHEATERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSpaceHeaterType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcSpaceHeaterTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSpaceHeaterTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSpaceHeaterTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSpaceType
+ SUBTYPE OF (IfcSpatialStructureElementType);
+	PredefinedType : IfcSpaceTypeEnum;
+	LongName : OPTIONAL IfcLabel;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSpaceTypeEnum.USERDEFINED) OR 
+((PredefinedType = IfcSpaceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcSpatialElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSpatialElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcExternalSpatialStructureElement
+    ,IfcSpatialStructureElement
+    ,IfcSpatialZone))
+ SUBTYPE OF (IfcProduct);
+	LongName : OPTIONAL IfcLabel;
+ INVERSE
+	ContainsElements : SET [0:?] OF IfcRelContainedInSpatialStructure FOR RelatingStructure;
+	ServicedBySystems : SET [0:?] OF IfcRelServicesBuildings FOR RelatedBuildings;
+	ReferencesElements : SET [0:?] OF IfcRelReferencedInSpatialStructure FOR RelatingStructure;
+END_ENTITY;
+
+ENTITY IfcSpatialElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcSpatialStructureElementType
+    ,IfcSpatialZoneType))
+ SUBTYPE OF (IfcTypeProduct);
+	ElementType : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcSpatialStructureElement
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBuilding
+    ,IfcBuildingStorey
+    ,IfcSite
+    ,IfcSpace))
+ SUBTYPE OF (IfcSpatialElement);
+	CompositionType : OPTIONAL IfcElementCompositionEnum;
+ WHERE
+	WR41 : (HIINDEX(SELF\IfcObjectDefinition.Decomposes) = 1) 
+AND
+('IFC4.IFCRELAGGREGATES' IN TYPEOF(SELF\IfcObjectDefinition.Decomposes[1])) 
+AND
+(('IFC4.IFCPROJECT' IN TYPEOF (SELF\IfcObjectDefinition.Decomposes[1].RelatingObject)) OR
+ ('IFC4.IFCSPATIALSTRUCTUREELEMENT' IN TYPEOF (SELF\IfcObjectDefinition.Decomposes[1].RelatingObject))
+);
+END_ENTITY;
+
+ENTITY IfcSpatialStructureElementType
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcSpaceType))
+ SUBTYPE OF (IfcSpatialElementType);
+END_ENTITY;
+
+ENTITY IfcSpatialZone
+ SUBTYPE OF (IfcSpatialElement);
+	PredefinedType : OPTIONAL IfcSpatialZoneTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcSpatialZoneTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcSpatialZoneTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCSPATIALZONETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSpatialZoneType
+ SUBTYPE OF (IfcSpatialElementType);
+	PredefinedType : IfcSpatialZoneTypeEnum;
+	LongName : OPTIONAL IfcLabel;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSpatialZoneTypeEnum.USERDEFINED) OR 
+((PredefinedType = IfcSpatialZoneTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcSpatialElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSphere
+ SUBTYPE OF (IfcCsgPrimitive3D);
+	Radius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcSphericalSurface
+ SUBTYPE OF (IfcElementarySurface);
+	Radius : IfcPositiveLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcStackTerminal
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcStackTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcStackTerminalTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcStackTerminalTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCSTACKTERMINALTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcStackTerminalType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcStackTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcStackTerminalTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcStackTerminalTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcStair
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcStairTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcStairTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcStairTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCSTAIRTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcStairFlight
+ SUBTYPE OF (IfcBuildingElement);
+	NumberOfRisers : OPTIONAL IfcInteger;
+	NumberOfTreads : OPTIONAL IfcInteger;
+	RiserHeight : OPTIONAL IfcPositiveLengthMeasure;
+	TreadLength : OPTIONAL IfcPositiveLengthMeasure;
+	PredefinedType : OPTIONAL IfcStairFlightTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcStairFlightTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcStairFlightTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCSTAIRFLIGHTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcStairFlightType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcStairFlightTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcStairFlightTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcStairFlightTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcStairType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcStairTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcStairTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcStairTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcStructuralAction
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralCurveAction
+    ,IfcStructuralPointAction
+    ,IfcStructuralSurfaceAction))
+ SUBTYPE OF (IfcStructuralActivity);
+	DestabilizingLoad : OPTIONAL IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcStructuralActivity
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralAction
+    ,IfcStructuralReaction))
+ SUBTYPE OF (IfcProduct);
+	AppliedLoad : IfcStructuralLoad;
+	GlobalOrLocal : IfcGlobalOrLocalEnum;
+ INVERSE
+	AssignedToStructuralItem : SET [0:1] OF IfcRelConnectsStructuralActivity FOR RelatedStructuralActivity;
+END_ENTITY;
+
+ENTITY IfcStructuralAnalysisModel
+ SUBTYPE OF (IfcSystem);
+	PredefinedType : IfcAnalysisModelTypeEnum;
+	OrientationOf2DPlane : OPTIONAL IfcAxis2Placement3D;
+	LoadedBy : OPTIONAL SET [1:?] OF IfcStructuralLoadGroup;
+	HasResults : OPTIONAL SET [1:?] OF IfcStructuralResultGroup;
+	SharedPlacement : OPTIONAL IfcObjectPlacement;
+ WHERE
+	HasObjectType : (PredefinedType <> IfcAnalysisModelTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStructuralConnection
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralCurveConnection
+    ,IfcStructuralPointConnection
+    ,IfcStructuralSurfaceConnection))
+ SUBTYPE OF (IfcStructuralItem);
+	AppliedCondition : OPTIONAL IfcBoundaryCondition;
+ INVERSE
+	ConnectsStructuralMembers : SET [1:?] OF IfcRelConnectsStructuralMember FOR RelatedStructuralConnection;
+END_ENTITY;
+
+ENTITY IfcStructuralConnectionCondition
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcFailureConnectionCondition
+    ,IfcSlippageConnectionCondition));
+	Name : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcStructuralCurveAction
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralLinearAction))
+ SUBTYPE OF (IfcStructuralAction);
+	ProjectedOrTrue : OPTIONAL IfcProjectedOrTrueLengthEnum;
+	PredefinedType : IfcStructuralCurveActivityTypeEnum;
+ WHERE
+	ProjectedIsGlobal : (NOT EXISTS(ProjectedOrTrue)) OR
+((ProjectedOrTrue <> PROJECTED_LENGTH) OR
+ (SELF\IfcStructuralActivity.GlobalOrLocal = GLOBAL_COORDS));
+	HasObjectType : (PredefinedType <> IfcStructuralCurveActivityTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+	SuitablePredefinedType : PredefinedType <> IfcStructuralCurveActivityTypeEnum.EQUIDISTANT;
+END_ENTITY;
+
+ENTITY IfcStructuralCurveConnection
+ SUBTYPE OF (IfcStructuralConnection);
+	Axis : IfcDirection;
+END_ENTITY;
+
+ENTITY IfcStructuralCurveMember
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralCurveMemberVarying))
+ SUBTYPE OF (IfcStructuralMember);
+	PredefinedType : IfcStructuralCurveMemberTypeEnum;
+	Axis : IfcDirection;
+ WHERE
+	HasObjectType : (PredefinedType <> IfcStructuralCurveMemberTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStructuralCurveMemberVarying
+ SUBTYPE OF (IfcStructuralCurveMember);
+END_ENTITY;
+
+ENTITY IfcStructuralCurveReaction
+ SUBTYPE OF (IfcStructuralReaction);
+	PredefinedType : IfcStructuralCurveActivityTypeEnum;
+ WHERE
+	HasObjectType : (PredefinedType <> IfcStructuralCurveActivityTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+	SuitablePredefinedType : (PredefinedType <> IfcStructuralCurveActivityTypeEnum.SINUS) AND (PredefinedType <> IfcStructuralCurveActivityTypeEnum.PARABOLA);
+END_ENTITY;
+
+ENTITY IfcStructuralItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralConnection
+    ,IfcStructuralMember))
+ SUBTYPE OF (IfcProduct);
+ INVERSE
+	AssignedStructuralActivity : SET [0:?] OF IfcRelConnectsStructuralActivity FOR RelatingElement;
+END_ENTITY;
+
+ENTITY IfcStructuralLinearAction
+ SUBTYPE OF (IfcStructuralCurveAction);
+ WHERE
+	SuitableLoadType : SIZEOF(['IFC4.IFCSTRUCTURALLOADLINEARFORCE', 'IFC4.IFCSTRUCTURALLOADTEMPERATURE'] * TYPEOF(SELF\IfcStructuralActivity.AppliedLoad)) = 1;
+	ConstPredefinedType : SELF\IfcStructuralCurveAction.PredefinedType = IfcStructuralCurveActivityTypeEnum.CONST;
+END_ENTITY;
+
+ENTITY IfcStructuralLoad
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralLoadConfiguration
+    ,IfcStructuralLoadOrResult));
+	Name : OPTIONAL IfcLabel;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadCase
+ SUBTYPE OF (IfcStructuralLoadGroup);
+	SelfWeightCoefficients : OPTIONAL LIST [3:3] OF IfcRatioMeasure;
+ WHERE
+	IsLoadCasePredefinedType : SELF\IfcStructuralLoadGroup.PredefinedType = IfcLoadGroupTypeEnum.LOAD_CASE;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadConfiguration
+ SUBTYPE OF (IfcStructuralLoad);
+	Values : LIST [1:?] OF IfcStructuralLoadOrResult;
+	Locations : OPTIONAL LIST [1:?] OF UNIQUE LIST [1:2] OF IfcLengthMeasure;
+ WHERE
+	ValidListSize : NOT EXISTS(Locations) OR (SIZEOF(Locations) = SIZEOF(Values));
+END_ENTITY;
+
+ENTITY IfcStructuralLoadGroup
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralLoadCase))
+ SUBTYPE OF (IfcGroup);
+	PredefinedType : IfcLoadGroupTypeEnum;
+	ActionType : IfcActionTypeEnum;
+	ActionSource : IfcActionSourceTypeEnum;
+	Coefficient : OPTIONAL IfcRatioMeasure;
+	Purpose : OPTIONAL IfcLabel;
+ INVERSE
+	SourceOfResultGroup : SET [0:1] OF IfcStructuralResultGroup FOR ResultForLoadGroup;
+	LoadGroupFor : SET [0:?] OF IfcStructuralAnalysisModel FOR LoadedBy;
+ WHERE
+	HasObjectType : (
+  (PredefinedType <> IfcLoadGroupTypeEnum.USERDEFINED) AND
+  (ActionType <> IfcActionTypeEnum.USERDEFINED) AND
+  (ActionSource <> IfcActionSourceTypeEnum.USERDEFINED)
+) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStructuralLoadLinearForce
+ SUBTYPE OF (IfcStructuralLoadStatic);
+	LinearForceX : OPTIONAL IfcLinearForceMeasure;
+	LinearForceY : OPTIONAL IfcLinearForceMeasure;
+	LinearForceZ : OPTIONAL IfcLinearForceMeasure;
+	LinearMomentX : OPTIONAL IfcLinearMomentMeasure;
+	LinearMomentY : OPTIONAL IfcLinearMomentMeasure;
+	LinearMomentZ : OPTIONAL IfcLinearMomentMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadOrResult
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralLoadStatic
+    ,IfcSurfaceReinforcementArea))
+ SUBTYPE OF (IfcStructuralLoad);
+END_ENTITY;
+
+ENTITY IfcStructuralLoadPlanarForce
+ SUBTYPE OF (IfcStructuralLoadStatic);
+	PlanarForceX : OPTIONAL IfcPlanarForceMeasure;
+	PlanarForceY : OPTIONAL IfcPlanarForceMeasure;
+	PlanarForceZ : OPTIONAL IfcPlanarForceMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadSingleDisplacement
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralLoadSingleDisplacementDistortion))
+ SUBTYPE OF (IfcStructuralLoadStatic);
+	DisplacementX : OPTIONAL IfcLengthMeasure;
+	DisplacementY : OPTIONAL IfcLengthMeasure;
+	DisplacementZ : OPTIONAL IfcLengthMeasure;
+	RotationalDisplacementRX : OPTIONAL IfcPlaneAngleMeasure;
+	RotationalDisplacementRY : OPTIONAL IfcPlaneAngleMeasure;
+	RotationalDisplacementRZ : OPTIONAL IfcPlaneAngleMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadSingleDisplacementDistortion
+ SUBTYPE OF (IfcStructuralLoadSingleDisplacement);
+	Distortion : OPTIONAL IfcCurvatureMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadSingleForce
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralLoadSingleForceWarping))
+ SUBTYPE OF (IfcStructuralLoadStatic);
+	ForceX : OPTIONAL IfcForceMeasure;
+	ForceY : OPTIONAL IfcForceMeasure;
+	ForceZ : OPTIONAL IfcForceMeasure;
+	MomentX : OPTIONAL IfcTorqueMeasure;
+	MomentY : OPTIONAL IfcTorqueMeasure;
+	MomentZ : OPTIONAL IfcTorqueMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadSingleForceWarping
+ SUBTYPE OF (IfcStructuralLoadSingleForce);
+	WarpingMoment : OPTIONAL IfcWarpingMomentMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralLoadStatic
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralLoadLinearForce
+    ,IfcStructuralLoadPlanarForce
+    ,IfcStructuralLoadSingleDisplacement
+    ,IfcStructuralLoadSingleForce
+    ,IfcStructuralLoadTemperature))
+ SUBTYPE OF (IfcStructuralLoadOrResult);
+END_ENTITY;
+
+ENTITY IfcStructuralLoadTemperature
+ SUBTYPE OF (IfcStructuralLoadStatic);
+	DeltaTConstant : OPTIONAL IfcThermodynamicTemperatureMeasure;
+	DeltaTY : OPTIONAL IfcThermodynamicTemperatureMeasure;
+	DeltaTZ : OPTIONAL IfcThermodynamicTemperatureMeasure;
+END_ENTITY;
+
+ENTITY IfcStructuralMember
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralCurveMember
+    ,IfcStructuralSurfaceMember))
+ SUBTYPE OF (IfcStructuralItem);
+ INVERSE
+	ConnectedBy : SET [0:?] OF IfcRelConnectsStructuralMember FOR RelatingStructuralMember;
+END_ENTITY;
+
+ENTITY IfcStructuralPlanarAction
+ SUBTYPE OF (IfcStructuralSurfaceAction);
+ WHERE
+	SuitableLoadType : SIZEOF(['IFC4.IFCSTRUCTURALLOADPLANARFORCE', 'IFC4.IFCSTRUCTURALLOADTEMPERATURE'] * TYPEOF(SELF\IfcStructuralActivity.AppliedLoad)) = 1;
+	ConstPredefinedType : SELF\IfcStructuralSurfaceAction.PredefinedType = IfcStructuralSurfaceActivityTypeEnum.CONST;
+END_ENTITY;
+
+ENTITY IfcStructuralPointAction
+ SUBTYPE OF (IfcStructuralAction);
+ WHERE
+	SuitableLoadType : SIZEOF(['IFC4.IFCSTRUCTURALLOADSINGLEFORCE', 'IFC4.IFCSTRUCTURALLOADSINGLEDISPLACEMENT'] * TYPEOF(SELF\IfcStructuralActivity.AppliedLoad)) = 1;
+END_ENTITY;
+
+ENTITY IfcStructuralPointConnection
+ SUBTYPE OF (IfcStructuralConnection);
+	ConditionCoordinateSystem : OPTIONAL IfcAxis2Placement3D;
+END_ENTITY;
+
+ENTITY IfcStructuralPointReaction
+ SUBTYPE OF (IfcStructuralReaction);
+ WHERE
+	SuitableLoadType : SIZEOF(['IFC4.IFCSTRUCTURALLOADSINGLEFORCE', 'IFC4.IFCSTRUCTURALLOADSINGLEDISPLACEMENT'] * TYPEOF(SELF\IfcStructuralActivity.AppliedLoad)) = 1;
+END_ENTITY;
+
+ENTITY IfcStructuralReaction
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStructuralCurveReaction
+    ,IfcStructuralPointReaction
+    ,IfcStructuralSurfaceReaction))
+ SUBTYPE OF (IfcStructuralActivity);
+END_ENTITY;
+
+ENTITY IfcStructuralResultGroup
+ SUBTYPE OF (IfcGroup);
+	TheoryType : IfcAnalysisTheoryTypeEnum;
+	ResultForLoadGroup : OPTIONAL IfcStructuralLoadGroup;
+	IsLinear : IfcBoolean;
+ INVERSE
+	ResultGroupFor : SET [0:1] OF IfcStructuralAnalysisModel FOR HasResults;
+ WHERE
+	HasObjectType : (TheoryType <> IfcAnalysisTheoryTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStructuralSurfaceAction
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralPlanarAction))
+ SUBTYPE OF (IfcStructuralAction);
+	ProjectedOrTrue : OPTIONAL IfcProjectedOrTrueLengthEnum;
+	PredefinedType : IfcStructuralSurfaceActivityTypeEnum;
+ WHERE
+	ProjectedIsGlobal : (NOT EXISTS(ProjectedOrTrue)) OR
+((ProjectedOrTrue <> PROJECTED_LENGTH) OR
+ (SELF\IfcStructuralActivity.GlobalOrLocal = GLOBAL_COORDS));
+	HasObjectType : (PredefinedType <> IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStructuralSurfaceConnection
+ SUBTYPE OF (IfcStructuralConnection);
+END_ENTITY;
+
+ENTITY IfcStructuralSurfaceMember
+ SUPERTYPE OF (ONEOF
+    (IfcStructuralSurfaceMemberVarying))
+ SUBTYPE OF (IfcStructuralMember);
+	PredefinedType : IfcStructuralSurfaceMemberTypeEnum;
+	Thickness : OPTIONAL IfcPositiveLengthMeasure;
+ WHERE
+	HasObjectType : (PredefinedType <> IfcStructuralSurfaceMemberTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStructuralSurfaceMemberVarying
+ SUBTYPE OF (IfcStructuralSurfaceMember);
+END_ENTITY;
+
+ENTITY IfcStructuralSurfaceReaction
+ SUBTYPE OF (IfcStructuralReaction);
+	PredefinedType : IfcStructuralSurfaceActivityTypeEnum;
+ WHERE
+	HasPredefinedType : (PredefinedType <> IfcStructuralSurfaceActivityTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcStyleModel
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcStyledRepresentation))
+ SUBTYPE OF (IfcRepresentation);
+END_ENTITY;
+
+ENTITY IfcStyledItem
+ SUBTYPE OF (IfcRepresentationItem);
+	Item : OPTIONAL IfcRepresentationItem;
+	Styles : SET [1:?] OF IfcStyleAssignmentSelect;
+	Name : OPTIONAL IfcLabel;
+ WHERE
+	ApplicableItem : NOT('IFC4.IFCSTYLEDITEM' IN TYPEOF(Item));
+END_ENTITY;
+
+ENTITY IfcStyledRepresentation
+ SUBTYPE OF (IfcStyleModel);
+ WHERE
+	OnlyStyledItems : SIZEOF(QUERY(temp <* SELF\IfcRepresentation.Items | 
+  (NOT('IFC4.IFCSTYLEDITEM' IN TYPEOF(temp)))
+)) = 0;
+END_ENTITY;
+
+ENTITY IfcSubContractResource
+ SUBTYPE OF (IfcConstructionResource);
+	PredefinedType : OPTIONAL IfcSubContractResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSubContractResourceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSubContractResourceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcSubContractResourceType
+ SUBTYPE OF (IfcConstructionResourceType);
+	PredefinedType : IfcSubContractResourceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSubContractResourceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSubContractResourceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeResource.ResourceType));
+END_ENTITY;
+
+ENTITY IfcSubedge
+ SUBTYPE OF (IfcEdge);
+	ParentEdge : IfcEdge;
+END_ENTITY;
+
+ENTITY IfcSurface
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBoundedSurface
+    ,IfcElementarySurface
+    ,IfcSweptSurface))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+END_ENTITY;
+
+ENTITY IfcSurfaceCurve
+ SUPERTYPE OF (ONEOF
+    (IfcIntersectionCurve
+    ,IfcSeamCurve))
+ SUBTYPE OF (IfcCurve);
+	Curve3D : IfcCurve;
+	AssociatedGeometry : LIST [1:2] OF IfcPcurve;
+	MasterRepresentation : IfcPreferredSurfaceCurveRepresentation;
+ DERIVE
+	BasisSurface : SET [1:2] OF IfcSurface := IfcGetBasisSurface(SELF);
+ WHERE
+	CurveIs3D : Curve3D.Dim = 3;
+	CurveIsNotPcurve : NOT ('IFC4.IFCPCURVE' IN TYPEOF(Curve3D));
+END_ENTITY;
+
+ENTITY IfcSurfaceCurveSweptAreaSolid
+ SUBTYPE OF (IfcSweptAreaSolid);
+	Directrix : IfcCurve;
+	StartParam : OPTIONAL IfcParameterValue;
+	EndParam : OPTIONAL IfcParameterValue;
+	ReferenceSurface : IfcSurface;
+ WHERE
+	DirectrixBounded : (EXISTS(StartParam) AND EXISTS(EndParam)) OR 
+(SIZEOF(['IFC4.IFCCONIC', 'IFC4.IFCBOUNDEDCURVE'] * TYPEOF(Directrix)) = 1);
+END_ENTITY;
+
+ENTITY IfcSurfaceFeature
+ SUBTYPE OF (IfcFeatureElement);
+	PredefinedType : OPTIONAL IfcSurfaceFeatureTypeEnum;
+ WHERE
+	HasObjectType : NOT EXISTS(PredefinedType) OR (PredefinedType <> IfcSurfaceFeatureTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcSurfaceOfLinearExtrusion
+ SUBTYPE OF (IfcSweptSurface);
+	ExtrudedDirection : IfcDirection;
+	Depth : IfcLengthMeasure;
+ DERIVE
+	ExtrusionAxis : IfcVector := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector (ExtrudedDirection, Depth);
+ WHERE
+	DepthGreaterZero : Depth > 0.;
+END_ENTITY;
+
+ENTITY IfcSurfaceOfRevolution
+ SUBTYPE OF (IfcSweptSurface);
+	AxisPosition : IfcAxis1Placement;
+ DERIVE
+	AxisLine : IfcLine := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcCurve() || IfcLine(AxisPosition.Location, 
+  IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(AxisPosition.Z,1.0));
+END_ENTITY;
+
+ENTITY IfcSurfaceReinforcementArea
+ SUBTYPE OF (IfcStructuralLoadOrResult);
+	SurfaceReinforcement1 : OPTIONAL LIST [2:3] OF IfcLengthMeasure;
+	SurfaceReinforcement2 : OPTIONAL LIST [2:3] OF IfcLengthMeasure;
+	ShearReinforcement : OPTIONAL IfcRatioMeasure;
+ WHERE
+	SurfaceAndOrShearAreaSpecified : EXISTS(SurfaceReinforcement1) OR EXISTS(SurfaceReinforcement2) OR EXISTS(ShearReinforcement);
+	NonnegativeArea1 : (NOT EXISTS(SurfaceReinforcement1)) OR (
+    (SurfaceReinforcement1[1] >= 0.) AND
+    (SurfaceReinforcement1[2] >= 0.) AND
+    ((SIZEOF(SurfaceReinforcement1) = 1) OR (SurfaceReinforcement1[1] >= 0.))
+);
+	NonnegativeArea2 : (NOT EXISTS(SurfaceReinforcement2)) OR (
+    (SurfaceReinforcement2[1] >= 0.) AND
+    (SurfaceReinforcement2[2] >= 0.) AND
+    ((SIZEOF(SurfaceReinforcement2) = 1) OR (SurfaceReinforcement2[1] >= 0.))
+);
+	NonnegativeArea3 : (NOT EXISTS(ShearReinforcement)) OR (ShearReinforcement >= 0.);
+END_ENTITY;
+
+ENTITY IfcSurfaceStyle
+ SUBTYPE OF (IfcPresentationStyle);
+	Side : IfcSurfaceSide;
+	Styles : SET [1:5] OF IfcSurfaceStyleElementSelect;
+ WHERE
+	MaxOneShading : SIZEOF(QUERY(Style <* SELF.Styles |
+  'IFC4.IFCSURFACESTYLESHADING' IN
+   TYPEOF(Style)
+  )) <= 1;
+	MaxOneLighting : SIZEOF(QUERY(Style <* SELF.Styles |
+  'IFC4.IFCSURFACESTYLELIGHTING' IN
+   TYPEOF(Style)
+  )) <= 1;
+	MaxOneRefraction : SIZEOF(QUERY(Style <* SELF.Styles |
+  'IFC4.IFCSURFACESTYLEREFRACTION' IN
+   TYPEOF(Style)
+  )) <= 1;
+	MaxOneTextures : SIZEOF(QUERY(Style <* SELF.Styles |
+  'IFC4.IFCSURFACESTYLEWITHTEXTURES' IN
+   TYPEOF(Style)
+  )) <= 1;
+	MaxOneExtDefined : SIZEOF(QUERY(Style <* SELF.Styles |
+  'IFC4.IFCEXTERNALLYDEFINEDSURFACESTYLE' IN
+   TYPEOF(Style)
+  )) <= 1;
+END_ENTITY;
+
+ENTITY IfcSurfaceStyleLighting
+ SUBTYPE OF (IfcPresentationItem);
+	DiffuseTransmissionColour : IfcColourRgb;
+	DiffuseReflectionColour : IfcColourRgb;
+	TransmissionColour : IfcColourRgb;
+	ReflectanceColour : IfcColourRgb;
+END_ENTITY;
+
+ENTITY IfcSurfaceStyleRefraction
+ SUBTYPE OF (IfcPresentationItem);
+	RefractionIndex : OPTIONAL IfcReal;
+	DispersionFactor : OPTIONAL IfcReal;
+END_ENTITY;
+
+ENTITY IfcSurfaceStyleRendering
+ SUBTYPE OF (IfcSurfaceStyleShading);
+	DiffuseColour : OPTIONAL IfcColourOrFactor;
+	TransmissionColour : OPTIONAL IfcColourOrFactor;
+	DiffuseTransmissionColour : OPTIONAL IfcColourOrFactor;
+	ReflectionColour : OPTIONAL IfcColourOrFactor;
+	SpecularColour : OPTIONAL IfcColourOrFactor;
+	SpecularHighlight : OPTIONAL IfcSpecularHighlightSelect;
+	ReflectanceMethod : IfcReflectanceMethodEnum;
+END_ENTITY;
+
+ENTITY IfcSurfaceStyleShading
+ SUPERTYPE OF (ONEOF
+    (IfcSurfaceStyleRendering))
+ SUBTYPE OF (IfcPresentationItem);
+	SurfaceColour : IfcColourRgb;
+	Transparency : OPTIONAL IfcNormalisedRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcSurfaceStyleWithTextures
+ SUBTYPE OF (IfcPresentationItem);
+	Textures : LIST [1:?] OF IfcSurfaceTexture;
+END_ENTITY;
+
+ENTITY IfcSurfaceTexture
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcBlobTexture
+    ,IfcImageTexture
+    ,IfcPixelTexture))
+ SUBTYPE OF (IfcPresentationItem);
+	RepeatS : IfcBoolean;
+	RepeatT : IfcBoolean;
+	Mode : OPTIONAL IfcIdentifier;
+	TextureTransform : OPTIONAL IfcCartesianTransformationOperator2D;
+	Parameter : OPTIONAL LIST [1:?] OF IfcIdentifier;
+ INVERSE
+	IsMappedBy : SET [0:?] OF IfcTextureCoordinate FOR Maps;
+	UsedInStyles : SET [0:?] OF IfcSurfaceStyleWithTextures FOR Textures;
+END_ENTITY;
+
+ENTITY IfcSweptAreaSolid
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcExtrudedAreaSolid
+    ,IfcFixedReferenceSweptAreaSolid
+    ,IfcRevolvedAreaSolid
+    ,IfcSurfaceCurveSweptAreaSolid))
+ SUBTYPE OF (IfcSolidModel);
+	SweptArea : IfcProfileDef;
+	Position : OPTIONAL IfcAxis2Placement3D;
+ WHERE
+	SweptAreaType : SweptArea.ProfileType = IfcProfileTypeEnum.Area;
+END_ENTITY;
+
+ENTITY IfcSweptDiskSolid
+ SUPERTYPE OF (ONEOF
+    (IfcSweptDiskSolidPolygonal))
+ SUBTYPE OF (IfcSolidModel);
+	Directrix : IfcCurve;
+	Radius : IfcPositiveLengthMeasure;
+	InnerRadius : OPTIONAL IfcPositiveLengthMeasure;
+	StartParam : OPTIONAL IfcParameterValue;
+	EndParam : OPTIONAL IfcParameterValue;
+ WHERE
+	DirectrixDim : Directrix.Dim = 3;
+	InnerRadiusSize : (NOT EXISTS(InnerRadius)) OR (Radius > InnerRadius);
+	DirectrixBounded : (EXISTS(StartParam) AND EXISTS(EndParam)) OR 
+(SIZEOF(['IFC4.IFCCONIC', 'IFC4.IFCBOUNDEDCURVE'] * TYPEOF(Directrix)) = 1);
+END_ENTITY;
+
+ENTITY IfcSweptDiskSolidPolygonal
+ SUBTYPE OF (IfcSweptDiskSolid);
+	FilletRadius : OPTIONAL IfcPositiveLengthMeasure;
+ WHERE
+	CorrectRadii : NOT(EXISTS(FilletRadius)) OR (FilletRadius >= SELF\IfcSweptDiskSolid.Radius);
+	DirectrixIsPolyline : ('IFC4.IFCPOLYLINE' IN TYPEOF(SELF\IfcSweptDiskSolid.Directrix)) OR
+(('IFC4.IFCINDEXEDPOLYCURVE' IN TYPEOF(SELF\IfcSweptDiskSolid.Directrix)) AND NOT(EXISTS(SELF\IfcSweptDiskSolid.Directrix.Segments)));
+END_ENTITY;
+
+ENTITY IfcSweptSurface
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcSurfaceOfLinearExtrusion
+    ,IfcSurfaceOfRevolution))
+ SUBTYPE OF (IfcSurface);
+	SweptCurve : IfcProfileDef;
+	Position : OPTIONAL IfcAxis2Placement3D;
+ WHERE
+	SweptCurveType : SweptCurve.ProfileType = IfcProfileTypeEnum.Curve;
+END_ENTITY;
+
+ENTITY IfcSwitchingDevice
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcSwitchingDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSwitchingDeviceTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSwitchingDeviceTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCSWITCHINGDEVICETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSwitchingDeviceType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcSwitchingDeviceTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSwitchingDeviceTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSwitchingDeviceTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcSystem
+ SUPERTYPE OF (ONEOF
+    (IfcBuildingSystem
+    ,IfcDistributionSystem
+    ,IfcStructuralAnalysisModel
+    ,IfcZone))
+ SUBTYPE OF (IfcGroup);
+ INVERSE
+	ServicesBuildings : SET [0:1] OF IfcRelServicesBuildings FOR RelatingSystem;
+END_ENTITY;
+
+ENTITY IfcSystemFurnitureElement
+ SUBTYPE OF (IfcFurnishingElement);
+	PredefinedType : OPTIONAL IfcSystemFurnitureElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcSystemFurnitureElementTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcSystemFurnitureElementTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+   ('IFC4.IFCSYSTEMFURNITUREELEMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcSystemFurnitureElementType
+ SUBTYPE OF (IfcFurnishingElementType);
+	PredefinedType : OPTIONAL IfcSystemFurnitureElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcSystemFurnitureElementTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcSystemFurnitureElementTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	Depth : IfcPositiveLengthMeasure;
+	FlangeWidth : IfcPositiveLengthMeasure;
+	WebThickness : IfcPositiveLengthMeasure;
+	FlangeThickness : IfcPositiveLengthMeasure;
+	FilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	FlangeEdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	WebEdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	WebSlope : OPTIONAL IfcPlaneAngleMeasure;
+	FlangeSlope : OPTIONAL IfcPlaneAngleMeasure;
+ WHERE
+	ValidFlangeThickness : FlangeThickness < Depth;
+	ValidWebThickness : WebThickness < FlangeWidth;
+END_ENTITY;
+
+ENTITY IfcTable;
+	Name : OPTIONAL IfcLabel;
+	Rows : OPTIONAL LIST [1:?] OF IfcTableRow;
+	Columns : OPTIONAL LIST [1:?] OF IfcTableColumn;
+ DERIVE
+	NumberOfCellsInRow : IfcInteger := HIINDEX(Rows[1].RowCells);
+	NumberOfHeadings : IfcInteger := SIZEOF(QUERY( Temp <* Rows | Temp.IsHeading));
+	NumberOfDataRows : IfcInteger := SIZEOF(QUERY( Temp <* Rows | NOT(Temp.IsHeading)));
+ WHERE
+	WR1 : SIZEOF(QUERY( Temp <* Rows | HIINDEX(Temp.RowCells) <> HIINDEX(Rows[1].RowCells))) = 0;
+	WR2 : { 0 <= NumberOfHeadings <= 1 };
+END_ENTITY;
+
+ENTITY IfcTableColumn;
+	Identifier : OPTIONAL IfcIdentifier;
+	Name : OPTIONAL IfcLabel;
+	Description : OPTIONAL IfcText;
+	Unit : OPTIONAL IfcUnit;
+	ReferencePath : OPTIONAL IfcReference;
+END_ENTITY;
+
+ENTITY IfcTableRow;
+	RowCells : OPTIONAL LIST [1:?] OF IfcValue;
+	IsHeading : OPTIONAL IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcTank
+ SUBTYPE OF (IfcFlowStorageDevice);
+	PredefinedType : OPTIONAL IfcTankTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcTankTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcTankTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCTANKTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcTankType
+ SUBTYPE OF (IfcFlowStorageDeviceType);
+	PredefinedType : IfcTankTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTankTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTankTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTask
+ SUBTYPE OF (IfcProcess);
+	Status : OPTIONAL IfcLabel;
+	WorkMethod : OPTIONAL IfcLabel;
+	IsMilestone : IfcBoolean;
+	Priority : OPTIONAL IfcInteger;
+	TaskTime : OPTIONAL IfcTaskTime;
+	PredefinedType : OPTIONAL IfcTaskTypeEnum;
+ WHERE
+	HasName : EXISTS(SELF\IfcRoot.Name);
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR (PredefinedType <> IfcTaskTypeEnum.USERDEFINED) OR ((PredefinedType = IfcTaskTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcTaskTime
+ SUPERTYPE OF (ONEOF
+    (IfcTaskTimeRecurring))
+ SUBTYPE OF (IfcSchedulingTime);
+	DurationType : OPTIONAL IfcTaskDurationEnum;
+	ScheduleDuration : OPTIONAL IfcDuration;
+	ScheduleStart : OPTIONAL IfcDateTime;
+	ScheduleFinish : OPTIONAL IfcDateTime;
+	EarlyStart : OPTIONAL IfcDateTime;
+	EarlyFinish : OPTIONAL IfcDateTime;
+	LateStart : OPTIONAL IfcDateTime;
+	LateFinish : OPTIONAL IfcDateTime;
+	FreeFloat : OPTIONAL IfcDuration;
+	TotalFloat : OPTIONAL IfcDuration;
+	IsCritical : OPTIONAL IfcBoolean;
+	StatusTime : OPTIONAL IfcDateTime;
+	ActualDuration : OPTIONAL IfcDuration;
+	ActualStart : OPTIONAL IfcDateTime;
+	ActualFinish : OPTIONAL IfcDateTime;
+	RemainingTime : OPTIONAL IfcDuration;
+	Completion : OPTIONAL IfcPositiveRatioMeasure;
+END_ENTITY;
+
+ENTITY IfcTaskTimeRecurring
+ SUBTYPE OF (IfcTaskTime);
+	Recurrence : IfcRecurrencePattern;
+END_ENTITY;
+
+ENTITY IfcTaskType
+ SUBTYPE OF (IfcTypeProcess);
+	PredefinedType : IfcTaskTypeEnum;
+	WorkMethod : OPTIONAL IfcLabel;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTaskTypeEnum.USERDEFINED) OR ((PredefinedType = IfcTaskTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcTypeProcess.ProcessType));
+END_ENTITY;
+
+ENTITY IfcTelecomAddress
+ SUBTYPE OF (IfcAddress);
+	TelephoneNumbers : OPTIONAL LIST [1:?] OF IfcLabel;
+	FacsimileNumbers : OPTIONAL LIST [1:?] OF IfcLabel;
+	PagerNumber : OPTIONAL IfcLabel;
+	ElectronicMailAddresses : OPTIONAL LIST [1:?] OF IfcLabel;
+	WWWHomePageURL : OPTIONAL IfcURIReference;
+	MessagingIDs : OPTIONAL LIST [1:?] OF IfcURIReference;
+ WHERE
+	MinimumDataProvided : EXISTS (TelephoneNumbers) OR
+EXISTS (FacsimileNumbers) OR 
+EXISTS (PagerNumber) OR
+EXISTS (ElectronicMailAddresses) OR 
+EXISTS (WWWHomePageURL) OR
+EXISTS (MessagingIDs);
+END_ENTITY;
+
+ENTITY IfcTendon
+ SUBTYPE OF (IfcReinforcingElement);
+	PredefinedType : OPTIONAL IfcTendonTypeEnum;
+	NominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	CrossSectionArea : OPTIONAL IfcAreaMeasure;
+	TensionForce : OPTIONAL IfcForceMeasure;
+	PreStress : OPTIONAL IfcPressureMeasure;
+	FrictionCoefficient : OPTIONAL IfcNormalisedRatioMeasure;
+	AnchorageSlip : OPTIONAL IfcPositiveLengthMeasure;
+	MinCurvatureRadius : OPTIONAL IfcPositiveLengthMeasure;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+(PredefinedType <> IfcTendonTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTendonTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCTENDONTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcTendonAnchor
+ SUBTYPE OF (IfcReinforcingElement);
+	PredefinedType : OPTIONAL IfcTendonAnchorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+(PredefinedType <> IfcTendonAnchorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTendonAnchorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+('IFC4.IFCTENDONANCHORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcTendonAnchorType
+ SUBTYPE OF (IfcReinforcingElementType);
+	PredefinedType : IfcTendonAnchorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTendonAnchorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTendonAnchorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTendonType
+ SUBTYPE OF (IfcReinforcingElementType);
+	PredefinedType : IfcTendonTypeEnum;
+	NominalDiameter : OPTIONAL IfcPositiveLengthMeasure;
+	CrossSectionArea : OPTIONAL IfcAreaMeasure;
+	SheathDiameter : OPTIONAL IfcPositiveLengthMeasure;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTendonTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTendonTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTessellatedFaceSet
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcPolygonalFaceSet
+    ,IfcTriangulatedFaceSet))
+ SUBTYPE OF (IfcTessellatedItem);
+	Coordinates : IfcCartesianPointList3D;
+ DERIVE
+	Dim : IfcDimensionCount := 3;
+ INVERSE
+	HasColours : SET [0:1] OF IfcIndexedColourMap FOR MappedTo;
+	HasTextures : SET [0:?] OF IfcIndexedTextureMap FOR MappedTo;
+END_ENTITY;
+
+ENTITY IfcTessellatedItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcIndexedPolygonalFace
+    ,IfcTessellatedFaceSet))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+END_ENTITY;
+
+ENTITY IfcTextLiteral
+ SUPERTYPE OF (ONEOF
+    (IfcTextLiteralWithExtent))
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Literal : IfcPresentableText;
+	Placement : IfcAxis2Placement;
+	Path : IfcTextPath;
+END_ENTITY;
+
+ENTITY IfcTextLiteralWithExtent
+ SUBTYPE OF (IfcTextLiteral);
+	Extent : IfcPlanarExtent;
+	BoxAlignment : IfcBoxAlignment;
+ WHERE
+	WR31 : NOT('IFC4.IFCPLANARBOX' IN TYPEOF(Extent));
+END_ENTITY;
+
+ENTITY IfcTextStyle
+ SUBTYPE OF (IfcPresentationStyle);
+	TextCharacterAppearance : OPTIONAL IfcTextStyleForDefinedFont;
+	TextStyle : OPTIONAL IfcTextStyleTextModel;
+	TextFontStyle : IfcTextFontSelect;
+	ModelOrDraughting : OPTIONAL IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcTextStyleFontModel
+ SUBTYPE OF (IfcPreDefinedTextFont);
+	FontFamily : LIST [1:?] OF IfcTextFontName;
+	FontStyle : OPTIONAL IfcFontStyle;
+	FontVariant : OPTIONAL IfcFontVariant;
+	FontWeight : OPTIONAL IfcFontWeight;
+	FontSize : IfcSizeSelect;
+ WHERE
+	MeasureOfFontSize : ('IFC4.IFCLENGTHMEASURE' IN TYPEOF(SELF.FontSize)) AND
+(SELF.FontSize > 0.);
+END_ENTITY;
+
+ENTITY IfcTextStyleForDefinedFont
+ SUBTYPE OF (IfcPresentationItem);
+	Colour : IfcColour;
+	BackgroundColour : OPTIONAL IfcColour;
+END_ENTITY;
+
+ENTITY IfcTextStyleTextModel
+ SUBTYPE OF (IfcPresentationItem);
+	TextIndent : OPTIONAL IfcSizeSelect;
+	TextAlign : OPTIONAL IfcTextAlignment;
+	TextDecoration : OPTIONAL IfcTextDecoration;
+	LetterSpacing : OPTIONAL IfcSizeSelect;
+	WordSpacing : OPTIONAL IfcSizeSelect;
+	TextTransform : OPTIONAL IfcTextTransformation;
+	LineHeight : OPTIONAL IfcSizeSelect;
+END_ENTITY;
+
+ENTITY IfcTextureCoordinate
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcIndexedTextureMap
+    ,IfcTextureCoordinateGenerator
+    ,IfcTextureMap))
+ SUBTYPE OF (IfcPresentationItem);
+	Maps : LIST [1:?] OF IfcSurfaceTexture;
+END_ENTITY;
+
+ENTITY IfcTextureCoordinateGenerator
+ SUBTYPE OF (IfcTextureCoordinate);
+	Mode : IfcLabel;
+	Parameter : OPTIONAL LIST [1:?] OF IfcReal;
+END_ENTITY;
+
+ENTITY IfcTextureMap
+ SUBTYPE OF (IfcTextureCoordinate);
+	Vertices : LIST [3:?] OF IfcTextureVertex;
+	MappedTo : IfcFace;
+END_ENTITY;
+
+ENTITY IfcTextureVertex
+ SUBTYPE OF (IfcPresentationItem);
+	Coordinates : LIST [2:2] OF IfcParameterValue;
+END_ENTITY;
+
+ENTITY IfcTextureVertexList
+ SUBTYPE OF (IfcPresentationItem);
+	TexCoordsList : LIST [1:?] OF LIST [2:2] OF IfcParameterValue;
+END_ENTITY;
+
+ENTITY IfcTimePeriod;
+	StartTime : IfcTime;
+	EndTime : IfcTime;
+END_ENTITY;
+
+ENTITY IfcTimeSeries
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcIrregularTimeSeries
+    ,IfcRegularTimeSeries));
+	Name : IfcLabel;
+	Description : OPTIONAL IfcText;
+	StartTime : IfcDateTime;
+	EndTime : IfcDateTime;
+	TimeSeriesDataType : IfcTimeSeriesDataTypeEnum;
+	DataOrigin : IfcDataOriginEnum;
+	UserDefinedDataOrigin : OPTIONAL IfcLabel;
+	Unit : OPTIONAL IfcUnit;
+ INVERSE
+	HasExternalReference : SET [1:?] OF IfcExternalReferenceRelationship FOR RelatedResourceObjects;
+END_ENTITY;
+
+ENTITY IfcTimeSeriesValue;
+	ListValues : LIST [1:?] OF IfcValue;
+END_ENTITY;
+
+ENTITY IfcTopologicalRepresentationItem
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcConnectedFaceSet
+    ,IfcEdge
+    ,IfcFace
+    ,IfcFaceBound
+    ,IfcLoop
+    ,IfcPath
+    ,IfcVertex))
+ SUBTYPE OF (IfcRepresentationItem);
+END_ENTITY;
+
+ENTITY IfcTopologyRepresentation
+ SUBTYPE OF (IfcShapeModel);
+ WHERE
+	WR21 : SIZEOF(QUERY(temp <* SELF\IfcRepresentation.Items | 
+  NOT('IFC4.IFCTOPOLOGICALREPRESENTATIONITEM' IN TYPEOF(temp))
+)) = 0;
+	WR22 : EXISTS(SELF\IfcRepresentation.RepresentationType);
+	WR23 : IfcTopologyRepresentationTypes(SELF\IfcRepresentation.RepresentationType, SELF\IfcRepresentation.Items);
+END_ENTITY;
+
+ENTITY IfcToroidalSurface
+ SUBTYPE OF (IfcElementarySurface);
+	MajorRadius : IfcPositiveLengthMeasure;
+	MinorRadius : IfcPositiveLengthMeasure;
+ WHERE
+	MajorLargerMinor : MinorRadius < MajorRadius;
+END_ENTITY;
+
+ENTITY IfcTransformer
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcTransformerTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcTransformerTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcTransformerTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCTRANFORMERTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcTransformerType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcTransformerTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTransformerTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTransformerTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTransportElement
+ SUBTYPE OF (IfcElement);
+	PredefinedType : OPTIONAL IfcTransportElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcTransportElementTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcTransportElementTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCTRANSPORTELEMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcTransportElementType
+ SUBTYPE OF (IfcElementType);
+	PredefinedType : IfcTransportElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTransportElementTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTransportElementTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTrapeziumProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	BottomXDim : IfcPositiveLengthMeasure;
+	TopXDim : IfcPositiveLengthMeasure;
+	YDim : IfcPositiveLengthMeasure;
+	TopXOffset : IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcTriangulatedFaceSet
+ SUBTYPE OF (IfcTessellatedFaceSet);
+	Normals : OPTIONAL LIST [1:?] OF LIST [3:3] OF IfcParameterValue;
+	Closed : OPTIONAL IfcBoolean;
+	CoordIndex : LIST [1:?] OF LIST [3:3] OF IfcPositiveInteger;
+	PnIndex : OPTIONAL LIST [1:?] OF IfcPositiveInteger;
+ DERIVE
+	NumberOfTriangles : IfcInteger := SIZEOF(CoordIndex);
+END_ENTITY;
+
+ENTITY IfcTrimmedCurve
+ SUBTYPE OF (IfcBoundedCurve);
+	BasisCurve : IfcCurve;
+	Trim1 : SET [1:2] OF IfcTrimmingSelect;
+	Trim2 : SET [1:2] OF IfcTrimmingSelect;
+	SenseAgreement : IfcBoolean;
+	MasterRepresentation : IfcTrimmingPreference;
+ WHERE
+	Trim1ValuesConsistent : (HIINDEX(Trim1) = 1) OR (TYPEOF(Trim1[1]) <> TYPEOF(Trim1[2]));
+	Trim2ValuesConsistent : (HIINDEX(Trim2) = 1) OR (TYPEOF(Trim2[1]) <> TYPEOF(Trim2[2]));
+	NoTrimOfBoundedCurves : NOT('IFC4.IFCBOUNDEDCURVE' IN TYPEOF(BasisCurve));
+END_ENTITY;
+
+ENTITY IfcTubeBundle
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcTubeBundleTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcTubeBundleTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcTubeBundleTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCTUBEBUNDLETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcTubeBundleType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcTubeBundleTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcTubeBundleTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcTubeBundleTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcTypeObject
+ SUPERTYPE OF (ONEOF
+    (IfcTypeProcess
+    ,IfcTypeProduct
+    ,IfcTypeResource))
+ SUBTYPE OF (IfcObjectDefinition);
+	ApplicableOccurrence : OPTIONAL IfcIdentifier;
+	HasPropertySets : OPTIONAL SET [1:?] OF IfcPropertySetDefinition;
+ INVERSE
+	Types : SET [0:1] OF IfcRelDefinesByType FOR RelatingType;
+ WHERE
+	NameRequired : EXISTS(SELF\IfcRoot.Name);
+	UniquePropertySetNames : (NOT(EXISTS(HasPropertySets))) OR IfcUniquePropertySetNames(HasPropertySets);
+END_ENTITY;
+
+ENTITY IfcTypeProcess
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcEventType
+    ,IfcProcedureType
+    ,IfcTaskType))
+ SUBTYPE OF (IfcTypeObject);
+	Identification : OPTIONAL IfcIdentifier;
+	LongDescription : OPTIONAL IfcText;
+	ProcessType : OPTIONAL IfcLabel;
+ INVERSE
+	OperatesOn : SET [0:?] OF IfcRelAssignsToProcess FOR RelatingProcess;
+END_ENTITY;
+
+ENTITY IfcTypeProduct
+ SUPERTYPE OF (ONEOF
+    (IfcDoorStyle
+    ,IfcElementType
+    ,IfcSpatialElementType
+    ,IfcWindowStyle))
+ SUBTYPE OF (IfcTypeObject);
+	RepresentationMaps : OPTIONAL LIST [1:?] OF UNIQUE IfcRepresentationMap;
+	Tag : OPTIONAL IfcLabel;
+ INVERSE
+	ReferencedBy : SET [0:?] OF IfcRelAssignsToProduct FOR RelatingProduct;
+ WHERE
+	ApplicableOccurrence : NOT(EXISTS(SELF\IfcTypeObject.Types[1])) OR
+(SIZEOF(QUERY(temp <* SELF\IfcTypeObject.Types[1].RelatedObjects |
+  NOT('IFC4.IFCPRODUCT' IN TYPEOF(temp)))
+) = 0);
+END_ENTITY;
+
+ENTITY IfcTypeResource
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcConstructionResourceType))
+ SUBTYPE OF (IfcTypeObject);
+	Identification : OPTIONAL IfcIdentifier;
+	LongDescription : OPTIONAL IfcText;
+	ResourceType : OPTIONAL IfcLabel;
+ INVERSE
+	ResourceOf : SET [0:?] OF IfcRelAssignsToResource FOR RelatingResource;
+END_ENTITY;
+
+ENTITY IfcUShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	Depth : IfcPositiveLengthMeasure;
+	FlangeWidth : IfcPositiveLengthMeasure;
+	WebThickness : IfcPositiveLengthMeasure;
+	FlangeThickness : IfcPositiveLengthMeasure;
+	FilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	EdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	FlangeSlope : OPTIONAL IfcPlaneAngleMeasure;
+ WHERE
+	ValidFlangeThickness : FlangeThickness < (Depth / 2.);
+	ValidWebThickness : WebThickness < FlangeWidth;
+END_ENTITY;
+
+ENTITY IfcUnitAssignment;
+	Units : SET [1:?] OF IfcUnit;
+ WHERE
+	WR01 : IfcCorrectUnitAssignment(Units);
+END_ENTITY;
+
+ENTITY IfcUnitaryControlElement
+ SUBTYPE OF (IfcDistributionControlElement);
+	PredefinedType : OPTIONAL IfcUnitaryControlElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcUnitaryControlElementTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcUnitaryControlElementTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+('IFC4.IFCUNITARYCONTROLELEMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcUnitaryControlElementType
+ SUBTYPE OF (IfcDistributionControlElementType);
+	PredefinedType : IfcUnitaryControlElementTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcUnitaryControlElementTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcUnitaryControlElementTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcUnitaryEquipment
+ SUBTYPE OF (IfcEnergyConversionDevice);
+	PredefinedType : OPTIONAL IfcUnitaryEquipmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcUnitaryEquipmentTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcUnitaryEquipmentTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCUNITARYEQUIPMENTTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcUnitaryEquipmentType
+ SUBTYPE OF (IfcEnergyConversionDeviceType);
+	PredefinedType : IfcUnitaryEquipmentTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcUnitaryEquipmentTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcUnitaryEquipmentTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcValve
+ SUBTYPE OF (IfcFlowController);
+	PredefinedType : OPTIONAL IfcValveTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcValveTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcValveTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCVALVETYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcValveType
+ SUBTYPE OF (IfcFlowControllerType);
+	PredefinedType : IfcValveTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcValveTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcValveTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcVector
+ SUBTYPE OF (IfcGeometricRepresentationItem);
+	Orientation : IfcDirection;
+	Magnitude : IfcLengthMeasure;
+ DERIVE
+	Dim : IfcDimensionCount := Orientation.Dim;
+ WHERE
+	MagGreaterOrEqualZero : Magnitude >= 0.0;
+END_ENTITY;
+
+ENTITY IfcVertex
+ SUPERTYPE OF (ONEOF
+    (IfcVertexPoint))
+ SUBTYPE OF (IfcTopologicalRepresentationItem);
+END_ENTITY;
+
+ENTITY IfcVertexLoop
+ SUBTYPE OF (IfcLoop);
+	LoopVertex : IfcVertex;
+END_ENTITY;
+
+ENTITY IfcVertexPoint
+ SUBTYPE OF (IfcVertex);
+	VertexGeometry : IfcPoint;
+END_ENTITY;
+
+ENTITY IfcVibrationIsolator
+ SUBTYPE OF (IfcElementComponent);
+	PredefinedType : OPTIONAL IfcVibrationIsolatorTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcVibrationIsolatorTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcVibrationIsolatorTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCVIBRATIONISOLATORTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcVibrationIsolatorType
+ SUBTYPE OF (IfcElementComponentType);
+	PredefinedType : IfcVibrationIsolatorTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcVibrationIsolatorTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcVibrationIsolatorTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcVirtualElement
+ SUBTYPE OF (IfcElement);
+END_ENTITY;
+
+ENTITY IfcVirtualGridIntersection;
+	IntersectingAxes : LIST [2:2] OF UNIQUE IfcGridAxis;
+	OffsetDistances : LIST [2:3] OF IfcLengthMeasure;
+END_ENTITY;
+
+ENTITY IfcVoidingFeature
+ SUBTYPE OF (IfcFeatureElementSubtraction);
+	PredefinedType : OPTIONAL IfcVoidingFeatureTypeEnum;
+ WHERE
+	HasObjectType : NOT EXISTS(PredefinedType) OR (PredefinedType <> IfcVoidingFeatureTypeEnum.USERDEFINED) OR EXISTS(SELF\IfcObject.ObjectType);
+END_ENTITY;
+
+ENTITY IfcWall
+ SUPERTYPE OF (ONEOF
+    (IfcWallElementedCase
+    ,IfcWallStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	PredefinedType : OPTIONAL IfcWallTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR
+ (PredefinedType <> IfcWallTypeEnum.USERDEFINED) OR
+ ((PredefinedType = IfcWallTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR
+  ('IFC4.IFCWALLTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcWallElementedCase
+ SUBTYPE OF (IfcWall);
+ WHERE
+	HasDecomposition : HIINDEX(SELF\IfcObjectDefinition.IsDecomposedBy) > 0;
+END_ENTITY;
+
+ENTITY IfcWallStandardCase
+ SUBTYPE OF (IfcWall);
+ WHERE
+	HasMaterialLayerSetUsage : SIZEOF (QUERY(temp <* USEDIN(SELF, 'IFC4.IFCRELASSOCIATES.RELATEDOBJECTS') |
+              ('IFC4.IFCRELASSOCIATESMATERIAL' IN TYPEOF(temp)) AND
+              ('IFC4.IFCMATERIALLAYERSETUSAGE' IN TYPEOF(temp.RelatingMaterial))
+              )) = 1;
+END_ENTITY;
+
+ENTITY IfcWallType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcWallTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcWallTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcWallTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcWasteTerminal
+ SUBTYPE OF (IfcFlowTerminal);
+	PredefinedType : OPTIONAL IfcWasteTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR 
+ (PredefinedType <> IfcWasteTerminalTypeEnum.USERDEFINED) OR 
+ ((PredefinedType = IfcWasteTerminalTypeEnum.USERDEFINED) AND EXISTS (SELF\IfcObject.ObjectType));
+	CorrectTypeAssigned : (SIZEOF(IsTypedBy) = 0) OR 
+  ('IFC4.IFCWASTETERMINALTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcWasteTerminalType
+ SUBTYPE OF (IfcFlowTerminalType);
+	PredefinedType : IfcWasteTerminalTypeEnum;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcWasteTerminalTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcWasteTerminalTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcWindow
+ SUPERTYPE OF (ONEOF
+    (IfcWindowStandardCase))
+ SUBTYPE OF (IfcBuildingElement);
+	OverallHeight : OPTIONAL IfcPositiveLengthMeasure;
+	OverallWidth : OPTIONAL IfcPositiveLengthMeasure;
+	PredefinedType : OPTIONAL IfcWindowTypeEnum;
+	PartitioningType : OPTIONAL IfcWindowTypePartitioningEnum;
+	UserDefinedPartitioningType : OPTIONAL IfcLabel;
+ WHERE
+	CorrectStyleAssigned : (SIZEOF(IsTypedBy) = 0) 
+OR ('IFC4.IFCWINDOWTYPE' IN TYPEOF(SELF\IfcObject.IsTypedBy[1].RelatingType));
+END_ENTITY;
+
+ENTITY IfcWindowLiningProperties
+ SUBTYPE OF (IfcPreDefinedPropertySet);
+	LiningDepth : OPTIONAL IfcPositiveLengthMeasure;
+	LiningThickness : OPTIONAL IfcNonNegativeLengthMeasure;
+	TransomThickness : OPTIONAL IfcNonNegativeLengthMeasure;
+	MullionThickness : OPTIONAL IfcNonNegativeLengthMeasure;
+	FirstTransomOffset : OPTIONAL IfcNormalisedRatioMeasure;
+	SecondTransomOffset : OPTIONAL IfcNormalisedRatioMeasure;
+	FirstMullionOffset : OPTIONAL IfcNormalisedRatioMeasure;
+	SecondMullionOffset : OPTIONAL IfcNormalisedRatioMeasure;
+	ShapeAspectStyle : OPTIONAL IfcShapeAspect;
+	LiningOffset : OPTIONAL IfcLengthMeasure;
+	LiningToPanelOffsetX : OPTIONAL IfcLengthMeasure;
+	LiningToPanelOffsetY : OPTIONAL IfcLengthMeasure;
+ WHERE
+	WR31 : NOT(EXISTS(LiningDepth) AND NOT(EXISTS(LiningThickness)));
+	WR32 : NOT(NOT(EXISTS(FirstTransomOffset)) AND EXISTS(SecondTransomOffset));
+	WR33 : NOT(NOT(EXISTS(FirstMullionOffset)) AND EXISTS(SecondMullionOffset));
+	WR34 : (EXISTS(SELF\IfcPropertySetDefinition.DefinesType[1])) 
+AND 
+(
+ ('IFC4.IFCWINDOWTYPE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+  OR
+ ('IFC4.IFCWINDOWSTYLE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+);
+END_ENTITY;
+
+ENTITY IfcWindowPanelProperties
+ SUBTYPE OF (IfcPreDefinedPropertySet);
+	OperationType : IfcWindowPanelOperationEnum;
+	PanelPosition : IfcWindowPanelPositionEnum;
+	FrameDepth : OPTIONAL IfcPositiveLengthMeasure;
+	FrameThickness : OPTIONAL IfcPositiveLengthMeasure;
+	ShapeAspectStyle : OPTIONAL IfcShapeAspect;
+ WHERE
+	ApplicableToType : (EXISTS(SELF\IfcPropertySetDefinition.DefinesType[1])) 
+AND 
+(
+ ('IFC4.IFCWINDOWTYPE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+  OR
+ ('IFC4.IFCWINDOWSTYLE' IN TYPEOF(SELF\IfcPropertySetDefinition.DefinesType[1]))
+);
+END_ENTITY;
+
+ENTITY IfcWindowStandardCase
+ SUBTYPE OF (IfcWindow);
+END_ENTITY;
+
+ENTITY IfcWindowStyle
+ SUBTYPE OF (IfcTypeProduct);
+	ConstructionType : IfcWindowStyleConstructionEnum;
+	OperationType : IfcWindowStyleOperationEnum;
+	ParameterTakesPrecedence : IfcBoolean;
+	Sizeable : IfcBoolean;
+END_ENTITY;
+
+ENTITY IfcWindowType
+ SUBTYPE OF (IfcBuildingElementType);
+	PredefinedType : IfcWindowTypeEnum;
+	PartitioningType : IfcWindowTypePartitioningEnum;
+	ParameterTakesPrecedence : OPTIONAL IfcBoolean;
+	UserDefinedPartitioningType : OPTIONAL IfcLabel;
+ WHERE
+	CorrectPredefinedType : (PredefinedType <> IfcWindowTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcWindowTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcElementType.ElementType));
+END_ENTITY;
+
+ENTITY IfcWorkCalendar
+ SUBTYPE OF (IfcControl);
+	WorkingTimes : OPTIONAL SET [1:?] OF IfcWorkTime;
+	ExceptionTimes : OPTIONAL SET [1:?] OF IfcWorkTime;
+	PredefinedType : OPTIONAL IfcWorkCalendarTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR (PredefinedType <> IfcWorkCalendarTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcWorkCalendarTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcWorkControl
+ ABSTRACT SUPERTYPE OF (ONEOF
+    (IfcWorkPlan
+    ,IfcWorkSchedule))
+ SUBTYPE OF (IfcControl);
+	CreationDate : IfcDateTime;
+	Creators : OPTIONAL SET [1:?] OF IfcPerson;
+	Purpose : OPTIONAL IfcLabel;
+	Duration : OPTIONAL IfcDuration;
+	TotalFloat : OPTIONAL IfcDuration;
+	StartTime : IfcDateTime;
+	FinishTime : OPTIONAL IfcDateTime;
+END_ENTITY;
+
+ENTITY IfcWorkPlan
+ SUBTYPE OF (IfcWorkControl);
+	PredefinedType : OPTIONAL IfcWorkPlanTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR (PredefinedType <> IfcWorkPlanTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcWorkPlanTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcWorkSchedule
+ SUBTYPE OF (IfcWorkControl);
+	PredefinedType : OPTIONAL IfcWorkScheduleTypeEnum;
+ WHERE
+	CorrectPredefinedType : NOT(EXISTS(PredefinedType)) OR (PredefinedType <> IfcWorkScheduleTypeEnum.USERDEFINED) OR
+((PredefinedType = IfcWorkScheduleTypeEnum.USERDEFINED) AND EXISTS(SELF\IfcObject.ObjectType));
+END_ENTITY;
+
+ENTITY IfcWorkTime
+ SUBTYPE OF (IfcSchedulingTime);
+	RecurrencePattern : OPTIONAL IfcRecurrencePattern;
+	Start : OPTIONAL IfcDate;
+	Finish : OPTIONAL IfcDate;
+END_ENTITY;
+
+ENTITY IfcZShapeProfileDef
+ SUBTYPE OF (IfcParameterizedProfileDef);
+	Depth : IfcPositiveLengthMeasure;
+	FlangeWidth : IfcPositiveLengthMeasure;
+	WebThickness : IfcPositiveLengthMeasure;
+	FlangeThickness : IfcPositiveLengthMeasure;
+	FilletRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+	EdgeRadius : OPTIONAL IfcNonNegativeLengthMeasure;
+ WHERE
+	ValidFlangeThickness : FlangeThickness < (Depth / 2.);
+END_ENTITY;
+
+ENTITY IfcZone
+ SUBTYPE OF (IfcSystem);
+	LongName : OPTIONAL IfcLabel;
+ WHERE
+	WR1 : (SIZEOF(SELF\IfcGroup.IsGroupedBy) = 0) OR
+	(SIZEOF (QUERY (temp <* SELF\IfcGroup.IsGroupedBy[1].RelatedObjects |  
+		NOT(('IFC4.IFCZONE' IN TYPEOF(temp)) OR 
+		('IFC4.IFCSPACE' IN TYPEOF(temp)) OR
+		('IFC4.IFCSPATIALZONE' IN TYPEOF(temp))
+	))) = 0);
+END_ENTITY;
+
+FUNCTION IfcAssociatedSurface
+(Arg : IfcPcurve) : IfcSurface;
+
+   LOCAL
+     Surf : IfcSurface;
+   END_LOCAL;
+   
+   Surf := Arg\IfcPcurve.BasisSurface;
+   
+   RETURN(Surf);
+END_FUNCTION;
+
+FUNCTION IfcBaseAxis
+(Dim : INTEGER; 
+   Axis1, Axis2, Axis3 : IfcDirection) 
+    : LIST [2:3] OF IfcDirection;
+
+LOCAL
+  U : LIST [2:3] OF IfcDirection;
+  Factor : REAL;
+  D1, D2 : IfcDirection;
+END_LOCAL;
+
+  IF (Dim = 3) THEN 
+    D1 := NVL(IfcNormalise(Axis3), IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0,0.0,1.0]));
+    D2 := IfcFirstProjAxis(D1, Axis1);
+    U  := [D2, IfcSecondProjAxis(D1, D2, Axis2), D1];
+  ELSE
+    IF EXISTS(Axis1) THEN
+      D1 := IfcNormalise(Axis1);
+      U  := [D1, IfcOrthogonalComplement(D1)];
+      IF EXISTS(Axis2) THEN
+        Factor := IfcDotProduct(Axis2, U[2]);
+        IF (Factor < 0.0) THEN
+          U[2].DirectionRatios[1] := -U[2].DirectionRatios[1];
+          U[2].DirectionRatios[2] := -U[2].DirectionRatios[2];
+        END_IF;
+      END_IF;
+    ELSE
+      IF EXISTS(Axis2) THEN
+        D1 := IfcNormalise(Axis2);
+        U  := [IfcOrthogonalComplement(D1), D1];
+        U[1].DirectionRatios[1] := -U[1].DirectionRatios[1];
+        U[1].DirectionRatios[2] := -U[1].DirectionRatios[2];
+        ELSE
+          U := [IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([1.0, 0.0]), 
+                IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0, 1.0])];
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN(U);
+END_FUNCTION;
+
+FUNCTION IfcBooleanChoose
+(B : BOOLEAN ;
+     Choice1, Choice2 : GENERIC : Item) : GENERIC : Item;
+  IF B THEN
+     RETURN (Choice1);
+  ELSE
+     RETURN (Choice2);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION IfcBuild2Axes
+(RefDirection : IfcDirection)
+    : LIST [2:2] OF IfcDirection;
+LOCAL
+  D : IfcDirection := NVL(IfcNormalise(RefDirection),
+      IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([1.0,0.0]));
+END_LOCAL;
+  RETURN([D, IfcOrthogonalComplement(D)]);
+END_FUNCTION;
+
+FUNCTION IfcBuildAxes
+(Axis, RefDirection : IfcDirection) 
+    : LIST [3:3] OF IfcDirection;
+LOCAL
+  D1, D2 : IfcDirection;
+END_LOCAL;
+  D1 := NVL(IfcNormalise(Axis), IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0,0.0,1.0]));
+  D2 := IfcFirstProjAxis(D1, RefDirection);
+  RETURN ([D2, IfcNormalise(IfcCrossProduct(D1,D2))\IfcVector.Orientation, D1]);
+END_FUNCTION;
+
+FUNCTION IfcConsecutiveSegments
+(Segments : LIST [1:?] OF IfcSegmentIndexSelect)
+  : BOOLEAN;
+
+ LOCAL
+  Result : BOOLEAN := TRUE;
+ END_LOCAL;
+
+  REPEAT i := 1 TO (HIINDEX(Segments)-1);
+    IF Segments[i][HIINDEX(Segments[i])] <> Segments[i+1][1] THEN
+      BEGIN
+        Result := FALSE;
+        ESCAPE;
+      END;
+	END_IF;
+  END_REPEAT;
+
+  RETURN (Result);
+END_FUNCTION;
+
+FUNCTION IfcConstraintsParamBSpline
+( Degree, UpKnots, UpCp : INTEGER;
+  KnotMult : LIST OF INTEGER;
+  Knots : LIST OF IfcParameterValue ) 
+: BOOLEAN;
+
+
+  LOCAL
+    Result : BOOLEAN := TRUE;
+    K, Sum : INTEGER;
+  END_LOCAL;
+
+  (* Find sum of knot multiplicities. *)
+  Sum := KnotMult[1];
+  REPEAT i := 2 TO UpKnots;
+    Sum := Sum + KnotMult[i];
+  END_REPEAT;
+
+  (* Check limits holding for all B-spline parametrisations *)
+  IF (Degree < 1) OR (UpKnots < 2) OR (UpCp < Degree) OR
+    (Sum <> (Degree + UpCp + 2)) THEN
+    Result := FALSE;
+    RETURN(Result);
+  END_IF;
+
+  K := KnotMult[1];
+  IF (K < 1) OR (K > Degree + 1) THEN
+    Result := FALSE;
+    RETURN(Result);
+  END_IF;
+
+  REPEAT i := 2 TO UpKnots;
+    IF (KnotMult[i] < 1) OR (Knots[i] <= Knots[i-1]) THEN
+      Result := FALSE;
+      RETURN(Result);
+    END_IF;
+    K := KnotMult[i];
+    IF (i < UpKnots) AND (K > Degree) THEN
+      Result := FALSE;
+      RETURN(Result);
+    END_IF;
+    IF (i = UpKnots) AND (K > Degree + 1) THEN
+      Result := FALSE;
+      RETURN(Result);
+    END_IF;
+  END_REPEAT;
+
+  RETURN(result);
+END_FUNCTION;
+
+FUNCTION IfcConvertDirectionInto2D
+(Direction : IfcDirection)
+    : IfcDirection;
+	
+  LOCAL
+    Direction2D : IfcDirection := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.,1.]);
+  END_LOCAL;
+  
+  Direction2D.DirectionRatios[1] := Direction.DirectionRatios[1];
+  Direction2D.DirectionRatios[2] := Direction.DirectionRatios[2];
+  
+  RETURN (Direction2D);
+END_FUNCTION;
+
+FUNCTION IfcCorrectDimensions
+(m   : IfcUnitEnum; Dim : IfcDimensionalExponents) : LOGICAL;  
+CASE m OF
+  LENGTHUNIT : IF
+    Dim = (IfcDimensionalExponents (1, 0, 0, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  MASSUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 1, 0, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  TIMEUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 1, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ELECTRICCURRENTUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 1, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  THERMODYNAMICTEMPERATUREUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 0, 1, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  AMOUNTOFSUBSTANCEUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 0, 0, 1, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  LUMINOUSINTENSITYUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 0, 0, 0, 1))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  PLANEANGLEUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  SOLIDANGLEUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  AREAUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 0, 0, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  VOLUMEUNIT : IF
+    Dim = (IfcDimensionalExponents (3, 0, 0, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+
+  ABSORBEDDOSEUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 0, -2, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  RADIOACTIVITYUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, -1, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ELECTRICCAPACITANCEUNIT : IF
+    Dim = (IfcDimensionalExponents (-2, -1, 4, 2, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  DOSEEQUIVALENTUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 0, -2, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ELECTRICCHARGEUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 1, 1, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ELECTRICCONDUCTANCEUNIT : IF
+    Dim = (IfcDimensionalExponents (-2, -1, 3, 2, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ELECTRICVOLTAGEUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 1, -3, -1, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ELECTRICRESISTANCEUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 1, -3, -2, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ENERGYUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 1, -2, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  FORCEUNIT : IF
+    Dim = (IfcDimensionalExponents (1, 1, -2, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  FREQUENCYUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, -1, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  INDUCTANCEUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 1, -2, -2, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  ILLUMINANCEUNIT : IF
+    Dim = (IfcDimensionalExponents (-2, 0, 0, 0, 0, 0, 1))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  LUMINOUSFLUXUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 0, 0, 0, 0, 0, 1))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  MAGNETICFLUXUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 1, -2, -1, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  MAGNETICFLUXDENSITYUNIT : IF
+    Dim = (IfcDimensionalExponents (0, 1, -2, -1, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  POWERUNIT : IF
+    Dim = (IfcDimensionalExponents (2, 1, -3, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+  PRESSUREUNIT : IF
+    Dim = (IfcDimensionalExponents (-1, 1, -2, 0, 0, 0, 0))
+      THEN RETURN(TRUE);
+      ELSE RETURN(FALSE);
+    END_IF;
+
+  OTHERWISE :
+    RETURN (UNKNOWN);
+END_CASE;
+END_FUNCTION;
+
+FUNCTION IfcCorrectFillAreaStyle
+(Styles : SET[1:?] OF IfcFillStyleSelect)
+  :LOGICAL;
+
+LOCAL
+   Hatching : INTEGER := 0;
+   Tiles    : INTEGER := 0;
+   Colour   : INTEGER := 0;
+   External : INTEGER := 0;
+END_LOCAL;
+
+
+External := SIZEOF(QUERY(Style <* Styles |
+  'IFC4.IFCEXTERNALLYDEFINEDHATCHSTYLE' IN
+   TYPEOF(Style)));
+
+Hatching  := SIZEOF(QUERY(Style <* Styles |
+  'IFC4.IFCFILLAREASTYLEHATCHING' IN
+   TYPEOF(Style)));
+
+Tiles     := SIZEOF(QUERY(Style <* Styles |
+  'IFC4.IFCFILLAREASTYLETILES' IN
+   TYPEOF(Style)));
+
+Colour    := SIZEOF(QUERY(Style <* Styles |
+  'IFC4.IFCCOLOUR' IN
+   TYPEOF(Style)));
+
+
+IF (External > 1) THEN
+  RETURN (FALSE);
+END_IF;
+
+
+IF ((External = 1) AND ((Hatching > 0) OR (Tiles > 0) OR (Colour > 0))) THEN
+  RETURN (FALSE);
+END_IF;
+
+
+IF (Colour > 1) THEN
+  RETURN (FALSE);
+END_IF;
+
+IF ((Hatching > 0) AND (Tiles >0)) THEN
+  RETURN (FALSE);
+END_IF;
+
+RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION IfcCorrectLocalPlacement
+(AxisPlacement:IfcAxis2Placement; 
+   RelPlacement : IfcObjectPlacement):LOGICAL;
+
+  IF (EXISTS(RelPlacement)) THEN
+    IF ('IFC4.IFCGRIDPLACEMENT' IN TYPEOF(RelPlacement)) THEN
+      RETURN(?);
+    END_IF;
+    IF ('IFC4.IFCLOCALPLACEMENT' IN TYPEOF(RelPlacement)) THEN
+      IF ('IFC4.IFCAXIS2PLACEMENT2D' IN TYPEOF(AxisPlacement)) THEN
+        RETURN(TRUE);
+      END_IF;
+      IF ('IFC4.IFCAXIS2PLACEMENT3D' IN TYPEOF(AxisPlacement)) THEN
+        IF (RelPlacement\IfcLocalPlacement.RelativePlacement.Dim = 3) THEN
+          RETURN(TRUE);
+        ELSE
+          RETURN(FALSE);
+        END_IF;
+      END_IF;
+    END_IF;
+  ELSE
+    RETURN(TRUE);  
+  END_IF;
+  RETURN(?);
+END_FUNCTION;
+
+FUNCTION IfcCorrectObjectAssignment
+(Constraint: IfcObjectTypeEnum; Objects : SET[1:?] OF IfcObjectDefinition)
+  : LOGICAL ;
+  
+LOCAL
+  Count : INTEGER := 0;
+END_LOCAL;
+
+    IF NOT(EXISTS(Constraint)) THEN 
+      RETURN(TRUE);
+    END_IF;
+  
+    CASE Constraint OF
+      IfcObjectTypeEnum.NOTDEFINED : RETURN(TRUE);
+      IfcObjectTypeEnum.PRODUCT :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCPRODUCT' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      IfcObjectTypeEnum.PROCESS :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCPROCESS' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      IfcObjectTypeEnum.CONTROL :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCCONTROL' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      IfcObjectTypeEnum.RESOURCE :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCRESOURCE' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      IfcObjectTypeEnum.ACTOR :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCACTOR' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      IfcObjectTypeEnum.GROUP :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCGROUP' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      IfcObjectTypeEnum.PROJECT :
+        BEGIN
+          Count := SIZEOF(QUERY(temp <* Objects | NOT('IFC4.IFCPROJECT' IN TYPEOF(temp))));
+          RETURN(Count = 0);
+        END;
+      OTHERWISE : RETURN(?);
+    END_CASE;
+END_FUNCTION;
+
+FUNCTION IfcCorrectUnitAssignment
+(Units : SET [1:?] OF IfcUnit)
+   : LOGICAL;
+
+  LOCAL
+    NamedUnitNumber    : INTEGER := 0;
+    DerivedUnitNumber  : INTEGER := 0;
+    MonetaryUnitNumber : INTEGER := 0;
+    NamedUnitNames     : SET OF IfcUnitEnum := [];
+    DerivedUnitNames   : SET OF IfcDerivedUnitEnum := [];
+  END_LOCAL;
+
+  NamedUnitNumber    := SIZEOF(QUERY(temp <* Units | ('IFC4.IFCNAMEDUNIT' IN TYPEOF(temp)) AND NOT(temp\IfcNamedUnit.UnitType = IfcUnitEnum.USERDEFINED)));
+  DerivedUnitNumber  := SIZEOF(QUERY(temp <* Units | ('IFC4.IFCDERIVEDUNIT' IN TYPEOF(temp)) AND NOT(temp\IfcDerivedUnit.UnitType = IfcDerivedUnitEnum.USERDEFINED)));
+  MonetaryUnitNumber := SIZEOF(QUERY(temp <* Units |  'IFC4.IFCMONETARYUNIT' IN TYPEOF(temp)));
+
+  REPEAT i := 1 TO SIZEOF(Units);
+    IF (('IFC4.IFCNAMEDUNIT' IN TYPEOF(Units[i])) AND NOT(Units[i]\IfcNamedUnit.UnitType = IfcUnitEnum.USERDEFINED)) THEN
+        NamedUnitNames := NamedUnitNames + Units[i]\IfcNamedUnit.UnitType;
+    END_IF;
+    IF (('IFC4.IFCDERIVEDUNIT' IN TYPEOF(Units[i])) AND NOT(Units[i]\IfcDerivedUnit.UnitType = IfcDerivedUnitEnum.USERDEFINED)) THEN
+        DerivedUnitNames := DerivedUnitNames + Units[i]\IfcDerivedUnit.UnitType;
+    END_IF;
+  END_REPEAT;
+
+  RETURN((SIZEOF(NamedUnitNames) = NamedUnitNumber) AND (SIZEOF(DerivedUnitNames) = DerivedUnitNumber) AND (MonetaryUnitNumber <= 1));
+END_FUNCTION;
+
+FUNCTION IfcCrossProduct
+(Arg1, Arg2 : IfcDirection) 
+    : IfcVector;
+LOCAL
+  Mag : REAL;
+  Res : IfcDirection;
+  V1,V2  : LIST[3:3] OF REAL;
+  Result : IfcVector;
+END_LOCAL;
+
+  IF (NOT EXISTS (Arg1) OR (Arg1.Dim = 2)) OR (NOT EXISTS (Arg2) OR (Arg2.Dim = 2)) THEN
+    RETURN(?);
+  ELSE
+    BEGIN
+      V1  := IfcNormalise(Arg1)\IfcDirection.DirectionRatios;
+
+      V2  := IfcNormalise(Arg2)\IfcDirection.DirectionRatios;
+      Res := IfcRepresentationItem() || IfcGeometricRepresentationItem () 
+             || IfcDirection([(V1[2]*V2[3] - V1[3]*V2[2]), (V1[3]*V2[1] - V1[1]*V2[3]), (V1[1]*V2[2] - V1[2]*V2[1])]);
+      Mag := 0.0;
+      REPEAT i := 1 TO 3;
+        Mag := Mag + Res.DirectionRatios[i]*Res.DirectionRatios[i];
+      END_REPEAT;
+      IF (Mag > 0.0) THEN
+        Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(Res, SQRT(Mag));
+      ELSE
+        Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(Arg1, 0.0);
+      END_IF;
+      RETURN(Result);
+    END;
+  END_IF;
+END_FUNCTION;
+
+FUNCTION IfcCurveDim
+(Curve : IfcCurve)
+       : IfcDimensionCount;
+
+  IF ('IFC4.IFCLINE' IN TYPEOF(Curve))
+    THEN RETURN(Curve\IfcLine.Pnt.Dim);
+  END_IF;
+  IF ('IFC4.IFCCONIC' IN TYPEOF(Curve))
+    THEN RETURN(Curve\IfcConic.Position.Dim);
+  END_IF;
+  IF ('IFC4.IFCPOLYLINE' IN TYPEOF(Curve))
+    THEN RETURN(Curve\IfcPolyline.Points[1].Dim);
+  END_IF;
+  IF ('IFC4.IFCTRIMMEDCURVE' IN TYPEOF(Curve))
+    THEN RETURN(IfcCurveDim(Curve\IfcTrimmedCurve.BasisCurve));
+  END_IF;
+  IF ('IFC4.IFCCOMPOSITECURVE' IN TYPEOF(Curve))
+    THEN RETURN(Curve\IfcCompositeCurve.Segments[1].Dim);
+  END_IF;
+  IF ('IFC4.IFCBSPLINECURVE' IN TYPEOF(Curve))
+    THEN RETURN(Curve\IfcBSplineCurve.ControlPointsList[1].Dim);
+  END_IF;
+  IF ('IFC4.IFCOFFSETCURVE2D' IN TYPEOF(Curve))
+    THEN RETURN(2); 
+  END_IF;
+  IF ('IFC4.IFCOFFSETCURVE3D' IN TYPEOF(Curve))
+    THEN RETURN(3);
+  END_IF;
+  IF ('IFC4.IFCPCURVE' IN TYPEOF(Curve))
+    THEN RETURN(3);
+  END_IF;
+  IF ('IFC4.IFCINDEXEDPOLYCURVE' IN TYPEOF(Curve))
+    THEN RETURN(Curve\IfcIndexedPolyCurve.Points.Dim);
+  END_IF;
+RETURN (?);
+END_FUNCTION;
+
+FUNCTION IfcCurveWeightsPositive
+( B: IfcRationalBSplineCurveWithKnots)
+: BOOLEAN;
+
+  LOCAL
+    Result : BOOLEAN := TRUE;
+  END_LOCAL;
+
+  REPEAT i := 0 TO B.UpperIndexOnControlPoints;
+    IF B.Weights[i] <= 0.0  THEN
+      Result := FALSE;
+      RETURN(Result);
+    END_IF;
+  END_REPEAT;
+  RETURN(Result);
+END_FUNCTION;
+
+FUNCTION IfcDeriveDimensionalExponents
+(UnitElements : SET [1:?] OF IfcDerivedUnitElement)
+    : IfcDimensionalExponents;  
+    LOCAL
+    Result : IfcDimensionalExponents :=
+            IfcDimensionalExponents(0, 0, 0, 0, 0, 0, 0);  
+    END_LOCAL;
+    REPEAT i := LOINDEX(UnitElements) TO HIINDEX(UnitElements);
+        Result.LengthExponent := Result.LengthExponent +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.LengthExponent);
+        Result.MassExponent := Result.MassExponent  +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.MassExponent);
+        Result.TimeExponent := Result.TimeExponent +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.TimeExponent);
+        Result.ElectricCurrentExponent := Result.ElectricCurrentExponent +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.ElectricCurrentExponent);
+        Result.ThermodynamicTemperatureExponent := Result.ThermodynamicTemperatureExponent +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.ThermodynamicTemperatureExponent);
+        Result.AmountOfSubstanceExponent := Result.AmountOfSubstanceExponent +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.AmountOfSubstanceExponent);
+        Result.LuminousIntensityExponent := Result.LuminousIntensityExponent +
+          (UnitElements[i].Exponent *
+           UnitElements[i].Unit.Dimensions.LuminousIntensityExponent);
+    END_REPEAT;  
+    RETURN (Result);
+END_FUNCTION;
+
+FUNCTION IfcDimensionsForSiUnit
+(n : IfcSiUnitName )     : IfcDimensionalExponents;
+  CASE n OF
+    METRE          : RETURN (IfcDimensionalExponents
+                             (1, 0, 0, 0, 0, 0, 0));
+    SQUARE_METRE   : RETURN (IfcDimensionalExponents
+                             (2, 0, 0, 0, 0, 0, 0));
+    CUBIC_METRE    : RETURN (IfcDimensionalExponents
+                             (3, 0, 0, 0, 0, 0, 0));
+    GRAM           : RETURN (IfcDimensionalExponents
+                             (0, 1, 0, 0, 0, 0, 0));
+    SECOND         : RETURN (IfcDimensionalExponents
+                             (0, 0, 1, 0, 0, 0, 0));
+    AMPERE         : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 1, 0, 0, 0));
+    KELVIN         : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 1, 0, 0));
+    MOLE           : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 0, 1, 0));
+    CANDELA        : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 0, 0, 1));
+    RADIAN         : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 0, 0, 0));
+    STERADIAN      : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 0, 0, 0));
+    HERTZ          : RETURN (IfcDimensionalExponents
+                             (0, 0, -1, 0, 0, 0, 0));
+    NEWTON         : RETURN (IfcDimensionalExponents
+                             (1, 1, -2, 0, 0, 0, 0));
+    PASCAL         : RETURN (IfcDimensionalExponents
+                             (-1, 1, -2, 0, 0, 0, 0));
+    JOULE          : RETURN (IfcDimensionalExponents
+                             (2, 1, -2, 0, 0, 0, 0));
+    WATT           : RETURN (IfcDimensionalExponents
+                             (2, 1, -3, 0, 0, 0, 0));
+    COULOMB        : RETURN (IfcDimensionalExponents
+                             (0, 0, 1, 1, 0, 0, 0));
+    VOLT           : RETURN (IfcDimensionalExponents
+                             (2, 1, -3, -1, 0, 0, 0));
+    FARAD          : RETURN (IfcDimensionalExponents
+                             (-2, -1, 4, 2, 0, 0, 0));
+    OHM            : RETURN (IfcDimensionalExponents
+                             (2, 1, -3, -2, 0, 0, 0));
+    SIEMENS        : RETURN (IfcDimensionalExponents
+                             (-2, -1, 3, 2, 0, 0, 0));
+    WEBER          : RETURN (IfcDimensionalExponents
+                             (2, 1, -2, -1, 0, 0, 0));
+    TESLA          : RETURN (IfcDimensionalExponents
+                             (0, 1, -2, -1, 0, 0, 0));
+    HENRY          : RETURN (IfcDimensionalExponents
+                             (2, 1, -2, -2, 0, 0, 0));
+    DEGREE_CELSIUS : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 1, 0, 0));
+    LUMEN          : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 0, 0, 1));
+    LUX            : RETURN (IfcDimensionalExponents
+                             (-2, 0, 0, 0, 0, 0, 1));
+    BECQUEREL      : RETURN (IfcDimensionalExponents
+                             (0, 0, -1, 0, 0, 0, 0));
+    GRAY           : RETURN (IfcDimensionalExponents
+                             (2, 0, -2, 0, 0, 0, 0));
+    SIEVERT        : RETURN (IfcDimensionalExponents
+                             (2, 0, -2, 0, 0, 0, 0));
+    OTHERWISE      : RETURN (IfcDimensionalExponents
+                             (0, 0, 0, 0, 0, 0, 0));
+  END_CASE;
+END_FUNCTION;
+
+FUNCTION IfcDotProduct
+(Arg1, Arg2 : IfcDirection) 
+    : REAL;
+LOCAL
+  Scalar : REAL;
+  Vec1, Vec2 : IfcDirection;
+  Ndim   : INTEGER;
+END_LOCAL;
+
+  IF NOT EXISTS (Arg1) OR NOT EXISTS (Arg2) THEN
+    Scalar := ?;
+  ELSE
+    IF (Arg1.Dim <> Arg2.Dim) THEN
+      Scalar := ?;
+    ELSE
+      BEGIN
+        Vec1 := IfcNormalise(Arg1);
+        Vec2 := IfcNormalise(Arg2);
+        Ndim := Arg1.Dim;
+        Scalar := 0.0;
+        REPEAT i := 1 TO Ndim;
+          Scalar := Scalar + Vec1.DirectionRatios[i]*Vec2.DirectionRatios[i];
+        END_REPEAT;
+      END;
+    END_IF;
+  END_IF;
+  RETURN (Scalar);
+END_FUNCTION;
+
+FUNCTION IfcFirstProjAxis
+(ZAxis, Arg : IfcDirection) : IfcDirection;
+LOCAL
+  XAxis : IfcDirection;
+  V     : IfcDirection;
+  Z     : IfcDirection;
+  XVec  : IfcVector;
+END_LOCAL;
+
+  IF (NOT EXISTS(ZAxis)) THEN
+    RETURN (?) ;
+  ELSE
+    Z := IfcNormalise(ZAxis);
+    IF NOT EXISTS(Arg) THEN
+      IF (Z.DirectionRatios <> [1.0,0.0,0.0]) THEN
+        V := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([1.0,0.0,0.0]);
+      ELSE
+        V := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0,1.0,0.0]);
+      END_IF;
+    ELSE
+      IF (Arg.Dim <> 3) THEN
+        RETURN (?) ;
+      END_IF;
+      IF ((IfcCrossProduct(Arg,Z).Magnitude) = 0.0) THEN
+        RETURN (?);
+      ELSE
+        V := IfcNormalise(Arg);
+      END_IF;
+    END_IF;
+    XVec  := IfcScalarTimesVector(IfcDotProduct(V, Z), Z);
+    XAxis := IfcVectorDifference(V, XVec).Orientation;
+    XAxis := IfcNormalise(XAxis);
+  END_IF;
+  RETURN(XAxis);
+END_FUNCTION;
+
+FUNCTION IfcGetBasisSurface
+(C : IfcCurveOnSurface) : SET[0:2] OF IfcSurface;
+
+  LOCAL
+    Surfs : SET[0:2] OF IfcSurface;
+    N : INTEGER;
+  END_LOCAL;
+
+  Surfs := [];
+  IF 'IFC4.IFCPCURVE' IN TYPEOF (C) THEN
+    Surfs := [C\IfcPCurve.BasisSurface];
+  ELSE
+    IF 'IFC4.IFCSURFACECURVE' IN TYPEOF (C) THEN
+      N := SIZEOF(C\IfcSurfaceCurve.AssociatedGeometry);
+      REPEAT i := 1 TO N;
+      Surfs := Surfs + IfcAssociatedSurface(C\IfcSurfaceCurve.AssociatedGeometry[i]);
+      END_REPEAT;
+    END_IF;
+  END_IF;
+  IF 'IFC4.IFCCOMPOSITECURVEONSURFACE' IN TYPEOF (C) THEN
+
+    (* For an IfcCompositeCurveOnSurface the BasisSurface is the intersection of the BasisSurface of all the segments. *)
+
+    N := SIZEOF(C\IfcCompositeCurve.Segments);
+    Surfs := IfcGetBasisSurface(C\IfcCompositeCurve.Segments[1].ParentCurve);
+    IF N > 1 THEN
+      REPEAT i := 2 TO N;
+        Surfs := Surfs * IfcGetBasisSurface(C\IfcCompositeCurve.Segments[1].ParentCurve);
+      END_REPEAT;
+    END_IF;
+  END_IF;
+  RETURN(Surfs);
+END_FUNCTION;
+
+FUNCTION IfcListToArray
+(Lis : LIST [0:?] OF GENERIC : T;
+       Low,U : INTEGER) : ARRAY OF GENERIC : T;
+   LOCAL
+     N   : INTEGER;
+     Res : ARRAY [Low:U] OF GENERIC : T;
+   END_LOCAL;
+      
+   N := SIZEOF(Lis);
+   IF (N <> (U-Low +1)) THEN
+     RETURN(?);
+   ELSE
+     Res := [Lis[1] : N];
+     REPEAT i := 2 TO N;
+       Res[Low+i-1] := Lis[i];
+     END_REPEAT;
+     RETURN(Res);
+   END_IF;
+END_FUNCTION;
+
+FUNCTION IfcLoopHeadToTail
+(ALoop : IfcEdgeLoop) : LOGICAL;
+   LOCAL
+     N : INTEGER;
+     P : LOGICAL := TRUE;
+   END_LOCAL;
+     
+     N := SIZEOF (ALoop.EdgeList);
+     REPEAT i := 2 TO N;
+       P := P AND (ALoop.EdgeList[i-1].EdgeEnd :=:
+                   ALoop.EdgeList[i].EdgeStart);
+     END_REPEAT;     
+     RETURN (P);
+END_FUNCTION;
+
+FUNCTION IfcMakeArrayOfArray
+(Lis : LIST[1:?] OF LIST [1:?] OF GENERIC : T;
+ Low1, U1, Low2, U2 : INTEGER):
+ARRAY [Low1:U1] OF ARRAY [Low2:U2] OF GENERIC : T;
+
+  LOCAL
+    Res : ARRAY[Low1:U1] OF ARRAY [Low2:U2] OF GENERIC : T;
+  END_LOCAL;
+
+  (* Check input dimensions for consistency *)
+  IF (U1-Low1+1) <> SIZEOF(Lis) THEN
+    RETURN (?);
+  END_IF;
+  IF (U2 - Low2 + 1 ) <> SIZEOF(Lis[1]) THEN
+    RETURN (?) ;
+  END_IF;
+
+  (* Initialise Res with values from Lis[1] *)
+  Res := [IfcListToArray(Lis[1], Low2, U2) : (U1-Low1 + 1)];
+  REPEAT i := 2 TO HIINDEX(Lis);
+    IF (U2-Low2+1) <> SIZEOF(Lis[i]) THEN
+      RETURN (?);
+    END_IF;
+    Res[Low1+i-1] := IfcListToArray(Lis[i], Low2, U2);
+  END_REPEAT;
+  RETURN (Res);
+END_FUNCTION;
+
+FUNCTION IfcMlsTotalThickness
+(LayerSet : IfcMaterialLayerSet) : IfcLengthMeasure;
+  LOCAL
+    Max : IfcLengthMeasure := LayerSet.MaterialLayers[1].LayerThickness;    
+  END_LOCAL;
+
+  IF SIZEOF(LayerSet.MaterialLayers) > 1 THEN
+    REPEAT i := 2 TO HIINDEX(LayerSet.MaterialLayers);
+       Max := Max + LayerSet.MaterialLayers[i].LayerThickness;
+    END_REPEAT;
+  END_IF;
+  RETURN (Max);
+END_FUNCTION;
+
+FUNCTION IfcNormalise
+(Arg : IfcVectorOrDirection) 
+    : IfcVectorOrDirection;
+LOCAL
+  Ndim : INTEGER;
+  V    : IfcDirection
+         := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([1.,0.]); 
+  Vec  : IfcVector 
+         := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector (
+            IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([1.,0.]), 1.);
+  Mag  : REAL;
+  Result : IfcVectorOrDirection
+         := V;
+END_LOCAL;
+
+  IF NOT EXISTS (Arg) THEN
+    RETURN (?);
+  ELSE
+    IF 'IFC4.IFCVECTOR' IN TYPEOF(Arg) THEN
+      BEGIN
+        Ndim := Arg\IfcVector.Dim;
+	V.DirectionRatios := Arg\IfcVector.Orientation.DirectionRatios;
+        Vec.Magnitude := Arg\IfcVector.Magnitude;
+	Vec.Orientation := V;
+        IF Arg\IfcVector.Magnitude = 0.0 THEN
+          RETURN(?);
+        ELSE
+          Vec.Magnitude := 1.0;
+        END_IF;
+      END;
+    ELSE
+      BEGIN
+        Ndim := Arg\IfcDirection.Dim;
+        V.DirectionRatios := Arg\IfcDirection.DirectionRatios;
+      END;
+    END_IF;
+
+    Mag := 0.0;
+      REPEAT i := 1 TO Ndim;
+        Mag := Mag + V.DirectionRatios[i]*V.DirectionRatios[i];
+      END_REPEAT;
+    IF Mag > 0.0 THEN
+      Mag := SQRT(Mag);
+      REPEAT i := 1 TO Ndim;
+        V.DirectionRatios[i] := V.DirectionRatios[i]/Mag;
+      END_REPEAT;
+      IF 'IFC4.IFCVECTOR' IN TYPEOF(arg) THEN
+        Vec.Orientation := V;
+        Result := Vec;
+      ELSE
+        Result := V;
+      END_IF;
+    ELSE
+      RETURN(?);
+    END_IF;
+  END_IF;
+  RETURN (Result);
+END_FUNCTION;
+
+FUNCTION IfcOrthogonalComplement
+(Vec : IfcDirection) 
+    : IfcDirection;
+LOCAL
+  Result : IfcDirection ;
+END_LOCAL;
+  IF NOT EXISTS (Vec) OR (Vec.Dim <> 2) THEN
+    RETURN(?);
+  ELSE
+    Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([-Vec.DirectionRatios[2], Vec.DirectionRatios[1]]);
+    RETURN(Result);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION IfcPathHeadToTail
+(APath : IfcPath) : LOGICAL;
+   LOCAL
+     N : INTEGER := 0;
+     P : LOGICAL := UNKNOWN;
+   END_LOCAL;
+     N := SIZEOF (APath.EdgeList);
+   REPEAT i := 2 TO N;
+      P := P AND (APath.EdgeList[i-1].EdgeEnd :=:
+                  APath.EdgeList[i].EdgeStart);
+   END_REPEAT;
+   RETURN (P);
+END_FUNCTION;
+
+FUNCTION IfcPointListDim
+(PointList : IfcCartesianPointList)
+           : IfcDimensionCount;
+
+  IF ('IFC4.IFCCARTESIANPOINTLIST2D' IN TYPEOF(PointList))
+    THEN RETURN(2);
+  END_IF;		   
+  IF ('IFC4.IFCCARTESIANPOINTLIST3D' IN TYPEOF(PointList))
+    THEN RETURN(3);
+  END_IF;		   
+  RETURN (?);
+END_FUNCTION;
+
+FUNCTION IfcSameAxis2Placement
+(ap1, ap2 : IfcAxis2Placement; Epsilon : REAL)
+  : LOGICAL ;
+
+  RETURN (IfcSameDirection(ap1.P[1],ap2.P[1],Epsilon) AND
+          IfcSameDirection(ap1.P[2],ap2.P[2],Epsilon) AND
+          IfcSameCartesianPoint(ap1.Location,ap1.Location,Epsilon));
+END_FUNCTION;
+
+FUNCTION IfcSameCartesianPoint
+(cp1, cp2 : IfcCartesianPoint; Epsilon : REAL)
+	: LOGICAL;
+  
+  LOCAL
+    cp1x : REAL := cp1.Coordinates[1];
+    cp1y : REAL := cp1.Coordinates[2];
+    cp1z : REAL := 0;
+    cp2x : REAL := cp2.Coordinates[1];
+    cp2y : REAL := cp2.Coordinates[2];
+    cp2z : REAL := 0;
+  END_LOCAL;
+
+  IF (SIZEOF(cp1.Coordinates) > 2) THEN
+    cp1z := cp1.Coordinates[3];
+  END_IF;
+
+  IF (SIZEOF(cp2.Coordinates) > 2) THEN
+    cp2z := cp2.Coordinates[3];
+  END_IF;
+
+  RETURN (IfcSameValue(cp1x,cp2x,Epsilon) AND
+          IfcSameValue(cp1y,cp2y,Epsilon) AND
+          IfcSameValue(cp1z,cp2z,Epsilon));
+END_FUNCTION;
+
+FUNCTION IfcSameDirection
+(dir1, dir2 : IfcDirection; Epsilon : REAL)
+	: LOGICAL;
+  LOCAL
+    dir1x : REAL := dir1.DirectionRatios[1];
+    dir1y : REAL := dir1.DirectionRatios[2];
+    dir1z : REAL := 0;
+    dir2x : REAL := dir2.DirectionRatios[1];
+    dir2y : REAL := dir2.DirectionRatios[2];
+    dir2z : REAL := 0;
+  END_LOCAL;
+
+  IF (SIZEOF(dir1.DirectionRatios) > 2) THEN
+    dir1z := dir1.DirectionRatios[3];
+  END_IF;
+
+  IF (SIZEOF(dir2.DirectionRatios) > 2) THEN
+    dir2z := dir2.DirectionRatios[3];
+  END_IF;
+  
+  RETURN (IfcSameValue(dir1x,dir2x,Epsilon) AND
+          IfcSameValue(dir1y,dir2y,Epsilon) AND
+          IfcSameValue(dir1z,dir2z,Epsilon));
+END_FUNCTION;
+
+FUNCTION IfcSameValidPrecision
+(Epsilon1, Epsilon2 : REAL) : LOGICAL ;
+  LOCAL
+    ValidEps1, ValidEps2 : REAL;
+    DefaultEps           : REAL := 0.000001;
+    DerivationOfEps      : REAL := 1.001;
+    UpperEps             : REAL := 1.0;
+  END_LOCAL;
+  
+    ValidEps1 := NVL(Epsilon1, DefaultEps);
+    ValidEps2 := NVL(Epsilon2, DefaultEps);
+    RETURN ((0.0 < ValidEps1) AND (ValidEps1 <= (DerivationOfEps * ValidEps2)) AND 
+            (ValidEps2 <= (DerivationOfEps * ValidEps1)) AND (ValidEps2 < UpperEps));
+END_FUNCTION;
+
+FUNCTION IfcSameValue
+(Value1, Value2 : REAL; Epsilon : REAL)
+	: LOGICAL;
+  LOCAL
+    ValidEps    : REAL;
+    DefaultEps  : REAL := 0.000001;
+  END_LOCAL;
+  
+  ValidEps := NVL(Epsilon, DefaultEps);
+  RETURN ((Value1 + ValidEps > Value2) AND (Value1 < Value2 + ValidEps));
+END_FUNCTION;
+
+FUNCTION IfcScalarTimesVector
+(Scalar : REAL; Vec : IfcVectorOrDirection)
+    : IfcVector;
+LOCAL
+  V : IfcDirection;
+  Mag : REAL;
+  Result : IfcVector;
+END_LOCAL;
+
+  IF NOT EXISTS (Scalar) OR NOT EXISTS (Vec) THEN
+    RETURN (?) ;
+  ELSE
+    IF 'IFC4.IFCVECTOR' IN TYPEOF (Vec) THEN
+      V := Vec\IfcVector.Orientation;
+      Mag := Scalar * Vec\IfcVector.Magnitude;
+    ELSE
+      V := Vec;
+      Mag := Scalar;
+    END_IF;
+    IF (Mag < 0.0 ) THEN
+      REPEAT i := 1 TO SIZEOF(V.DirectionRatios);
+        V.DirectionRatios[i] := -V.DirectionRatios[i];
+      END_REPEAT;
+      Mag := -Mag;
+    END_IF;
+    Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector(IfcNormalise(V), Mag);
+  END_IF;
+  RETURN (Result);
+END_FUNCTION;
+
+FUNCTION IfcSecondProjAxis
+(ZAxis, XAxis, Arg: IfcDirection) 
+    : IfcDirection;
+LOCAL
+  YAxis : IfcVector;
+  V     : IfcDirection;
+  Temp  : IfcVector;
+END_LOCAL;
+
+  IF NOT EXISTS(Arg) THEN
+    V := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0,1.0,0.0]);
+  ELSE
+    V := Arg;
+  END_IF;
+  Temp  := IfcScalarTimesVector(IfcDotProduct(V, ZAxis), ZAxis);
+  YAxis := IfcVectorDifference(V, Temp);
+  Temp  := IfcScalarTimesVector(IfcDotProduct(V, XAxis), XAxis);
+  YAxis := IfcVectorDifference(YAxis, Temp);
+  YAxis := IfcNormalise(YAxis);
+  RETURN(YAxis.Orientation);
+END_FUNCTION;
+
+FUNCTION IfcShapeRepresentationTypes
+(RepType : IfcLabel; Items : SET OF IfcRepresentationItem) : LOGICAL;
+    
+    LOCAL
+      Count : INTEGER := 0;
+    END_LOCAL;
+
+    CASE RepType OF 
+    'Point' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCPOINT' IN TYPEOF(temp))));
+      END;
+
+    'PointCloud' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCCARTESIANPOINTLIST3D' IN TYPEOF(temp))));
+      END;
+
+    'Curve' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCCURVE' IN TYPEOF(temp))));
+      END;
+
+    'Curve2D' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCCURVE' IN TYPEOF(temp)) 
+                 AND (temp\IfcCurve.Dim = 2)));
+      END;
+
+    'Curve3D' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCCURVE' IN TYPEOF(temp)) 
+                 AND (temp\IfcCurve.Dim = 3)));
+      END;
+
+    'Surface' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCSURFACE' IN TYPEOF(temp))));
+      END;
+
+    'Surface2D' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCSURFACE' IN TYPEOF(temp)) 
+                 AND (temp\IfcSurface.Dim = 2)));
+      END;
+
+    'Surface3D' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCSURFACE' IN TYPEOF(temp)) 
+                 AND (temp\IfcSurface.Dim = 3)));
+      END;
+
+    'FillArea' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCANNOTATIONFILLAREA' IN TYPEOF(temp))));
+      END;
+
+    'Text' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCTEXTLITERAL' IN TYPEOF(temp))));
+      END;
+
+    'AdvancedSurface' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | 'IFC4.IFCBSPLINESURFACE' IN TYPEOF(temp)));
+      END;
+
+    'Annotation2D' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | (
+                  SIZEOF(TYPEOF(temp) * [
+                   'IFC4.IFCPOINT',
+                   'IFC4.IFCCURVE',
+                   'IFC4.IFCGEOMETRICCURVESET',
+                   'IFC4.IFCANNOTATIONFILLAREA',
+                   'IFC4.IFCTEXTLITERAL']) = 1)
+                 ));
+      END;
+
+    'GeometricSet' : 
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCGEOMETRICSET' IN TYPEOF(temp))
+                 OR ('IFC4.IFCPOINT' IN TYPEOF(temp))
+                 OR ('IFC4.IFCCURVE' IN TYPEOF(temp))
+                 OR ('IFC4.IFCSURFACE' IN TYPEOF(temp))));
+      END;
+
+    'GeometricCurveSet' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCGEOMETRICCURVESET' IN TYPEOF(temp))
+                 OR ('IFC4.IFCGEOMETRICSET' IN TYPEOF(temp))
+                 OR ('IFC4.IFCPOINT' IN TYPEOF(temp))
+                 OR ('IFC4.IFCCURVE' IN TYPEOF(temp))));
+         REPEAT i:=1 TO HIINDEX(Items);  
+           IF ('IFC4.IFCGEOMETRICSET' IN TYPEOF(Items[i]))
+           THEN
+             IF (SIZEOF(QUERY(temp <* Items[i]\IfcGeometricSet.Elements | 'IFC4.IFCSURFACE' IN TYPEOF(temp))) > 0)
+             THEN
+               Count := Count - 1;
+             END_IF;
+           END_IF;
+         END_REPEAT;
+      END;
+
+    'Tessellation' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | 'IFC4.IFCTESSELLATEDITEM' IN TYPEOF(temp)));
+      END;
+
+    'SurfaceOrSolidModel' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | SIZEOF([
+                   'IFC4.IFCTESSELLATEDITEM',
+                   'IFC4.IFCSHELLBASEDSURFACEMODEL',
+                   'IFC4.IFCFACEBASEDSURFACEMODEL',
+                   'IFC4.IFCSOLIDMODEL'] * TYPEOF(temp)) >= 1
+                 ));      
+      END;
+
+    'SurfaceModel' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | SIZEOF([
+                   'IFC4.IFCTESSELLATEDITEM',
+                   'IFC4.IFCSHELLBASEDSURFACEMODEL',
+                   'IFC4.IFCFACEBASEDSURFACEMODEL'] * TYPEOF(temp)) >= 1
+                 ));      
+      END;
+
+    'SolidModel' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCSOLIDMODEL' IN TYPEOF(temp))));            
+      END;
+
+    'SweptSolid' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | (SIZEOF([
+                   'IFC4.IFCEXTRUDEDAREASOLID',
+                   'IFC4.IFCREVOLVEDAREASOLID'] * TYPEOF(temp)) >= 1
+                   ) AND (SIZEOF([
+                   'IFC4.IFCEXTRUDEDAREASOLIDTAPERED',
+                   'IFC4.IFCREVOLVEDAREASOLIDTAPERED'] * TYPEOF(temp)) = 0
+                   )
+                 ));                             
+      END;
+
+    'AdvancedSweptSolid' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | SIZEOF([
+                   'IFC4.IFCSWEPTAREASOLID',
+                   'IFC4.IFCSWEPTDISKSOLID'] *  TYPEOF(temp)) >= 1
+                 ));      
+      END;
+
+    'CSG' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | SIZEOF([
+                   'IFC4.IFCBOOLEANRESULT',
+                   'IFC4.IFCCSGPRIMITIVE3D',
+                   'IFC4.IFCCSGSOLID'] *  TYPEOF(temp)) >= 1
+                 ));            
+      END;
+
+    'Clipping' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | SIZEOF([
+                   'IFC4.IFCCSGSOLID',
+                   'IFC4.IFCBOOLEANCLIPPINGRESULT'] * TYPEOF(temp)) >= 1
+                 )); 
+      END;
+
+    'Brep' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCFACETEDBREP' IN TYPEOF(temp))));      
+      END;
+
+    'AdvancedBrep' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCMANIFOLDSOLIDBREP' IN TYPEOF(temp))));      
+      END;
+
+    'BoundingBox' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCBOUNDINGBOX' IN TYPEOF(temp))));
+        IF (SIZEOF(Items) > 1)
+        THEN
+          Count := 0;
+        END_IF;   
+      END;
+
+    'SectionedSpine' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCSECTIONEDSPINE' IN TYPEOF(temp))));      
+      END;
+
+    'LightSource' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCLIGHTSOURCE' IN TYPEOF(temp))));      
+      END;
+
+    'MappedRepresentation' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | ('IFC4.IFCMAPPEDITEM' IN TYPEOF(temp))));  
+      END;
+
+     OTHERWISE : RETURN(?);
+    END_CASE;
+    RETURN (Count = SIZEOF(Items));
+END_FUNCTION;
+
+FUNCTION IfcSurfaceWeightsPositive
+( B: IfcRationalBSplineSurfaceWithKnots) 
+: BOOLEAN;
+
+  LOCAL
+    Result : BOOLEAN := TRUE;
+  END_LOCAL;
+
+  REPEAT i := 0 TO B\IfcBSplineSurface.UUpper;
+    REPEAT j := 0 TO B\IfcBSplineSurface.VUpper;
+      IF (B.Weights[i][j] <= 0.0) THEN
+        Result := FALSE;
+        RETURN(Result);
+      END_IF;
+    END_REPEAT;
+  END_REPEAT;
+  RETURN(Result);
+END_FUNCTION;
+
+FUNCTION IfcTaperedSweptAreaProfiles
+(StartArea, EndArea : IfcProfileDef)
+ : LOGICAL;
+
+LOCAL
+   Result : LOGICAL := FALSE;
+END_LOCAL;
+   
+IF ('IFC4.IFCPARAMETERIZEDPROFILEDEF' IN TYPEOF(StartArea)) THEN
+   IF ('IFC4.IFCDERIVEDPROFILEDEF' IN TYPEOF(EndArea)) THEN
+      Result := (StartArea :=: EndArea\IfcDerivedProfileDef.ParentProfile);
+   ELSE
+      Result := (TYPEOF(StartArea) = TYPEOF(EndArea));
+   END_IF;
+ELSE
+   IF ('IFC4.IFCDERIVEDPROFILEDEF' IN TYPEOF(EndArea)) THEN
+      Result := (StartArea :=: EndArea\IfcDerivedProfileDef.ParentProfile);
+   ELSE
+      Result := FALSE;
+   END_IF;
+END_IF;
+
+RETURN(Result);
+END_FUNCTION;
+
+FUNCTION IfcTopologyRepresentationTypes
+(RepType : IfcLabel; Items : SET OF IfcRepresentationItem) : LOGICAL;
+    
+    LOCAL
+      Count : INTEGER := 0;
+    END_LOCAL;
+
+    CASE RepType OF 
+    'Vertex' :
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | 
+                  ('IFC4.IFCVERTEX' IN TYPEOF(temp))));
+      END;
+    'Edge' : 
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | 
+                  ('IFC4.IFCEDGE' IN TYPEOF(temp))));
+      END;
+    'Path' : 
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | 
+                  ('IFC4.IFCPATH' IN TYPEOF(temp))));
+      END;
+    'Face' : 
+      BEGIN 
+        Count := SIZEOF(QUERY(temp <* Items | 
+                  ('IFC4.IFCFACE' IN TYPEOF(temp))));
+      END;
+    'Shell' :
+      BEGIN
+        Count := SIZEOF(QUERY(temp <* Items | 
+                  ('IFC4.IFCOPENSHELL' IN TYPEOF(temp))
+                    OR ('IFC4.IFCCLOSEDSHELL' IN TYPEOF(temp))));
+      END;
+    'Undefined': RETURN(TRUE);
+     OTHERWISE : RETURN(?);
+    END_CASE;
+    RETURN (Count = SIZEOF(Items));
+END_FUNCTION;
+
+FUNCTION IfcUniqueDefinitionNames
+(Relations : SET [1:?] OF IfcRelDefinesByProperties)
+:LOGICAL;
+
+LOCAL
+  Definition : IfcPropertySetDefinitionSelect;
+  DefinitionSet : IfcPropertySetDefinitionSet;
+  Properties : SET OF IfcPropertySetDefinition := [];
+  Result : LOGICAL;
+END_LOCAL;
+
+IF SIZEOF(Relations) = 0 THEN
+  RETURN(TRUE);
+END_IF;
+
+REPEAT i:=1 TO HIINDEX(Relations);
+  Definition := Relations[i].RelatingPropertyDefinition;
+  IF 'IFC4.IFCPROPERTYSETDEFINITION' IN TYPEOF(Definition) THEN
+    Properties := Properties + Definition;
+  ELSE 
+    IF 'IFC4.IFCPROPERTYSETDEFINITIONSET' IN TYPEOF(Definition) THEN
+      BEGIN
+        DefinitionSet := Definition;
+        REPEAT j:= 1 TO HIINDEX(DefinitionSet);
+          Properties := Properties + DefinitionSet[j];
+        END_REPEAT;
+      END;
+	END_IF;
+  END_IF;
+END_REPEAT;
+
+Result := IfcUniquePropertySetNames(Properties);
+RETURN (Result);
+END_FUNCTION;
+
+FUNCTION IfcUniquePropertyName
+(Properties : SET [1:?] OF IfcProperty)
+ :LOGICAL;
+
+ LOCAL
+   Names : SET OF IfcIdentifier := [];
+ END_LOCAL;
+
+ REPEAT i:=1 TO HIINDEX(Properties);
+   Names := Names + Properties[i].Name;
+ END_REPEAT;
+
+ RETURN (SIZEOF(Names) = SIZEOF(Properties));
+END_FUNCTION;
+
+FUNCTION IfcUniquePropertySetNames
+(Properties : SET [1:?] OF IfcPropertySetDefinition)
+:LOGICAL;
+
+LOCAL
+  Names : SET OF IfcLabel := [];
+  Unnamed : INTEGER := 0;
+END_LOCAL;
+
+REPEAT i:=1 TO HIINDEX(Properties);
+  IF 'IFC4.IFCPROPERTYSET' IN TYPEOF(Properties[i]) THEN
+    Names := Names + Properties[i]\IfcRoot.Name;
+  ELSE
+    Unnamed := Unnamed + 1;
+  END_IF;
+END_REPEAT;
+
+RETURN (SIZEOF(Names) + Unnamed = SIZEOF(Properties));
+END_FUNCTION;
+
+FUNCTION IfcUniquePropertyTemplateNames
+(Properties : SET [1:?] OF IfcPropertyTemplate)
+:LOGICAL;
+
+LOCAL
+  Names : SET OF IfcLabel := [];
+END_LOCAL;
+
+REPEAT i:=1 TO HIINDEX(Properties);
+  Names := Names + Properties[i].Name;
+END_REPEAT;
+RETURN (SIZEOF(Names) = SIZEOF(Properties));
+END_FUNCTION;
+
+FUNCTION IfcUniqueQuantityNames
+(Properties : SET [1:?] OF IfcPhysicalQuantity)
+:LOGICAL;
+
+LOCAL
+  Names : SET OF IfcLabel := [];
+END_LOCAL;
+
+REPEAT i:=1 TO HIINDEX(Properties);
+  Names := Names + Properties[i].Name;
+END_REPEAT;
+RETURN (SIZEOF(Names) = SIZEOF(Properties));
+END_FUNCTION;
+
+FUNCTION IfcVectorDifference
+(Arg1, Arg2 : IfcVectorOrDirection)
+    : IfcVector;
+LOCAL
+  Result : IfcVector;
+  Res, Vec1, Vec2 : IfcDirection;
+  Mag, Mag1, Mag2 : REAL;
+  Ndim : INTEGER;
+END_LOCAL;
+
+  IF ((NOT EXISTS (Arg1)) OR (NOT EXISTS (Arg2))) OR (Arg1.Dim <> Arg2.Dim) THEN
+    RETURN (?) ;
+  ELSE
+    BEGIN
+      IF 'IFC4.IFCVECTOR' IN TYPEOF(Arg1) THEN
+        Mag1 := Arg1\IfcVector.Magnitude;
+        Vec1 := Arg1\IfcVector.Orientation;
+      ELSE
+        Mag1 := 1.0;
+        Vec1 := Arg1;
+      END_IF;
+      IF 'IFC4.IFCVECTOR' IN TYPEOF(Arg2) THEN
+        Mag2 := Arg2\IfcVector.Magnitude;
+        Vec2 := Arg2\IfcVector.Orientation;
+      ELSE
+        Mag2 := 1.0;
+        Vec2 := Arg2;
+      END_IF;
+      Vec1 := IfcNormalise (Vec1);
+      Vec2 := IfcNormalise (Vec2);
+      Ndim := SIZEOF(Vec1.DirectionRatios);
+      Mag  := 0.0;
+      Res  := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0:Ndim]);
+
+      REPEAT i := 1 TO Ndim;
+        Res.DirectionRatios[i] := Mag1*Vec1.DirectionRatios[i] - Mag2*Vec2.DirectionRatios[i];
+        Mag := Mag + (Res.DirectionRatios[i]*Res.DirectionRatios[i]);
+      END_REPEAT;
+
+      IF (Mag > 0.0 ) THEN
+        Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector( Res, SQRT(Mag));
+      ELSE
+        Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector( Vec1, 0.0);
+      END_IF;
+    END;
+  END_IF;
+  RETURN (Result);
+END_FUNCTION;
+
+FUNCTION IfcVectorSum
+(Arg1, Arg2 : IfcVectorOrDirection) 
+    : IfcVector;
+LOCAL
+  Result : IfcVector;
+  Res, Vec1, Vec2 : IfcDirection;
+  Mag, Mag1, Mag2 : REAL;
+  Ndim : INTEGER;
+END_LOCAL;
+
+  IF ((NOT EXISTS (Arg1)) OR (NOT EXISTS (Arg2))) OR (Arg1.Dim <> Arg2.Dim) THEN
+    RETURN (?) ;
+  ELSE
+    BEGIN
+      IF 'IFC4.IFCVECTOR' IN TYPEOF(Arg1) THEN
+        Mag1 := Arg1\IfcVector.Magnitude;
+        Vec1 := Arg1\IfcVector.Orientation;
+      ELSE
+        Mag1 := 1.0;
+        Vec1 := Arg1;
+      END_IF;
+      IF 'IFC4.IFCVECTOR' IN TYPEOF(Arg2) THEN
+        Mag2 := Arg2\IfcVector.Magnitude;
+        Vec2 := Arg2\IfcVector.Orientation;
+      ELSE
+        Mag2 := 1.0;
+        Vec2 := Arg2;
+      END_IF;
+      Vec1 := IfcNormalise (Vec1);
+      Vec2 := IfcNormalise (Vec2);
+      Ndim := SIZEOF(Vec1.DirectionRatios);
+      Mag  := 0.0;
+      Res  := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcDirection([0.0:Ndim]);
+
+      REPEAT i := 1 TO Ndim;
+        Res.DirectionRatios[i] := Mag1*Vec1.DirectionRatios[i] + Mag2*Vec2.DirectionRatios[i];
+        Mag := Mag + (Res.DirectionRatios[i]*Res.DirectionRatios[i]);
+      END_REPEAT;
+
+      IF (Mag > 0.0 ) THEN
+        Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector( Res, SQRT(Mag));
+      ELSE
+        Result := IfcRepresentationItem() || IfcGeometricRepresentationItem () || IfcVector( Vec1, 0.0);
+      END_IF;
+    END;
+  END_IF;
+  RETURN (Result);
+END_FUNCTION;
+
+RULE IfcRepresentationContextSameWCS FOR
+	(IfcGeometricRepresentationContext);
+LOCAL
+  IsDifferent  : LOGICAL := FALSE;
+END_LOCAL;
+  IF (SIZEOF(IfcGeometricRepresentationContext) > 1)
+  THEN
+    REPEAT i := 2 TO HIINDEX(IfcGeometricRepresentationContext);
+      IF (IfcGeometricRepresentationContext[1].WorldCoordinateSystem :<>: IfcGeometricRepresentationContext[i].WorldCoordinateSystem)
+      THEN
+        IsDifferent := (NOT(IfcSameValidPrecision(IfcGeometricRepresentationContext[1].Precision,
+                                                  IfcGeometricRepresentationContext[i].Precision)))
+                    OR (NOT(IfcSameAxis2Placement(IfcGeometricRepresentationContext[1].WorldCoordinateSystem,
+                                                  IfcGeometricRepresentationContext[i].WorldCoordinateSystem,
+                                                  IfcGeometricRepresentationContext[1].Precision)));
+        IF (IsDifferent = TRUE) THEN
+          ESCAPE;
+        END_IF;
+      END_IF;
+    END_REPEAT;
+  END_IF;
+    WHERE
+      WR1 : IsDifferent = FALSE;
+END_RULE;
+
+RULE IfcSingleProjectInstance FOR
+	(IfcProject);
+
+    WHERE
+      WR1 : SIZEOF(IfcProject) <= 1;
+END_RULE;
+
+END_SCHEMA;