add assimp submodule

15 files changed, 27964 insertions, 0 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCBoolean.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCBoolean.cpp
new file mode 100644
index 0000000..36912a7
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCBoolean.cpp
@@ -0,0 +1,765 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCBoolean.cpp
+ *  @brief Implements a subset of Ifc boolean operations
+ */
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "AssetLib/IFC/IFCUtil.h"
+#include "Common/PolyTools.h"
+#include "PostProcessing/ProcessHelper.h"
+
+
+#include <iterator>
+#include <tuple>
+
+namespace Assimp {
+namespace IFC {
+
+// ------------------------------------------------------------------------------------------------
+// Calculates intersection between line segment and plane. To catch corner cases, specify which side you prefer.
+// 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 pdelta = e0 - p, seg = e1 - e0;
+    const IfcFloat dotOne = n * seg, dotTwo = -(n * pdelta);
+
+    // if segment ends on plane, do not report a hit. We stay on that side until a following segment starting at this
+    // point leaves the plane through the other side
+    if (std::abs(dotOne + dotTwo) < ai_epsilon)
+        return false;
+
+    // if segment starts on the plane, report a hit only if the end lies on the *other* side
+    if (std::abs(dotTwo) < ai_epsilon) {
+        if ((assumeStartOnWhiteSide && dotOne + dotTwo < ai_epsilon) || (!assumeStartOnWhiteSide && dotOne + dotTwo > -ai_epsilon)) {
+            out = e0;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    // ignore if segment is parallel to plane and far away from it on either side
+    // Warning: if there's a few thousand of such segments which slowly accumulate beyond the epsilon, no hit would be registered
+    if (std::abs(dotOne) < ai_epsilon)
+        return false;
+
+    // t must be in [0..1] if the intersection point is within the given segment
+    const IfcFloat t = dotTwo / dotOne;
+    if (t > 1.0 || t < 0.0)
+        return false;
+
+    out = e0 + t * seg;
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+void FilterPolygon(std::vector<IfcVector3> &resultpoly) {
+    if (resultpoly.size() < 3) {
+        resultpoly.clear();
+        return;
+    }
+
+    IfcVector3 vmin, vmax;
+    ArrayBounds(resultpoly.data(), static_cast<unsigned int>(resultpoly.size()), vmin, vmax);
+
+    // filter our IfcFloat points - those may happen if a point lies
+    // directly on the intersection line or directly on the clipping plane
+    const IfcFloat epsilon = (vmax - vmin).SquareLength() / 1e6f;
+    FuzzyVectorCompare fz(epsilon);
+    std::vector<IfcVector3>::iterator e = std::unique(resultpoly.begin(), resultpoly.end(), fz);
+
+    if (e != resultpoly.end())
+        resultpoly.erase(e, resultpoly.end());
+
+    if (!resultpoly.empty() && fz(resultpoly.front(), resultpoly.back()))
+        resultpoly.pop_back();
+}
+
+// ------------------------------------------------------------------------------------------------
+void WritePolygon(std::vector<IfcVector3> &resultpoly, TempMesh &result) {
+    FilterPolygon(resultpoly);
+
+    if (resultpoly.size() > 2) {
+        result.mVerts.insert(result.mVerts.end(), resultpoly.begin(), resultpoly.end());
+        result.mVertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid *hs, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData & /*conv*/) {
+    ai_assert(hs != nullptr);
+
+    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;
+    }
+
+    // extract plane base position vector and normal vector
+    IfcVector3 p, n(0.f, 0.f, 1.f);
+    if (plane->Position->Axis) {
+        ConvertDirection(n, plane->Position->Axis.Get());
+    }
+    ConvertCartesianPoint(p, plane->Position->Location);
+
+    if (!IsTrue(hs->AgreementFlag)) {
+        n *= -1.f;
+    }
+
+    // clip the current contents of `meshout` against the plane we obtained from the second operand
+    const std::vector<IfcVector3> &in = first_operand.mVerts;
+    std::vector<IfcVector3> &outvert = result.mVerts;
+
+    std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin(),
+                                              end = first_operand.mVertcnt.end(), iit;
+
+    outvert.reserve(in.size());
+    result.mVertcnt.reserve(first_operand.mVertcnt.size());
+
+    unsigned int vidx = 0;
+    for (iit = begin; iit != end; vidx += *iit++) {
+
+        unsigned int newcount = 0;
+        bool isAtWhiteSide = (in[vidx] - p) * n > -ai_epsilon;
+        for (unsigned int i = 0; i < *iit; ++i) {
+            const IfcVector3 &e0 = in[vidx + i], e1 = in[vidx + (i + 1) % *iit];
+
+            // does the next segment intersect the plane?
+            IfcVector3 isectpos;
+            if (IntersectSegmentPlane(p, n, e0, e1, isAtWhiteSide, isectpos)) {
+                if (isAtWhiteSide) {
+                    // e0 is on the right side, so keep it
+                    outvert.push_back(e0);
+                    outvert.push_back(isectpos);
+                    newcount += 2;
+                } else {
+                    // e0 is on the wrong side, so drop it and keep e1 instead
+                    outvert.push_back(isectpos);
+                    ++newcount;
+                }
+                isAtWhiteSide = !isAtWhiteSide;
+            } else {
+                if (isAtWhiteSide) {
+                    outvert.push_back(e0);
+                    ++newcount;
+                }
+            }
+        }
+
+        if (!newcount) {
+            continue;
+        }
+
+        IfcVector3 vmin, vmax;
+        ArrayBounds(&*(outvert.end() - newcount), newcount, vmin, vmax);
+
+        // filter our IfcFloat points - those may happen if a point lies
+        // directly on the intersection line. However, due to IfcFloat
+        // precision a bitwise comparison is not feasible to detect
+        // this case.
+        const IfcFloat epsilon = (vmax - vmin).SquareLength() / 1e6f;
+        FuzzyVectorCompare fz(epsilon);
+
+        std::vector<IfcVector3>::iterator e = std::unique(outvert.end() - newcount, outvert.end(), fz);
+
+        if (e != outvert.end()) {
+            newcount -= static_cast<unsigned int>(std::distance(e, outvert.end()));
+            outvert.erase(e, outvert.end());
+        }
+        if (fz(*(outvert.end() - newcount), outvert.back())) {
+            outvert.pop_back();
+            --newcount;
+        }
+        if (newcount > 2) {
+            result.mVertcnt.push_back(newcount);
+        } else
+            while (newcount-- > 0) {
+                result.mVerts.pop_back();
+            }
+    }
+    IFCImporter::LogVerboseDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)");
+}
+
+// ------------------------------------------------------------------------------------------------
+// Check if e0-e1 intersects a sub-segment of the given boundary line.
+// note: this functions works on 3D vectors, but performs its intersection checks solely in xy.
+// New version takes the supposed inside/outside state as a parameter and treats corner cases as if
+// the line stays on that side. This should make corner cases more stable.
+// Two million assumptions! Boundary should have all z at 0.0, will be treated as closed, should not have
+// segments with length <1e-6, self-intersecting might break the corner case handling... just don't go there, ok?
+bool IntersectsBoundaryProfile(const IfcVector3 &e0, const IfcVector3 &e1, const std::vector<IfcVector3> &boundary,
+        const bool isStartAssumedInside, std::vector<std::pair<size_t, IfcVector3>> &intersect_results,
+        const bool halfOpen = false) {
+    ai_assert(intersect_results.empty());
+
+    // determine winding order - necessary to detect segments going "inwards" or "outwards" from a point directly on the border
+    // positive sum of angles means clockwise order when looking down the -Z axis
+    IfcFloat windingOrder = 0.0;
+    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
+        IfcVector3 b01 = boundary[(i + 1) % bcount] - boundary[i];
+        IfcVector3 b12 = boundary[(i + 2) % bcount] - boundary[(i + 1) % bcount];
+        IfcVector3 b1_side = IfcVector3(b01.y, -b01.x, 0.0); // rotated 90° clockwise in Z plane
+        // Warning: rough estimate only. A concave poly with lots of small segments each featuring a small counter rotation
+        // could fool the accumulation. Correct implementation would be sum( acos( b01 * b2) * sign( b12 * b1_side))
+        windingOrder += (b1_side.x * b12.x + b1_side.y * b12.y);
+    }
+    windingOrder = windingOrder > 0.0 ? 1.0 : -1.0;
+
+    const IfcVector3 e = e1 - e0;
+
+    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
+        // boundary segment i: b0-b1
+        const IfcVector3 &b0 = boundary[i];
+        const IfcVector3 &b1 = boundary[(i + 1) % bcount];
+        IfcVector3 b = b1 - b0;
+
+        // segment-segment intersection
+        // solve b0 + b*s = e0 + e*t for (s,t)
+        const IfcFloat det = (-b.x * e.y + e.x * b.y);
+        if (std::abs(det) < ai_epsilon) {
+            // no solutions (parallel lines)
+            continue;
+        }
+        IfcFloat b_sqlen_inv = 1.0 / b.SquareLength();
+
+        const IfcFloat x = b0.x - e0.x;
+        const IfcFloat y = b0.y - e0.y;
+        const IfcFloat s = (x * e.y - e.x * y) / det; // scale along boundary edge
+        const IfcFloat t = (x * b.y - b.x * y) / det; // scale along given segment
+        const IfcVector3 p = e0 + e * t;
+#ifdef ASSIMP_BUILD_DEBUG
+        const IfcVector3 check = b0 + b * s - p;
+        ai_assert((IfcVector2(check.x, check.y)).SquareLength() < 1e-5);
+#endif
+
+        // also calculate the distance of e0 and e1 to the segment. We need to detect the "starts directly on segment"
+        // and "ends directly at segment" cases
+        bool startsAtSegment, endsAtSegment;
+        {
+            // calculate closest point to each end on the segment, clamp that point to the segment's length, then check
+            // distance to that point. This approach is like testing if e0 is inside a capped cylinder.
+            IfcFloat et0 = (b.x * (e0.x - b0.x) + b.y * (e0.y - b0.y)) * b_sqlen_inv;
+            IfcVector3 closestPosToE0OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et0)) * b;
+            startsAtSegment = (closestPosToE0OnBoundary - IfcVector3(e0.x, e0.y, 0.0)).SquareLength() < 1e-12;
+            IfcFloat et1 = (b.x * (e1.x - b0.x) + b.y * (e1.y - b0.y)) * b_sqlen_inv;
+            IfcVector3 closestPosToE1OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et1)) * b;
+            endsAtSegment = (closestPosToE1OnBoundary - IfcVector3(e1.x, e1.y, 0.0)).SquareLength() < 1e-12;
+        }
+
+        // Line segment ends at boundary -> ignore any hit, it will be handled by possibly following segments
+        if (endsAtSegment && !halfOpen)
+            continue;
+
+        // Line segment starts at boundary -> generate a hit only if following that line would change the INSIDE/OUTSIDE
+        // state. This should catch the case where a connected set of segments has a point directly on the boundary,
+        // one segment not hitting it because it ends there and the next segment not hitting it because it starts there
+        // Should NOT generate a hit if the segment only touches the boundary but turns around and stays inside.
+        if (startsAtSegment) {
+            IfcVector3 inside_dir = IfcVector3(b.y, -b.x, 0.0) * windingOrder;
+            bool isGoingInside = (inside_dir * e) > 0.0;
+            if (isGoingInside == isStartAssumedInside)
+                continue;
+
+            // only insert the point into the list if it is sufficiently far away from the previous intersection point.
+            // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
+            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
+                const IfcVector3 diff = intersect_results.back().second - e0;
+                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
+                    continue;
+            }
+            intersect_results.push_back(std::make_pair(i, e0));
+            continue;
+        }
+
+        // for a valid intersection, s and t should be in range [0,1]. Including a bit of epsilon on s, potential double
+        // hits on two consecutive boundary segments are filtered
+        if (s >= -ai_epsilon * b_sqlen_inv && s <= 1.0 + ai_epsilon * b_sqlen_inv && t >= 0.0 && (t <= 1.0 || halfOpen)) {
+            // only insert the point into the list if it is sufficiently far away from the previous intersection point.
+            // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
+            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
+                const IfcVector3 diff = intersect_results.back().second - p;
+                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
+                    continue;
+            }
+            intersect_results.push_back(std::make_pair(i, p));
+        }
+    }
+
+    return !intersect_results.empty();
+}
+
+// ------------------------------------------------------------------------------------------------
+// note: this functions works on 3D vectors, but performs its intersection checks solely in xy.
+bool PointInPoly(const IfcVector3 &p, const std::vector<IfcVector3> &boundary) {
+    // even-odd algorithm: take a random vector that extends from p to infinite
+    // and counts how many times it intersects edges of the boundary.
+    // because checking for segment intersections is prone to numeric inaccuracies
+    // or double detections (i.e. when hitting multiple adjacent segments at their
+    // shared vertices) we do it thrice with different rays and vote on it.
+
+    // the even-odd algorithm doesn't work for points which lie directly on
+    // the border of the polygon. If any of our attempts produces this result,
+    // we return false immediately.
+
+    std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
+    size_t votes = 0;
+
+    IntersectsBoundaryProfile(p, p + IfcVector3(1.0, 0, 0), boundary, true, intersected_boundary, true);
+    votes += intersected_boundary.size() % 2;
+
+    intersected_boundary.clear();
+    IntersectsBoundaryProfile(p, p + IfcVector3(0, 1.0, 0), boundary, true, intersected_boundary, true);
+    votes += intersected_boundary.size() % 2;
+
+    intersected_boundary.clear();
+    IntersectsBoundaryProfile(p, p + IfcVector3(0.6, -0.6, 0.0), boundary, true, intersected_boundary, true);
+    votes += intersected_boundary.size() % 2;
+
+    return votes > 1;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace *hs, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData &conv) {
+    ai_assert(hs != nullptr);
+
+    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;
+    }
+
+    // extract plane base position vector and normal vector
+    IfcVector3 p, n(0.f, 0.f, 1.f);
+    if (plane->Position->Axis) {
+        ConvertDirection(n, plane->Position->Axis.Get());
+    }
+    ConvertCartesianPoint(p, plane->Position->Location);
+
+    if (!IsTrue(hs->AgreementFlag)) {
+        n *= -1.f;
+    }
+
+    n.Normalize();
+
+    // obtain the polygonal bounding volume
+    std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
+    if (!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
+        IFCImporter::LogError("expected valid polyline for boundary of boolean halfspace");
+        return;
+    }
+
+    // determine winding order by calculating the normal.
+    IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(profile->mVerts.data(), profile->mVerts.size());
+
+    IfcMatrix4 proj_inv;
+    ConvertAxisPlacement(proj_inv, hs->Position);
+
+    // and map everything into a plane coordinate space so all intersection
+    // tests can be done in 2D space.
+    IfcMatrix4 proj = proj_inv;
+    proj.Inverse();
+
+    // clip the current contents of `meshout` against the plane we obtained from the second operand
+    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.mVertcnt.size());
+
+    unsigned int vidx = 0;
+    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++) {
+        // Our new approach: we cut the poly along the plane, then we intersect the part on the black side of the plane
+        // against the bounding polygon. All the white parts, and the black part outside the boundary polygon, are kept.
+        std::vector<IfcVector3> whiteside, blackside;
+
+        {
+            const IfcVector3 *srcVertices = &in[vidx];
+            const size_t srcVtxCount = *iit;
+            if (srcVtxCount == 0)
+                continue;
+
+            IfcVector3 polyNormal = TempMesh::ComputePolygonNormal(srcVertices, srcVtxCount, true);
+
+            // if the poly is parallel to the plane, put it completely on the black or white side
+            if (std::abs(polyNormal * n) > 0.9999) {
+                bool isOnWhiteSide = (srcVertices[0] - p) * n > -ai_epsilon;
+                std::vector<IfcVector3> &targetSide = isOnWhiteSide ? whiteside : blackside;
+                targetSide.insert(targetSide.end(), srcVertices, srcVertices + srcVtxCount);
+            } else {
+                // otherwise start building one polygon for each side. Whenever the current line segment intersects the plane
+                // we put a point there as an end of the current segment. Then we switch to the other side, put a point there, too,
+                // as a beginning of the current segment, and simply continue accumulating vertices.
+                bool isCurrentlyOnWhiteSide = ((srcVertices[0]) - p) * n > -ai_epsilon;
+                for (size_t a = 0; a < srcVtxCount; ++a) {
+                    IfcVector3 e0 = srcVertices[a];
+                    IfcVector3 e1 = srcVertices[(a + 1) % srcVtxCount];
+                    IfcVector3 ei;
+
+                    // put starting point to the current mesh
+                    std::vector<IfcVector3> &trgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
+                    trgt.push_back(srcVertices[a]);
+
+                    // if there's an intersection, put an end vertex there, switch to the other side's mesh,
+                    // and add a starting vertex there, too
+                    bool isPlaneHit = IntersectSegmentPlane(p, n, e0, e1, isCurrentlyOnWhiteSide, ei);
+                    if (isPlaneHit) {
+                        if (trgt.empty() || (trgt.back() - ei).SquareLength() > 1e-12)
+                            trgt.push_back(ei);
+                        isCurrentlyOnWhiteSide = !isCurrentlyOnWhiteSide;
+                        std::vector<IfcVector3> &newtrgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
+                        newtrgt.push_back(ei);
+                    }
+                }
+            }
+        }
+
+        // the part on the white side can be written into the target mesh right away
+        WritePolygon(whiteside, result);
+
+        // The black part is the piece we need to get rid of, but only the part of it within the boundary polygon.
+        // So we now need to construct all the polygons that result from BlackSidePoly minus BoundaryPoly.
+        FilterPolygon(blackside);
+
+        // Complicated, II. We run along the polygon. a) When we're inside the boundary, we run on until we hit an
+        // intersection, which means we're leaving it. We then start a new out poly there. b) When we're outside the
+        // boundary, we start collecting vertices until we hit an intersection, then we run along the boundary until we hit
+        // an intersection, then we switch back to the poly and run on on this one again, and so on until we got a closed
+        // loop. Then we continue with the path we left to catch potential additional polys on the other side of the
+        // boundary as described in a)
+        if (!blackside.empty()) {
+            // 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->mVerts);
+            bool isCurrentlyInside = startedInside;
+
+            std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
+
+            for (size_t a = 0; a < blackside.size(); ++a) {
+                const IfcVector3 e0 = proj * blackside[a];
+                const IfcVector3 e1 = proj * blackside[(a + 1) % blackside.size()];
+
+                intersected_boundary.clear();
+                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) {
+                    bool keepSorting = true;
+                    while (keepSorting) {
+                        keepSorting = false;
+                        for (size_t b = 0; b < intersected_boundary.size() - 1; ++b) {
+                            if ((intersected_boundary[b + 1].second - e0).SquareLength() < (intersected_boundary[b].second - e0).SquareLength()) {
+                                keepSorting = true;
+                                std::swap(intersected_boundary[b + 1], intersected_boundary[b]);
+                            }
+                        }
+                    }
+                }
+                // now add them to the list of intersections
+                for (size_t b = 0; b < intersected_boundary.size(); ++b)
+                    intersections.push_back(std::make_tuple(a, proj_inv * intersected_boundary[b].second, intersected_boundary[b].first));
+
+                // and calculate our new inside/outside state
+                if (intersected_boundary.size() & 1)
+                    isCurrentlyInside = !isCurrentlyInside;
+            }
+
+            // we got a list of in-out-combinations of intersections. That should be an even number of intersections, or
+            // we are facing a non-recoverable error.
+            if ((intersections.size() & 1) != 0) {
+                IFCImporter::LogWarn("Odd number of intersections, can't work with that. Omitting half space boundary check.");
+                continue;
+            }
+
+            if (intersections.size() > 1) {
+                // If we started outside, the first intersection is a out->in intersection. Cycle them so that it
+                // starts with an intersection leaving the boundary
+                if (!startedInside)
+                    for (size_t b = 0; b < intersections.size() - 1; ++b)
+                        std::swap(intersections[b], intersections[(b + intersections.size() - 1) % intersections.size()]);
+
+                // Filter pairs of out->in->out that lie too close to each other.
+                for (size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/) {
+                    if ((std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10)
+                        intersections.erase(intersections.begin() + a, intersections.begin() + a + 2);
+                    else
+                        a++;
+                }
+                if (intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10) {
+                    intersections.pop_back();
+                    intersections.erase(intersections.begin());
+                }
+            }
+
+            // no intersections at all: either completely inside the boundary, so everything gets discarded, or completely outside.
+            // in the latter case we're implementional lost. I'm simply going to ignore this, so a large poly will not get any
+            // holes if the boundary is smaller and does not touch it anywhere.
+            if (intersections.empty()) {
+                // starting point was outside -> everything is outside the boundary -> nothing is clipped -> add black side
+                // to result mesh unchanged
+                if (!startedInside) {
+                    outvertcnt.push_back(static_cast<unsigned int>(blackside.size()));
+                    outvert.insert(outvert.end(), blackside.begin(), blackside.end());
+                    continue;
+                } else {
+                    // starting point was inside the boundary -> everything is inside the boundary -> nothing is spared from the
+                    // clipping -> nothing left to add to the result mesh
+                    continue;
+                }
+            }
+
+            // determine the direction in which we're marching along the boundary polygon. If the src poly is faced upwards
+            // and the boundary is also winded this way, we need to march *backwards* on the boundary.
+            const IfcVector3 polyNormal = IfcMatrix3(proj) * TempMesh::ComputePolygonNormal(blackside.data(), blackside.size());
+            bool marchBackwardsOnBoundary = (profileNormal * polyNormal) >= 0.0;
+
+            // Build closed loops from these intersections. Starting from an intersection leaving the boundary we
+            // walk along the polygon to the next intersection (which should be an IS entering the boundary poly).
+            // From there we walk along the boundary until we hit another intersection leaving the boundary,
+            // walk along the poly to the next IS and so on until we're back at the starting point.
+            // We remove every intersection we "used up", so any remaining intersection is the start of a new loop.
+            while (!intersections.empty()) {
+                std::vector<IfcVector3> resultpoly;
+                size_t currentIntersecIdx = 0;
+
+                while (true) {
+                    ai_assert(intersections.size() > currentIntersecIdx + 1);
+                    std::tuple<size_t, IfcVector3, size_t> currintsec = intersections[currentIntersecIdx + 0];
+                    std::tuple<size_t, IfcVector3, size_t> nextintsec = intersections[currentIntersecIdx + 1];
+                    intersections.erase(intersections.begin() + currentIntersecIdx, intersections.begin() + currentIntersecIdx + 2);
+
+                    // we start with an in->out intersection
+                    resultpoly.push_back(std::get<1>(currintsec));
+                    // climb along the polygon to the next intersection, which should be an out->in
+                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0) + std::get<0>(nextintsec) - std::get<0>(currintsec);
+                    for (size_t a = 1; a <= numPolyPoints; ++a)
+                        resultpoly.push_back(blackside[(std::get<0>(currintsec) + a) % blackside.size()]);
+                    // put the out->in intersection
+                    resultpoly.push_back(std::get<1>(nextintsec));
+
+                    // 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->mVerts.size();
+                    size_t nextIntsecIdx = SIZE_MAX;
+                    while (nextIntsecIdx == SIZE_MAX) {
+                        IfcFloat t = 1e10;
+
+                        size_t nextBoundaryEdgeIdx = marchBackwardsOnBoundary ? (currentBoundaryEdgeIdx + profile->mVerts.size() - 1) : currentBoundaryEdgeIdx + 1;
+                        nextBoundaryEdgeIdx %= profile->mVerts.size();
+                        // vertices of the current boundary segments
+                        IfcVector3 currBoundaryPoint = profile->mVerts[currentBoundaryEdgeIdx];
+                        IfcVector3 nextBoundaryPoint = profile->mVerts[nextBoundaryEdgeIdx];
+                        // project the two onto the polygon
+                        if (std::abs(polyNormal.z) > 1e-5) {
+                            currBoundaryPoint.z = startingPoint.z + (currBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (currBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
+                            nextBoundaryPoint.z = startingPoint.z + (nextBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (nextBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
+                        }
+
+                        // build a direction that goes along the boundary border but lies in the poly plane
+                        IfcVector3 boundaryPlaneNormal = ((nextBoundaryPoint - currBoundaryPoint) ^ profileNormal).Normalize();
+                        IfcVector3 dirAtPolyPlane = (boundaryPlaneNormal ^ polyNormal).Normalize() * (marchBackwardsOnBoundary ? -1.0 : 1.0);
+                        // if we can project the direction to the plane, we can calculate a maximum marching distance along that dir
+                        // until we finish that boundary segment and continue on the next
+                        if (std::abs(polyNormal.z) > 1e-5) {
+                            t = std::min(t, (nextBoundaryPoint - startingPoint).Length());
+                        }
+
+                        // check if the direction hits the loop start - if yes, we got a poly to output
+                        IfcVector3 dirToThatPoint = proj * resultpoly.front() - startingPoint;
+                        IfcFloat tpt = dirToThatPoint * dirAtPolyPlane;
+                        if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
+                            nextIntsecIdx = intersections.size(); // dirty hack to end marching along the boundary and signal the end of the loop
+                            t = tpt;
+                        }
+
+                        // also check if the direction hits any in->out intersections earlier. If we hit one, we can switch back
+                        // to marching along the poly border from that intersection point
+                        for (size_t a = 0; a < intersections.size(); a += 2) {
+                            dirToThatPoint = proj * std::get<1>(intersections[a]) - startingPoint;
+                            tpt = dirToThatPoint * dirAtPolyPlane;
+                            if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
+                                nextIntsecIdx = a; // switch back to poly and march on from this in->out intersection
+                                t = tpt;
+                            }
+                        }
+
+                        // if we keep marching on the boundary, put the segment end point to the result poly and well... keep marching
+                        if (nextIntsecIdx == SIZE_MAX) {
+                            resultpoly.push_back(proj_inv * nextBoundaryPoint);
+                            currentBoundaryEdgeIdx = nextBoundaryEdgeIdx;
+                            startingPoint = nextBoundaryPoint;
+                        }
+
+                        // quick endless loop check
+                        if (resultpoly.size() > blackside.size() + profile->mVerts.size()) {
+                            IFCImporter::LogError("Encountered endless loop while clipping polygon against poly-bounded half space.");
+                            break;
+                        }
+                    }
+
+                    // we're back on the poly - if this is the intersection we started from, we got a closed loop.
+                    if (nextIntsecIdx >= intersections.size()) {
+                        break;
+                    }
+
+                    // otherwise it's another intersection. Continue marching from there.
+                    currentIntersecIdx = nextIntsecIdx;
+                }
+
+                WritePolygon(resultpoly, result);
+            }
+        }
+    }
+    IFCImporter::LogVerboseDebug("generating CSG geometry by plane clipping with polygonal bounding (IfcBooleanClippingResult)");
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid *as, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData &conv) {
+    ai_assert(as != nullptr);
+
+    // This case is handled by reduction to an instance of the quadrify() algorithm.
+    // Obviously, this won't work for arbitrarily complex cases. In fact, the first
+    // operand should be near-planar. Luckily, this is usually the case in Ifc
+    // buildings.
+
+    std::shared_ptr<TempMesh> meshtmp = std::shared_ptr<TempMesh>(new TempMesh());
+    ProcessExtrudedAreaSolid(*as, *meshtmp, conv, false);
+
+    std::vector<TempOpening> openings(1, TempOpening(as, IfcVector3(0, 0, 0), meshtmp, std::shared_ptr<TempMesh>()));
+
+    result = first_operand;
+
+    TempMesh temp;
+
+    std::vector<IfcVector3>::const_iterator vit = first_operand.mVerts.begin();
+    for (unsigned int pcount : first_operand.mVertcnt) {
+        temp.Clear();
+
+        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
+        // filtered to avoid running into assertions later on.
+
+        // ComputePolygonNormal returns the Newell normal, so the
+        // length of the normal is the area of the polygon.
+        const IfcVector3 &normal = temp.ComputeLastPolygonNormal(false);
+        if (normal.SquareLength() < static_cast<IfcFloat>(1e-5)) {
+            IFCImporter::LogWarn("skipping degenerate polygon (ProcessBooleanExtrudedAreaSolidDifference)");
+            continue;
+        }
+
+        GenerateOpenings(openings, temp, false, true);
+        result.Append(temp);
+
+        vit += pcount;
+    }
+
+    IFCImporter::LogVerboseDebug("generating CSG geometry by geometric difference to a solid (IfcExtrudedAreaSolid)");
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessBoolean(const Schema_2x3::IfcBooleanResult &boolean, TempMesh &result, ConversionData &conv) {
+    // supported CSG operations:
+    //   DIFFERENCE
+    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;
+        }
+
+        // supported cases (1st operand):
+        //  IfcBooleanResult -- call ProcessBoolean recursively
+        //  IfcSweptAreaSolid -- obtain polygonal geometry first
+
+        // supported cases (2nd operand):
+        //  IfcHalfSpaceSolid -- easy, clip against plane
+        //  IfcExtrudedAreaSolid -- reduce to an instance of the quadrify() algorithm
+
+        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 Schema_2x3::IfcBooleanResult *const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
+            ProcessBoolean(*op0, first_operand, conv);
+        } else if (const Schema_2x3::IfcSweptAreaSolid *const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
+            ProcessSweptAreaSolid(*swept, first_operand, conv);
+        } else {
+            IFCImporter::LogError("expected IfcSweptAreaSolid or IfcBooleanResult as first clipping operand");
+            return;
+        }
+
+        if (hs) {
+
+            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);
+            } else {
+                ProcessBooleanHalfSpaceDifference(hs, result, first_operand, conv);
+            }
+        } else {
+            ProcessBooleanExtrudedAreaSolidDifference(as, result, first_operand, conv);
+        }
+    } else {
+        IFCImporter::LogWarn("skipping unknown IfcBooleanResult entity, type is ", boolean.GetClassName());
+    }
+}
+
+} // namespace IFC
+} // namespace Assimp
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCCurve.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCCurve.cpp
new file mode 100644
index 0000000..19732ef
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCCurve.cpp
@@ -0,0 +1,618 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCProfile.cpp
+ *  @brief Read profile and curves entities from IFC files
+ */
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+#include "IFCUtil.h"
+
+namespace Assimp {
+namespace IFC {
+namespace {
+
+
+// --------------------------------------------------------------------------------
+// Conic is the base class for Circle and Ellipse
+// --------------------------------------------------------------------------------
+class Conic : public Curve {
+public:
+    // --------------------------------------------------
+    Conic(const Schema_2x3::IfcConic& entity, ConversionData& conv)
+    : Curve(entity,conv) {
+        IfcMatrix4 trafo;
+        ConvertAxisPlacement(trafo,*entity.Position,conv);
+
+        // for convenience, extract the matrix rows
+        location = IfcVector3(trafo.a4,trafo.b4,trafo.c4);
+        p[0] = IfcVector3(trafo.a1,trafo.b1,trafo.c1);
+        p[1] = IfcVector3(trafo.a2,trafo.b2,trafo.c2);
+        p[2] = IfcVector3(trafo.a3,trafo.b3,trafo.c3);
+    }
+
+    // --------------------------------------------------
+    bool IsClosed() const {
+        return true;
+    }
+
+    // --------------------------------------------------
+    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
+        ai_assert( InRange( a ) );
+        ai_assert( InRange( b ) );
+
+        a *= conv.angle_scale;
+        b *= conv.angle_scale;
+
+        a = std::fmod(a,static_cast<IfcFloat>( AI_MATH_TWO_PI ));
+        b = std::fmod(b,static_cast<IfcFloat>( AI_MATH_TWO_PI ));
+        const IfcFloat setting = static_cast<IfcFloat>( AI_MATH_PI * conv.settings.conicSamplingAngle / 180.0 );
+        return static_cast<size_t>( std::ceil(std::abs( b-a)) / setting);
+    }
+
+    // --------------------------------------------------
+    ParamRange GetParametricRange() const {
+        return std::make_pair(static_cast<IfcFloat>( 0. ), static_cast<IfcFloat>( AI_MATH_TWO_PI / conv.angle_scale ));
+    }
+
+protected:
+    IfcVector3 location, p[3];
+};
+
+// --------------------------------------------------------------------------------
+// Circle
+// --------------------------------------------------------------------------------
+class Circle : public Conic {
+public:
+    // --------------------------------------------------
+    Circle(const Schema_2x3::IfcCircle& entity, ConversionData& conv)
+        : Conic(entity,conv)
+        , entity(entity)
+    {
+    }
+
+    // --------------------------------------------------
+    IfcVector3 Eval(IfcFloat u) const {
+        u = -conv.angle_scale * u;
+        return location + static_cast<IfcFloat>(entity.Radius)*(static_cast<IfcFloat>(std::cos(u))*p[0] +
+            static_cast<IfcFloat>(std::sin(u))*p[1]);
+    }
+
+private:
+    const Schema_2x3::IfcCircle& entity;
+};
+
+// --------------------------------------------------------------------------------
+// Ellipse
+// --------------------------------------------------------------------------------
+class Ellipse : public Conic {
+public:
+    // --------------------------------------------------
+    Ellipse(const Schema_2x3::IfcEllipse& entity, ConversionData& conv)
+    : Conic(entity,conv)
+    , entity(entity) {
+        // empty
+    }
+
+    // --------------------------------------------------
+    IfcVector3 Eval(IfcFloat u) const {
+        u = -conv.angle_scale * u;
+        return location + static_cast<IfcFloat>(entity.SemiAxis1)*static_cast<IfcFloat>(std::cos(u))*p[0] +
+            static_cast<IfcFloat>(entity.SemiAxis2)*static_cast<IfcFloat>(std::sin(u))*p[1];
+    }
+
+private:
+    const Schema_2x3::IfcEllipse& entity;
+};
+
+// --------------------------------------------------------------------------------
+// Line
+// --------------------------------------------------------------------------------
+class Line : public Curve {
+public:
+    // --------------------------------------------------
+    Line(const Schema_2x3::IfcLine& entity, ConversionData& conv)
+    : Curve(entity,conv) {
+        ConvertCartesianPoint(p,entity.Pnt);
+        ConvertVector(v,entity.Dir);
+    }
+
+    // --------------------------------------------------
+    bool IsClosed() const {
+        return false;
+    }
+
+    // --------------------------------------------------
+    IfcVector3 Eval(IfcFloat u) const {
+        return p + u*v;
+    }
+
+    // --------------------------------------------------
+    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
+        ai_assert( InRange( a ) );
+        ai_assert( InRange( b ) );
+        // two points are always sufficient for a line segment
+        return a==b ? 1 : 2;
+    }
+
+
+    // --------------------------------------------------
+    void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
+        ai_assert( InRange( a ) );
+        ai_assert( InRange( b ) );
+
+        if (a == b) {
+            out.mVerts.push_back(Eval(a));
+            return;
+        }
+        out.mVerts.reserve(out.mVerts.size()+2);
+        out.mVerts.push_back(Eval(a));
+        out.mVerts.push_back(Eval(b));
+    }
+
+    // --------------------------------------------------
+    ParamRange GetParametricRange() const {
+        const IfcFloat inf = std::numeric_limits<IfcFloat>::infinity();
+
+        return std::make_pair(-inf,+inf);
+    }
+
+private:
+    IfcVector3 p,v;
+};
+
+// --------------------------------------------------------------------------------
+// CompositeCurve joins multiple smaller, bounded curves
+// --------------------------------------------------------------------------------
+class CompositeCurve : public BoundedCurve {
+    typedef std::pair< std::shared_ptr< BoundedCurve >, bool > CurveEntry;
+
+public:
+    // --------------------------------------------------
+    CompositeCurve(const Schema_2x3::IfcCompositeCurve& entity, ConversionData& conv)
+    : BoundedCurve(entity,conv)
+    , total() {
+        curves.reserve(entity.Segments.size());
+        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);
+
+            if (!bc) {
+                IFCImporter::LogError("expected segment of composite curve to be a bounded curve");
+                continue;
+            }
+
+            if ( (std::string)curveSegment.Transition != "CONTINUOUS" ) {
+                IFCImporter::LogVerboseDebug("ignoring transition code on composite curve segment, only continuous transitions are supported");
+            }
+
+            curves.push_back( CurveEntry(bc,IsTrue(curveSegment.SameSense)) );
+            total += bc->GetParametricRangeDelta();
+        }
+
+        if (curves.empty()) {
+            throw CurveError("empty composite curve");
+        }
+    }
+
+    // --------------------------------------------------
+    IfcVector3 Eval(IfcFloat u) const {
+        if (curves.empty()) {
+            return IfcVector3();
+        }
+
+        IfcFloat acc = 0;
+        for(const CurveEntry& entry : curves) {
+            const ParamRange& range = entry.first->GetParametricRange();
+            const IfcFloat delta = std::abs(range.second-range.first);
+            if (u < acc+delta) {
+                return entry.first->Eval( entry.second ? (u-acc) + range.first : range.second-(u-acc));
+            }
+
+            acc += delta;
+        }
+        // clamp to end
+        return curves.back().first->Eval(curves.back().first->GetParametricRange().second);
+    }
+
+    // --------------------------------------------------
+    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
+        ai_assert( InRange( a ) );
+        ai_assert( InRange( b ) );
+        size_t cnt = 0;
+
+        IfcFloat acc = 0;
+        for(const CurveEntry& entry : curves) {
+            const ParamRange& range = entry.first->GetParametricRange();
+            const IfcFloat delta = std::abs(range.second-range.first);
+            if (a <= acc+delta && b >= acc) {
+                const IfcFloat at =  std::max(static_cast<IfcFloat>( 0. ),a-acc), bt = std::min(delta,b-acc);
+                cnt += entry.first->EstimateSampleCount( entry.second ? at + range.first : range.second - bt, entry.second ? bt + range.first : range.second - at );
+            }
+
+            acc += delta;
+        }
+
+        return cnt;
+    }
+
+    // --------------------------------------------------
+    void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
+        ai_assert( InRange( a ) );
+        ai_assert( InRange( b ) );
+
+        const size_t cnt = EstimateSampleCount(a,b);
+        out.mVerts.reserve(out.mVerts.size() + cnt);
+
+        for(const CurveEntry& entry : curves) {
+            const size_t curCnt = out.mVerts.size();
+            entry.first->SampleDiscrete(out);
+
+            if (!entry.second && curCnt != out.mVerts.size()) {
+                std::reverse(out.mVerts.begin() + curCnt, out.mVerts.end());
+            }
+        }
+    }
+
+    // --------------------------------------------------
+    ParamRange GetParametricRange() const {
+        return std::make_pair(static_cast<IfcFloat>( 0. ),total);
+    }
+
+private:
+    std::vector< CurveEntry > curves;
+    IfcFloat total;
+};
+
+// --------------------------------------------------------------------------------
+// TrimmedCurve can be used to trim an unbounded curve to a bounded range
+// --------------------------------------------------------------------------------
+class TrimmedCurve : public BoundedCurve {
+public:
+    // --------------------------------------------------
+    TrimmedCurve(const Schema_2x3::IfcTrimmedCurve& entity, ConversionData& conv)
+        : BoundedCurve(entity,conv),
+          base(std::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv)))
+    {
+        typedef std::shared_ptr<const STEP::EXPRESS::DataType> Entry;
+
+        // for some reason, trimmed curves can either specify a parametric value
+        // or a point on the curve, or both. And they can even specify which of the
+        // two representations they prefer, even though an information invariant
+        // claims that they must be identical if both are present.
+        // oh well.
+        bool have_param = false, have_point = false;
+        IfcVector3 point;
+        for(const Entry& sel :entity.Trim1) {
+            if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
+                range.first = *r;
+                have_param = true;
+                break;
+            }
+            else if (const Schema_2x3::IfcCartesianPoint* const curR = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
+                ConvertCartesianPoint(point, *curR);
+                have_point = true;
+            }
+        }
+        if (!have_param) {
+            if (!have_point || !base->ReverseEval(point,range.first)) {
+                throw CurveError("IfcTrimmedCurve: failed to read first trim parameter, ignoring curve");
+            }
+        }
+        have_param = false, have_point = false;
+        for(const Entry& sel :entity.Trim2) {
+            if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
+                range.second = *r;
+                have_param = true;
+                break;
+            }
+            else if (const Schema_2x3::IfcCartesianPoint* const curR = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
+                ConvertCartesianPoint(point, *curR);
+                have_point = true;
+            }
+        }
+        if (!have_param) {
+            if (!have_point || !base->ReverseEval(point,range.second)) {
+                throw CurveError("IfcTrimmedCurve: failed to read second trim parameter, ignoring curve");
+            }
+        }
+
+        agree_sense = IsTrue(entity.SenseAgreement);
+        if( !agree_sense ) {
+            std::swap(range.first,range.second);
+        }
+
+        // "NOTE In case of a closed curve, it may be necessary to increment t1 or t2
+        // by the parametric length for consistency with the sense flag."
+        if (base->IsClosed()) {
+            if( range.first > range.second ) {
+                range.second += base->GetParametricRangeDelta();
+            }
+        }
+
+        maxval = range.second-range.first;
+        ai_assert(maxval >= 0);
+    }
+
+    // --------------------------------------------------
+    IfcVector3 Eval(IfcFloat p) const {
+        ai_assert(InRange(p));
+        return base->Eval( TrimParam(p) );
+    }
+
+    // --------------------------------------------------
+    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
+        ai_assert( InRange( a ) );
+        ai_assert( InRange( b ) );
+        return base->EstimateSampleCount(TrimParam(a),TrimParam(b));
+    }
+
+    // --------------------------------------------------
+    void SampleDiscrete(TempMesh& out,IfcFloat a,IfcFloat b) const {
+        ai_assert(InRange(a));
+        ai_assert(InRange(b));
+        return base->SampleDiscrete(out,TrimParam(a),TrimParam(b));
+    }
+
+    // --------------------------------------------------
+    ParamRange GetParametricRange() const {
+        return std::make_pair(static_cast<IfcFloat>( 0. ),maxval);
+    }
+
+private:
+    // --------------------------------------------------
+    IfcFloat TrimParam(IfcFloat f) const {
+        return agree_sense ? f + range.first :  range.second - f;
+    }
+
+private:
+    ParamRange range;
+    IfcFloat maxval;
+    bool agree_sense;
+
+    std::shared_ptr<const Curve> base;
+};
+
+
+// --------------------------------------------------------------------------------
+// PolyLine is a 'curve' defined by linear interpolation over a set of discrete points
+// --------------------------------------------------------------------------------
+class PolyLine : public BoundedCurve {
+public:
+    // --------------------------------------------------
+    PolyLine(const Schema_2x3::IfcPolyline& entity, ConversionData& conv)
+        : BoundedCurve(entity,conv)
+    {
+        points.reserve(entity.Points.size());
+
+        IfcVector3 t;
+        for(const Schema_2x3::IfcCartesianPoint& cp : entity.Points) {
+            ConvertCartesianPoint(t,cp);
+            points.push_back(t);
+        }
+    }
+
+    // --------------------------------------------------
+    IfcVector3 Eval(IfcFloat p) const {
+        ai_assert(InRange(p));
+
+        const size_t b = static_cast<size_t>(std::floor(p));
+        if (b == points.size()-1) {
+            return points.back();
+        }
+
+        const IfcFloat d = p-static_cast<IfcFloat>(b);
+        return points[b+1] * d + points[b] * (static_cast<IfcFloat>( 1. )-d);
+    }
+
+    // --------------------------------------------------
+    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
+        ai_assert(InRange(a));
+        ai_assert(InRange(b));
+        return static_cast<size_t>( std::ceil(b) - std::floor(a) );
+    }
+
+    // --------------------------------------------------
+    ParamRange GetParametricRange() const {
+        return std::make_pair(static_cast<IfcFloat>( 0. ),static_cast<IfcFloat>(points.size()-1));
+    }
+
+private:
+    std::vector<IfcVector3> points;
+};
+
+} // anon
+
+// ------------------------------------------------------------------------------------------------
+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 Schema_2x3::IfcTrimmedCurve* c = curve.ToPtr<Schema_2x3::IfcTrimmedCurve>()) {
+            return new TrimmedCurve(*c,conv);
+        }
+        if(const Schema_2x3::IfcCompositeCurve* c = curve.ToPtr<Schema_2x3::IfcCompositeCurve>()) {
+            return new CompositeCurve(*c,conv);
+        }
+    }
+
+    if(curve.ToPtr<Schema_2x3::IfcConic>()) {
+        if(const Schema_2x3::IfcCircle* c = curve.ToPtr<Schema_2x3::IfcCircle>()) {
+            return new Circle(*c,conv);
+        }
+        if(const Schema_2x3::IfcEllipse* c = curve.ToPtr<Schema_2x3::IfcEllipse>()) {
+            return new Ellipse(*c,conv);
+        }
+    }
+
+    if(const Schema_2x3::IfcLine* c = curve.ToPtr<Schema_2x3::IfcLine>()) {
+        return new Line(*c,conv);
+    }
+
+    // XXX OffsetCurve2D, OffsetCurve3D not currently supported
+    return nullptr;
+}
+
+#ifdef ASSIMP_BUILD_DEBUG
+// ------------------------------------------------------------------------------------------------
+bool Curve::InRange(IfcFloat u) const {
+    const ParamRange range = GetParametricRange();
+    if (IsClosed()) {
+        return true;
+    }
+    const IfcFloat epsilon = Math::getEpsilon<float>();
+    return u - range.first > -epsilon && range.second - u > -epsilon;
+}
+#endif
+
+// ------------------------------------------------------------------------------------------------
+IfcFloat Curve::GetParametricRangeDelta() const {
+    const ParamRange& range = GetParametricRange();
+    return std::abs(range.second - range.first);
+}
+
+// ------------------------------------------------------------------------------------------------
+size_t Curve::EstimateSampleCount(IfcFloat a, IfcFloat b) const {
+    (void)(a); (void)(b);
+    ai_assert( InRange( a ) );
+    ai_assert( InRange( b ) );
+
+    // arbitrary default value, deriving classes should supply better suited values
+    return 16;
+}
+
+// ------------------------------------------------------------------------------------------------
+IfcFloat RecursiveSearch(const Curve* cv, const IfcVector3& val, IfcFloat a, IfcFloat b,
+        unsigned int samples, IfcFloat threshold, unsigned int recurse = 0, unsigned int max_recurse = 15) {
+    ai_assert(samples>1);
+
+    const IfcFloat delta = (b-a)/samples, inf = std::numeric_limits<IfcFloat>::infinity();
+    IfcFloat min_point[2] = {a,b}, min_diff[2] = {inf,inf};
+    IfcFloat runner = a;
+
+    for (unsigned int i = 0; i < samples; ++i, runner += delta) {
+        const IfcFloat diff = (cv->Eval(runner)-val).SquareLength();
+        if (diff < min_diff[0]) {
+            min_diff[1] = min_diff[0];
+            min_point[1] = min_point[0];
+
+            min_diff[0] = diff;
+            min_point[0] = runner;
+        }
+        else if (diff < min_diff[1]) {
+            min_diff[1] = diff;
+            min_point[1] = runner;
+        }
+    }
+
+    ai_assert( min_diff[ 0 ] != inf );
+    ai_assert( min_diff[ 1 ] != inf );
+    if ( std::fabs(a-min_point[0]) < threshold || recurse >= max_recurse) {
+        return min_point[0];
+    }
+
+    // fix for closed curves to take their wrap-over into account
+    if (cv->IsClosed() && std::fabs(min_point[0]-min_point[1]) > cv->GetParametricRangeDelta()*0.5  ) {
+        const Curve::ParamRange& range = cv->GetParametricRange();
+        const IfcFloat wrapdiff = (cv->Eval(range.first)-val).SquareLength();
+
+        if (wrapdiff < min_diff[0]) {
+            const IfcFloat t = min_point[0];
+            min_point[0] = min_point[1] > min_point[0] ? range.first : range.second;
+             min_point[1] = t;
+        }
+    }
+
+    return RecursiveSearch(cv,val,min_point[0],min_point[1],samples,threshold,recurse+1,max_recurse);
+}
+
+// ------------------------------------------------------------------------------------------------
+bool Curve::ReverseEval(const IfcVector3& val, IfcFloat& paramOut) const
+{
+    // note: the following algorithm is not guaranteed to find the 'right' parameter value
+    // in all possible cases, but it will always return at least some value so this function
+    // will never fail in the default implementation.
+
+    // XXX derive threshold from curve topology
+    static const IfcFloat threshold = 1e-4f;
+    static const unsigned int samples = 16;
+
+    const ParamRange& range = GetParametricRange();
+    paramOut = RecursiveSearch(this,val,range.first,range.second,samples,threshold);
+
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+void Curve::SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
+    ai_assert( InRange( a ) );
+    ai_assert( InRange( b ) );
+
+    const size_t cnt = std::max(static_cast<size_t>(0),EstimateSampleCount(a,b));
+    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.mVerts.push_back(Eval(p));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+bool BoundedCurve::IsClosed() const {
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void BoundedCurve::SampleDiscrete(TempMesh& out) const {
+    const ParamRange& range = GetParametricRange();
+    ai_assert( range.first != std::numeric_limits<IfcFloat>::infinity() );
+    ai_assert( range.second != std::numeric_limits<IfcFloat>::infinity() );
+
+    return SampleDiscrete(out,range.first,range.second);
+}
+
+} // IFC
+} // Assimp
+
+#endif // ASSIMP_BUILD_NO_IFC_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCGeometry.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCGeometry.cpp
new file mode 100644
index 0000000..ef59542
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCGeometry.cpp
@@ -0,0 +1,932 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCGeometry.cpp
+ *  @brief Geometry conversion and synthesis for IFC
+ */
+
+
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+#include "IFCUtil.h"
+#include "Common/PolyTools.h"
+#include "PostProcessing/ProcessHelper.h"
+
+#ifdef ASSIMP_USE_HUNTER
+#  include <poly2tri/poly2tri.h>
+#  include <polyclipping/clipper.hpp>
+#else
+#  include "../contrib/poly2tri/poly2tri/poly2tri.h"
+#  include "../contrib/clipper/clipper.hpp"
+#endif
+
+#include <memory>
+#include <iterator>
+
+namespace Assimp {
+namespace IFC {
+
+// ------------------------------------------------------------------------------------------------
+bool ProcessPolyloop(const Schema_2x3::IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/)
+{
+    size_t cnt = 0;
+    for(const Schema_2x3::IfcCartesianPoint& c : loop.Polygon) {
+        IfcVector3 tmp;
+        ConvertCartesianPoint(tmp,c);
+
+        meshout.mVerts.push_back(tmp);
+        ++cnt;
+    }
+
+    meshout.mVertcnt.push_back(static_cast<unsigned int>(cnt));
+
+    // zero- or one- vertex polyloops simply ignored
+    if (meshout.mVertcnt.back() > 1) {
+        return true;
+    }
+
+    if (meshout.mVertcnt.back()==1) {
+        meshout.mVertcnt.pop_back();
+        meshout.mVerts.pop_back();
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t master_bounds = (size_t)-1)
+{
+    // handle all trivial cases
+    if(inmesh.mVertcnt.empty()) {
+        return;
+    }
+    if(inmesh.mVertcnt.size() == 1) {
+        result.Append(inmesh);
+        return;
+    }
+
+    ai_assert(std::count(inmesh.mVertcnt.begin(), inmesh.mVertcnt.end(), 0u) == 0);
+
+    typedef std::vector<unsigned int>::const_iterator face_iter;
+
+    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
+    // is the outer contour), reduce the triangulation task arising here to
+    // one that can be solved using the "quadrulation" algorithm which we use
+    // for pouring windows out of walls. The algorithm does not handle all
+    // cases but at least it is numerically stable and gives "nice" triangles.
+
+    // first compute normals for all polygons using Newell's algorithm
+    // do not normalize 'normals', we need the original length for computing the polygon area
+    std::vector<IfcVector3> normals;
+    inmesh.ComputePolygonNormals(normals,false);
+
+    // One of the polygons might be a IfcFaceOuterBound (in which case `master_bounds`
+    // is its index). Sadly we can't rely on it, the docs say 'At most one of the bounds
+    // shall be of the type IfcFaceOuterBound'
+    IfcFloat area_outer_polygon = 1e-10f;
+    if (master_bounds != (size_t)-1) {
+        ai_assert(master_bounds < inmesh.mVertcnt.size());
+        outer_polygon_it = begin + master_bounds;
+    }
+    else {
+        for(iit = begin; iit != end; ++iit) {
+            // find the polygon with the largest area and take it as the outer bound.
+            IfcVector3& n = normals[std::distance(begin,iit)];
+            const IfcFloat area = n.SquareLength();
+            if (area > area_outer_polygon) {
+                area_outer_polygon = area;
+                outer_polygon_it = iit;
+            }
+        }
+    }
+	if (outer_polygon_it == end) {
+		return;
+	}
+
+    const size_t outer_polygon_size = *outer_polygon_it;
+    const IfcVector3& master_normal = normals[std::distance(begin, outer_polygon_it)];
+
+    // Generate fake openings to meet the interface for the quadrulate
+    // algorithm. It boils down to generating small boxes given the
+    // inner polygon and the surface normal of the outer contour.
+    // It is important that we use the outer contour's normal because
+    // this is the plane onto which the quadrulate algorithm will
+    // project the entire mesh.
+    std::vector<TempOpening> fake_openings;
+    fake_openings.reserve(inmesh.mVertcnt.size()-1);
+
+    std::vector<IfcVector3>::const_iterator vit = inmesh.mVerts.begin(), outer_vit;
+
+    for(iit = begin; iit != end; vit += *iit++) {
+        if (iit == outer_polygon_it) {
+            outer_vit = vit;
+            continue;
+        }
+
+        // Filter degenerate polygons to keep them from causing trouble later on
+        IfcVector3& n = normals[std::distance(begin,iit)];
+        const IfcFloat area = n.SquareLength();
+        if (area < 1e-5f) {
+            IFCImporter::LogWarn("skipping degenerate polygon (ProcessPolygonBoundaries)");
+            continue;
+        }
+
+        fake_openings.push_back(TempOpening());
+        TempOpening& opening = fake_openings.back();
+
+        opening.extrusionDir = master_normal;
+        opening.solid = nullptr;
+
+        opening.profileMesh = std::make_shared<TempMesh>();
+        opening.profileMesh->mVerts.reserve(*iit);
+        opening.profileMesh->mVertcnt.push_back(*iit);
+
+        std::copy(vit, vit + *iit, std::back_inserter(opening.profileMesh->mVerts));
+    }
+
+    // fill a mesh with ONLY the main polygon
+    TempMesh temp;
+    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.mVerts));
+
+    GenerateOpenings(fake_openings, temp, false, false);
+    result.Append(temp);
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessConnectedFaceSet(const Schema_2x3::IfcConnectedFaceSet& fset, TempMesh& result, ConversionData& conv)
+{
+    for(const Schema_2x3::IfcFace& face : fset.CfsFaces) {
+        // size_t ob = -1, cnt = 0;
+        TempMesh meshout;
+        for(const Schema_2x3::IfcFaceBound& bound : face.Bounds) {
+
+            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
+                    // polygon covers the largest area.
+
+                    //if(bound.ToPtr<IfcFaceOuterBound>()) {
+                    //  ob = cnt;
+                    //}
+                    //++cnt;
+
+                }
+            }
+            else {
+                IFCImporter::LogWarn("skipping unknown IfcFaceBound entity, type is ", bound.Bound->GetClassName());
+                continue;
+            }
+
+            // And this, even though it is sometimes TRUE and sometimes FALSE,
+            // does not really improve results.
+
+            /*if(!IsTrue(bound.Orientation)) {
+                size_t c = 0;
+                for(unsigned int& c : meshout.vertcnt) {
+                    std::reverse(result.verts.begin() + cnt,result.verts.begin() + cnt + c);
+                    cnt += c;
+                }
+            }*/
+        }
+        ProcessPolygonBoundaries(result, meshout);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+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.mVerts.size()<=1) {
+        return;
+    }
+
+    IfcVector3 axis, pos;
+    ConvertAxisPlacement(axis,pos,solid.Axis);
+
+    IfcMatrix4 tb0,tb1;
+    IfcMatrix4::Translation(pos,tb0);
+    IfcMatrix4::Translation(-pos,tb1);
+
+    const std::vector<IfcVector3>& in = meshout.mVerts;
+    const size_t size=in.size();
+
+    bool has_area = solid.SweptArea->ProfileType == "AREA" && size>2;
+    const IfcFloat max_angle = solid.Angle*conv.angle_scale;
+    if(std::fabs(max_angle) < 1e-3) {
+        if(has_area) {
+            result = meshout;
+        }
+        return;
+    }
+
+    const unsigned int cnt_segments = std::max(2u,static_cast<unsigned int>(conv.settings.cylindricalTessellation * std::fabs(max_angle)/AI_MATH_HALF_PI_F));
+    const IfcFloat delta = max_angle/cnt_segments;
+
+    has_area = has_area && std::fabs(max_angle) < AI_MATH_TWO_PI_F*0.99;
+
+    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.mVerts;
+
+    // dummy data to simplify later processing
+    for(size_t i = 0; i < size; ++i) {
+        out.insert(out.end(),4,in[i]);
+    }
+
+    for(unsigned int seg = 0; seg < cnt_segments; ++seg) {
+        for(size_t i = 0; i < size; ++i) {
+            const size_t next = (i+1)%size;
+
+            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);
+            out.push_back(base_1);
+            out.push_back(rot*base_1);
+            out.push_back(rot*base_0);
+        }
+        base += size*4;
+    }
+
+    out.erase(out.begin(),out.begin()+size*4);
+
+    if(has_area) {
+        // leave the triangulation of the profile area to the ear cutting
+        // implementation in aiProcess_Triangulate - for now we just
+        // feed in two huge polygons.
+        base -= size*8;
+        for(size_t i = size; i--; ) {
+            out.push_back(out[base+i*4+3]);
+        }
+        for(size_t i = 0; i < size; ++i ) {
+            out.push_back(out[i*4]);
+        }
+        result.mVertcnt.push_back(static_cast<unsigned int>(size));
+        result.mVertcnt.push_back(static_cast<unsigned int>(size));
+    }
+
+    IfcMatrix4 trafo;
+    ConvertAxisPlacement(trafo, solid.Position);
+
+    result.Transform(trafo);
+    IFCImporter::LogVerboseDebug("generate mesh procedurally by radial extrusion (IfcRevolvedAreaSolid)");
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessSweptDiskSolid(const Schema_2x3::IfcSweptDiskSolid &solid, TempMesh& result, ConversionData& conv)
+{
+    const Curve* const curve = Curve::Convert(*solid.Directrix, conv);
+    if(!curve) {
+        IFCImporter::LogError("failed to convert Directrix curve (IfcSweptDiskSolid)");
+        return;
+    }
+
+    const unsigned int cnt_segments = conv.settings.cylindricalTessellation;
+    const IfcFloat deltaAngle = AI_MATH_TWO_PI/cnt_segments;
+
+	TempMesh temp;
+	curve->SampleDiscrete(temp, solid.StartParam, solid.EndParam);
+	const std::vector<IfcVector3>& curve_points = temp.mVerts;
+
+    const size_t samples = curve_points.size();
+
+    result.mVerts.reserve(cnt_segments * samples * 4);
+    result.mVertcnt.reserve((cnt_segments - 1) * samples);
+
+    std::vector<IfcVector3> points;
+    points.reserve(cnt_segments * samples);
+
+    if(curve_points.empty()) {
+        IFCImporter::LogWarn("curve evaluation yielded no points (IfcSweptDiskSolid)");
+        return;
+    }
+
+    IfcVector3 current = curve_points[0];
+    IfcVector3 previous = current;
+    IfcVector3 next;
+
+    IfcVector3 startvec;
+    startvec.x = 1.0f;
+    startvec.y = 1.0f;
+    startvec.z = 1.0f;
+
+    unsigned int last_dir = 0;
+
+    // generate circles at the sweep positions
+    for(size_t i = 0; i < samples; ++i) {
+
+        if(i != samples - 1) {
+            next = curve_points[i + 1];
+        }
+
+        // get a direction vector reflecting the approximate curvature (i.e. tangent)
+        IfcVector3 d = (current-previous) + (next-previous);
+
+        d.Normalize();
+
+        // figure out an arbitrary point q so that (p-q) * d = 0,
+        // try to maximize ||(p-q)|| * ||(p_last-q_last)||
+        IfcVector3 q;
+        bool take_any = false;
+
+        for (unsigned int j = 0; j < 2; ++j, take_any = true) {
+            if ((last_dir == 0 || take_any) && std::abs(d.x) > ai_epsilon) {
+                q.y = startvec.y;
+                q.z = startvec.z;
+                q.x = -(d.y * q.y + d.z * q.z) / d.x;
+                last_dir = 0;
+                break;
+            } else if ((last_dir == 1 || take_any) && std::abs(d.y) > ai_epsilon) {
+                q.x = startvec.x;
+                q.z = startvec.z;
+                q.y = -(d.x * q.x + d.z * q.z) / d.y;
+                last_dir = 1;
+                break;
+            } else if ((last_dir == 2 && std::abs(d.z) > ai_epsilon) || take_any) {
+                q.y = startvec.y;
+                q.x = startvec.x;
+                q.z = -(d.y * q.y + d.x * q.x) / d.z;
+                last_dir = 2;
+                break;
+            }
+        }
+
+        q *= solid.Radius / q.Length();
+        startvec = q;
+
+        // generate a rotation matrix to rotate q around d
+        IfcMatrix4 rot;
+        IfcMatrix4::Rotation(deltaAngle,d,rot);
+
+        for (unsigned int seg = 0; seg < cnt_segments; ++seg, q *= rot ) {
+            points.push_back(q + current);
+        }
+
+        previous = current;
+        current = next;
+    }
+
+    // make quads
+    for(size_t i = 0; i < samples - 1; ++i) {
+
+        const aiVector3D& this_start = points[ i * cnt_segments ];
+
+        // locate corresponding point on next sample ring
+        unsigned int best_pair_offset = 0;
+        float best_distance_squared = 1e10f;
+        for (unsigned int seg = 0; seg < cnt_segments; ++seg) {
+            const aiVector3D& p = points[ (i+1) * cnt_segments + seg];
+            const float l = (p-this_start).SquareLength();
+
+            if(l < best_distance_squared) {
+                best_pair_offset = seg;
+                best_distance_squared = l;
+            }
+        }
+
+        for (unsigned int seg = 0; seg < cnt_segments; ++seg) {
+
+            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.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.mVertcnt.push_back(4);
+        }
+    }
+
+    IFCImporter::LogVerboseDebug("generate mesh procedurally by sweeping a disk along a curve (IfcSweptDiskSolid)");
+}
+
+// ------------------------------------------------------------------------------------------------
+IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVector3& norOut)
+{
+    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();
+    ai_assert( curmesh.mVertcnt.size() == 1 );
+    ai_assert( curmesh.mVertcnt.back() == s);
+
+    const IfcVector3 any_point = out[s-1];
+    IfcVector3 nor;
+
+    // The input polygon is arbitrarily shaped, therefore we might need some tries
+    // until we find a suitable normal. Note that Newell's algorithm would give
+    // a more robust result, but this variant also gives us a suitable first
+    // 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 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;
+                break;
+            }
+        }
+    }
+
+    if(!done) {
+        ok = false;
+        return m;
+    }
+
+    nor.Normalize();
+    norOut = nor;
+
+    IfcVector3 r = (out[idx]-any_point);
+    r.Normalize();
+
+    //if(d) {
+    //  *d = -any_point * nor;
+    //}
+
+    // Reconstruct orthonormal basis
+    // XXX use Gram Schmidt for increased robustness
+    IfcVector3 u = r ^ nor;
+    u.Normalize();
+
+    m.a1 = r.x;
+    m.a2 = r.y;
+    m.a3 = r.z;
+
+    m.b1 = u.x;
+    m.b2 = u.y;
+    m.b3 = u.z;
+
+    m.c1 = -nor.x;
+    m.c2 = -nor.y;
+    m.c3 = -nor.z;
+
+    return m;
+}
+
+const auto closeDistance = ai_epsilon;
+
+bool areClose(Schema_2x3::IfcCartesianPoint pt1,Schema_2x3::IfcCartesianPoint pt2) {
+    if(pt1.Coordinates.size() != pt2.Coordinates.size())
+    {
+        IFCImporter::LogWarn("unable to compare differently-dimensioned points");
+        return false;
+    }
+    auto coord1 = pt1.Coordinates.begin();
+    auto coord2 = pt2.Coordinates.begin();
+    // we're just testing each dimension separately rather than doing euclidean distance, as we're
+    // looking for very close coordinates
+    for(; coord1 != pt1.Coordinates.end(); coord1++,coord2++)
+    {
+        if(std::fabs(*coord1 - *coord2) > closeDistance)
+            return false;
+    }
+    return true;
+}
+
+bool areClose(IfcVector3 pt1,IfcVector3 pt2) {
+    return (std::fabs(pt1.x - pt2.x) < closeDistance &&
+        std::fabs(pt1.y - pt2.y) < closeDistance &&
+        std::fabs(pt1.z - pt2.z) < closeDistance);
+}
+// Extrudes the given polygon along the direction, converts it into an opening or applies all openings as necessary.
+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.mVerts.size() > 2;
+    if (solid.Depth < ai_epsilon) {
+        if( has_area ) {
+            result.Append(curve);
+        }
+        return;
+    }
+
+    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;
+    ConvertAxisPlacement(trafo, solid.Position);
+
+    IfcVector3 vmin, vmax;
+    MinMaxChooser<IfcVector3>()(vmin, vmax);
+    for(IfcVector3& v : in) {
+        v *= trafo;
+
+        vmin = std::min(vmin, v);
+        vmax = std::max(vmax, v);
+    }
+
+    vmax -= vmin;
+    const IfcFloat diag = vmax.Length();
+    IfcVector3 dir = IfcMatrix3(trafo) * extrusionDir;
+
+    // reverse profile polygon if it's winded in the wrong direction in relation to the extrusion direction
+    IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(in.data(), in.size());
+    if( profileNormal * dir < 0.0 )
+        std::reverse(in.begin(), in.end());
+
+    std::vector<IfcVector3> nors;
+    const bool openings = !!conv.apply_openings && conv.apply_openings->size();
+
+    // Compute the normal vectors for all opening polygons as a prerequisite
+    // to TryAddOpenings_Poly2Tri()
+    // XXX this belongs into the aforementioned function
+    if( openings ) {
+
+        if( !conv.settings.useCustomTriangulation ) {
+            // it is essential to apply the openings in the correct spatial order. The direction
+            // doesn't matter, but we would screw up if we started with e.g. a door in between
+            // two windows.
+            std::sort(conv.apply_openings->begin(), conv.apply_openings->end(), TempOpening::DistanceSorter(in[0]));
+        }
+
+        nors.reserve(conv.apply_openings->size());
+        for(TempOpening& t : *conv.apply_openings) {
+            TempMesh& bounds = *t.profileMesh.get();
+
+            if( bounds.mVerts.size() <= 2 ) {
+                nors.push_back(IfcVector3());
+                continue;
+            }
+            auto nor = ((bounds.mVerts[2] - bounds.mVerts[0]) ^ (bounds.mVerts[1] - bounds.mVerts[0])).Normalize();
+            auto vI0 = bounds.mVertcnt[0];
+            for(size_t faceI = 0; faceI < bounds.mVertcnt.size(); faceI++)
+            {
+                if(bounds.mVertcnt[faceI] >= 3) {
+                    // do a check that this is at least parallel to the base plane
+                    auto nor2 = ((bounds.mVerts[vI0 + 2] - bounds.mVerts[vI0]) ^ (bounds.mVerts[vI0 + 1] - bounds.mVerts[vI0])).Normalize();
+                    if(!areClose(nor,nor2)) {
+                        std::stringstream msg;
+                        msg << "Face " << faceI << " is not parallel with face 0 - opening on entity " << solid.GetID();
+                        IFCImporter::LogWarn(msg.str().c_str());
+                    }
+                }
+            }
+            nors.push_back(nor);
+        }
+    }
+
+
+    TempMesh temp;
+    TempMesh& curmesh = openings ? temp : result;
+    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.mVertcnt.push_back(4);
+
+        out.push_back(in[i]);
+        out.push_back(in[next]);
+        out.push_back(in[next] + dir);
+        out.push_back(in[i] + dir);
+
+        if( openings ) {
+            if( (in[i] - in[next]).Length() > diag * 0.1 && GenerateOpenings(*conv.apply_openings, temp, true, true, dir) ) {
+                ++sides_with_openings;
+            }
+
+            result.Append(temp);
+            temp.Clear();
+        }
+    }
+
+    if(openings) {
+        for(TempOpening& opening : *conv.apply_openings) {
+            if(!opening.wallPoints.empty()) {
+                std::stringstream msg;
+                msg << "failed to generate all window caps on ID " << (int)solid.GetID();
+                IFCImporter::LogError(msg.str().c_str());
+            }
+            opening.wallPoints.clear();
+        }
+    }
+
+    size_t sides_with_v_openings = 0;
+    if(has_area) {
+
+        for(size_t n = 0; n < 2; ++n) {
+            if(n > 0) {
+                for(size_t i = 0; i < in.size(); ++i)
+                    out.push_back(in[i] + dir);
+            }
+            else {
+                for(size_t i = in.size(); i--; )
+                    out.push_back(in[i]);
+            }
+
+            curmesh.mVertcnt.push_back(static_cast<unsigned int>(in.size()));
+            if(openings && in.size() > 2) {
+                if(GenerateOpenings(*conv.apply_openings,temp,true,true,dir)) {
+                    ++sides_with_v_openings;
+                }
+
+                result.Append(temp);
+                temp.Clear();
+            }
+        }
+    }
+
+    if (openings && (sides_with_openings == 1 || sides_with_v_openings == 2)) {
+        std::stringstream msg;
+        msg << "failed to resolve all openings, presumably their topology is not supported by Assimp - ID " << solid.GetID() << " sides_with_openings " << sides_with_openings << " sides_with_v_openings " << sides_with_v_openings;
+        IFCImporter::LogWarn(msg.str().c_str());
+    }
+
+    IFCImporter::LogVerboseDebug("generate mesh procedurally by extrusion (IfcExtrudedAreaSolid)");
+
+    // If this is an opening element, store both the extruded mesh and the 2D profile mesh
+    // it was created from. Return an empty mesh to the caller.
+    if( collect_openings && !result.IsEmpty() ) {
+        ai_assert(conv.collect_openings);
+        std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
+        profile->Swap(result);
+
+        std::shared_ptr<TempMesh> profile2D = std::shared_ptr<TempMesh>(new TempMesh());
+        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());
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+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.mVerts.size()<=1) {
+        return;
+    }
+
+    IfcVector3 dir;
+    ConvertDirection(dir,solid.ExtrudedDirection);
+    dir *= solid.Depth;
+
+    // Some profiles bring their own holes, for which we need to provide a container. This all is somewhat backwards,
+    // 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 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 Schema_2x3::IfcCurve* curve : cprofile->InnerCurves) {
+                TempMesh curveMesh, tempMesh;
+                ProcessCurve(*curve, curveMesh, conv);
+                ProcessExtrudedArea(solid, curveMesh, dir, tempMesh, conv, true);
+            }
+            // and then apply those to the geometry we're about to generate
+            conv.apply_openings = conv.collect_openings;
+            conv.collect_openings = oldCollectOpenings;
+        }
+    }
+
+    ProcessExtrudedArea(solid, meshout, dir, result, conv, collect_openings);
+    conv.apply_openings = oldApplyOpenings;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh& meshout,
+    ConversionData& conv)
+{
+    if(const Schema_2x3::IfcExtrudedAreaSolid* const solid = swept.ToPtr<Schema_2x3::IfcExtrudedAreaSolid>()) {
+        ProcessExtrudedAreaSolid(*solid,meshout,conv, !!conv.collect_openings);
+    }
+    else if(const Schema_2x3::IfcRevolvedAreaSolid* const rev = swept.ToPtr<Schema_2x3::IfcRevolvedAreaSolid>()) {
+        ProcessRevolvedAreaSolid(*rev,meshout,conv);
+    }
+    else {
+        IFCImporter::LogWarn("skipping unknown IfcSweptAreaSolid entity, type is ", swept.GetClassName());
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+bool ProcessGeometricItem(const Schema_2x3::IfcRepresentationItem& geo, unsigned int matid, std::set<unsigned int>& mesh_indices,
+    ConversionData& conv)
+{
+    bool fix_orientation = false;
+    std::shared_ptr< TempMesh > meshtmp = std::make_shared<TempMesh>();
+    if(const Schema_2x3::IfcShellBasedSurfaceModel* shellmod = geo.ToPtr<Schema_2x3::IfcShellBasedSurfaceModel>()) {
+        for (const std::shared_ptr<const Schema_2x3::IfcShell> &shell : shellmod->SbsmBoundary) {
+            try {
+                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);
+            }
+            catch(std::bad_cast&) {
+                IFCImporter::LogWarn("unexpected type error, IfcShell ought to inherit from IfcConnectedFaceSet");
+            }
+        }
+        fix_orientation = true;
+    }
+    else  if(const Schema_2x3::IfcConnectedFaceSet* fset = geo.ToPtr<Schema_2x3::IfcConnectedFaceSet>()) {
+        ProcessConnectedFaceSet(*fset,*meshtmp.get(),conv);
+        fix_orientation = true;
+    }
+    else  if(const Schema_2x3::IfcSweptAreaSolid* swept = geo.ToPtr<Schema_2x3::IfcSweptAreaSolid>()) {
+        ProcessSweptAreaSolid(*swept,*meshtmp.get(),conv);
+    }
+    else  if(const Schema_2x3::IfcSweptDiskSolid* disk = geo.ToPtr<Schema_2x3::IfcSweptDiskSolid>()) {
+        ProcessSweptDiskSolid(*disk,*meshtmp.get(),conv);
+    }
+    else if(const Schema_2x3::IfcManifoldSolidBrep* brep = geo.ToPtr<Schema_2x3::IfcManifoldSolidBrep>()) {
+        ProcessConnectedFaceSet(brep->Outer,*meshtmp.get(),conv);
+        fix_orientation = true;
+    }
+    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 Schema_2x3::IfcBooleanResult* boolean = geo.ToPtr<Schema_2x3::IfcBooleanResult>()) {
+        ProcessBoolean(*boolean,*meshtmp.get(),conv);
+    }
+    else if(geo.ToPtr<Schema_2x3::IfcBoundingBox>()) {
+        // silently skip over bounding boxes
+        return false;
+    }
+    else {
+        std::stringstream toLog;
+        toLog << "skipping unknown IfcGeometricRepresentationItem entity, type is " << geo.GetClassName() << " id is " << geo.GetID();
+        IFCImporter::LogWarn(toLog.str().c_str());
+        return false;
+    }
+
+    // Do we just collect openings for a parent element (i.e. a wall)?
+    // In such a case, we generate the polygonal mesh as usual,
+    // but attach it to a TempOpening instance which will later be applied
+    // to the wall it pertains to.
+
+    // Note: swep area solids are added in ProcessExtrudedAreaSolid(),
+    // which returns an empty mesh.
+    if(conv.collect_openings) {
+        if (!meshtmp->IsEmpty()) {
+            conv.collect_openings->push_back(TempOpening(geo.ToPtr<Schema_2x3::IfcSolidModel>(),
+                IfcVector3(0,0,0),
+                meshtmp,
+                std::shared_ptr<TempMesh>()));
+        }
+        return true;
+    }
+
+    if (meshtmp->IsEmpty()) {
+        return false;
+    }
+
+    meshtmp->RemoveAdjacentDuplicates();
+    meshtmp->RemoveDegenerates();
+
+    if(fix_orientation) {
+//      meshtmp->FixupFaceOrientation();
+    }
+
+    aiMesh* const mesh = meshtmp->ToMesh();
+    if(mesh) {
+        mesh->mMaterialIndex = matid;
+        mesh_indices.insert(static_cast<unsigned int>(conv.meshes.size()));
+        conv.meshes.push_back(mesh);
+        return true;
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void AssignAddedMeshes(std::set<unsigned int>& mesh_indices,aiNode* nd,
+    ConversionData& /*conv*/)
+{
+    if (!mesh_indices.empty()) {
+		std::set<unsigned int>::const_iterator it = mesh_indices.cbegin();
+		std::set<unsigned int>::const_iterator end = mesh_indices.cend();
+
+        nd->mNumMeshes = static_cast<unsigned int>(mesh_indices.size());
+
+        nd->mMeshes = new unsigned int[nd->mNumMeshes];
+        for(unsigned int i = 0; it != end && i < nd->mNumMeshes; ++i, ++it) {
+            nd->mMeshes[i] = *it;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+bool TryQueryMeshCache(const Schema_2x3::IfcRepresentationItem& item,
+    std::set<unsigned int>& mesh_indices, unsigned int mat_index,
+    ConversionData& conv)
+{
+    ConversionData::MeshCacheIndex idx(&item, mat_index);
+    ConversionData::MeshCache::const_iterator it = conv.cached_meshes.find(idx);
+    if (it != conv.cached_meshes.end()) {
+        std::copy((*it).second.begin(),(*it).second.end(),std::inserter(mesh_indices, mesh_indices.end()));
+        return true;
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void PopulateMeshCache(const Schema_2x3::IfcRepresentationItem& item,
+    const std::set<unsigned int>& mesh_indices, unsigned int mat_index,
+    ConversionData& conv)
+{
+    ConversionData::MeshCacheIndex idx(&item, mat_index);
+    conv.cached_meshes[idx] = mesh_indices;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool ProcessRepresentationItem(const Schema_2x3::IfcRepresentationItem& item, unsigned int matid,
+    std::set<unsigned int>& mesh_indices,
+    ConversionData& conv)
+{
+    // determine material
+    unsigned int localmatid = ProcessMaterials(item.GetID(), matid, conv, true);
+
+    if (!TryQueryMeshCache(item,mesh_indices,localmatid,conv)) {
+        if(ProcessGeometricItem(item,localmatid,mesh_indices,conv)) {
+            if(mesh_indices.size()) {
+                PopulateMeshCache(item,mesh_indices,localmatid,conv);
+            }
+        }
+        else return false;
+    }
+    return true;
+}
+
+
+} // ! IFC
+} // ! Assimp
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.cpp
new file mode 100644
index 0000000..0c20686
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.cpp
@@ -0,0 +1,931 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCLoad.cpp
+ *  @brief Implementation of the Industry Foundation Classes loader.
+ */
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include <iterator>
+#include <limits>
+#include <tuple>
+
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
+#ifdef ASSIMP_USE_HUNTER
+#include <minizip/unzip.h>
+#else
+#include <unzip.h>
+#endif
+#endif
+
+#include "../STEPParser/STEPFileReader.h"
+#include "IFCLoader.h"
+
+#include "IFCUtil.h"
+
+#include <assimp/MemoryIOWrapper.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+namespace Assimp {
+template <>
+const char *LogFunctions<IFCImporter>::Prefix() {
+    static auto prefix = "IFC: ";
+    return prefix;
+}
+} // namespace Assimp
+
+using namespace Assimp;
+using namespace Assimp::Formatter;
+using namespace Assimp::IFC;
+
+/* DO NOT REMOVE this comment block. The genentitylist.sh script
+ * just looks for names adhering to the IfcSomething naming scheme
+ * and includes all matches in the whitelist for code-generation. Thus,
+ * all entity classes that are only indirectly referenced need to be
+ * mentioned explicitly.
+
+  IfcRepresentationMap
+  IfcProductRepresentation
+  IfcUnitAssignment
+  IfcClosedShell
+  IfcDoor
+
+ */
+
+namespace {
+
+// forward declarations
+void SetUnits(ConversionData &conv);
+void SetCoordinateSpace(ConversionData &conv);
+void ProcessSpatialStructures(ConversionData &conv);
+void MakeTreeRelative(ConversionData &conv);
+void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &conv);
+
+} // namespace
+
+static const aiImporterDesc desc = {
+    "Industry Foundation Classes (IFC) Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "ifc ifczip step stp"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+IFCImporter::IFCImporter() {}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+IFCImporter::~IFCImporter() {
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool IFCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    // note: this is the common identification for STEP-encoded files, so
+    // it is only unambiguous as long as we don't support any further
+    // file formats with STEP as their encoding.
+    static const char *tokens[] = { "ISO-10303-21" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+// List all extensions handled by this loader
+const aiImporterDesc *IFCImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup configuration properties for the loader
+void IFCImporter::SetupProperties(const Importer *pImp) {
+    settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS, true);
+    settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION, true);
+    settings.conicSamplingAngle = std::min(std::max((float)pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f);
+    settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180);
+    settings.skipAnnotations = true;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void IFCImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
+    if (!stream) {
+        ThrowException("Could not open file for reading");
+    }
+
+    // if this is a ifczip file, decompress its contents first
+    if (GetExtension(pFile) == "ifczip") {
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
+        unzFile zip = unzOpen(pFile.c_str());
+        if (zip == nullptr) {
+            ThrowException("Could not open ifczip file for reading, unzip failed");
+        }
+
+        // chop 'zip' postfix
+        std::string fileName = pFile.substr(0, pFile.length() - 3);
+
+        std::string::size_type s = pFile.find_last_of('\\');
+        if (s == std::string::npos) {
+            s = pFile.find_last_of('/');
+        }
+        if (s != std::string::npos) {
+            fileName = fileName.substr(s + 1);
+        }
+
+        // search file (same name as the IFCZIP except for the file extension) and place file pointer there
+        if (UNZ_OK == unzGoToFirstFile(zip)) {
+            do {
+                // get file size, etc.
+                unz_file_info fileInfo;
+                char filename[256];
+                unzGetCurrentFileInfo(zip, &fileInfo, filename, sizeof(filename), 0, 0, 0, 0);
+                if (GetExtension(filename) != "ifc") {
+                    continue;
+                }
+                uint8_t *buff = new uint8_t[fileInfo.uncompressed_size];
+                LogInfo("Decompressing IFCZIP file");
+                unzOpenCurrentFile(zip);
+                size_t total = 0;
+                int read = 0;
+                do {
+                    int bufferSize = fileInfo.uncompressed_size < INT16_MAX ? fileInfo.uncompressed_size : INT16_MAX;
+                    void *buffer = malloc(bufferSize);
+                    read = unzReadCurrentFile(zip, buffer, bufferSize);
+                    if (read > 0) {
+                        memcpy((char *)buff + total, buffer, read);
+                        total += read;
+                    }
+                    free(buffer);
+                } while (read > 0);
+                size_t filesize = fileInfo.uncompressed_size;
+                if (total == 0 || size_t(total) != filesize) {
+                    delete[] buff;
+                    ThrowException("Failed to decompress IFC ZIP file");
+                }
+                unzCloseCurrentFile(zip);
+                stream.reset(new MemoryIOStream(buff, fileInfo.uncompressed_size, true));
+                if (unzGoToNextFile(zip) == UNZ_END_OF_LIST_OF_FILE) {
+                    ThrowException("Found no IFC file member in IFCZIP file (1)");
+                }
+                break;
+
+            } while (true);
+        } else {
+            ThrowException("Found no IFC file member in IFCZIP file (2)");
+        }
+
+        unzClose(zip);
+#else
+        ThrowException("Could not open ifczip file for reading, assimp was built without ifczip support");
+#endif
+    }
+
+    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
+    const STEP::HeaderInfo &head = static_cast<const STEP::DB &>(*db).GetHeader();
+
+    if (!head.fileSchema.size() || head.fileSchema.substr(0, 3) != "IFC") {
+        ThrowException("Unrecognized file schema: " + head.fileSchema);
+    }
+
+    if (!DefaultLogger::isNullLogger()) {
+        LogDebug("File schema is \'", head.fileSchema, '\'');
+        if (head.timestamp.length()) {
+            LogDebug("Timestamp \'", head.timestamp, '\'');
+        }
+        if (head.app.length()) {
+            LogDebug("Application/Exporter identline is \'", head.app, '\'');
+        }
+    }
+
+    // obtain a copy of the machine-generated IFC scheme
+    ::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[] = {
+        "ifcsite", "ifcbuilding", "ifcproject"
+    };
+
+    // tell the reader for which types we need to simulate STEPs reverse indices
+    static const char *const inverse_indices_to_track[] = {
+        "ifcrelcontainedinspatialstructure", "ifcrelaggregates", "ifcrelvoidselement", "ifcreldefinesbyproperties", "ifcpropertyset", "ifcstyleditem"
+    };
+
+    // feed the IFC schema into the reader and pre-parse all lines
+    STEP::ReadFile(*db, schema, types_to_track, inverse_indices_to_track);
+    const STEP::LazyObject *proj = db->GetObject("ifcproject");
+    if (!proj) {
+        ThrowException("missing IfcProject entity");
+    }
+
+    ConversionData conv(*db, proj->To<Schema_2x3::IfcProject>(), pScene, settings);
+    SetUnits(conv);
+    SetCoordinateSpace(conv);
+    ProcessSpatialStructures(conv);
+    MakeTreeRelative(conv);
+
+// NOTE - this is a stress test for the importer, but it works only
+// in a build with no entities disabled. See
+//     scripts/IFCImporter/CPPGenerator.py
+// for more information.
+#ifdef ASSIMP_IFC_TEST
+    db->EvaluateAll();
+#endif
+
+    // do final data copying
+    if (conv.meshes.size()) {
+        pScene->mNumMeshes = static_cast<unsigned int>(conv.meshes.size());
+        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
+        std::copy(conv.meshes.begin(), conv.meshes.end(), pScene->mMeshes);
+
+        // needed to keep the d'tor from burning us
+        conv.meshes.clear();
+    }
+
+    if (conv.materials.size()) {
+        pScene->mNumMaterials = static_cast<unsigned int>(conv.materials.size());
+        pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]();
+        std::copy(conv.materials.begin(), conv.materials.end(), pScene->mMaterials);
+
+        // needed to keep the d'tor from burning us
+        conv.materials.clear();
+    }
+
+    // apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x)
+    aiMatrix4x4 scale, rot;
+    aiMatrix4x4::Scaling(static_cast<aiVector3D>(IfcVector3(conv.len_scale)), scale);
+    aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F, rot);
+
+    pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation;
+
+    // this must be last because objects are evaluated lazily as we process them
+    if (!DefaultLogger::isNullLogger()) {
+        LogDebug("STEP: evaluated ", db->GetEvaluatedObjectCount(), " object records");
+    }
+}
+
+namespace {
+
+// ------------------------------------------------------------------------------------------------
+void ConvertUnit(const Schema_2x3::IfcNamedUnit &unit, ConversionData &conv) {
+    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");
+        }
+        if (si->UnitType == "PLANEANGLEUNIT") {
+            if (si->Name != "RADIAN") {
+                IFCImporter::LogWarn("expected base unit for angles to be radian");
+            }
+        }
+    } 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<::Assimp::STEP::EXPRESS::REAL>();
+                ConvertUnit(*convu->ConversionFactor->UnitComponent, conv);
+                IFCImporter::LogDebug("got units used for angles");
+            } catch (std::bad_cast &) {
+                IFCImporter::LogError("skipping unknown IfcConversionBasedUnit.ValueComponent entry - expected REAL");
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &conv) {
+    try {
+        const ::Assimp::STEP::EXPRESS::ENTITY &e = dt.To<::Assimp::STEP::EXPRESS::ENTITY>();
+
+        const Schema_2x3::IfcNamedUnit &unit = e.ResolveSelect<Schema_2x3::IfcNamedUnit>(conv.db);
+        if (unit.UnitType != "LENGTHUNIT" && unit.UnitType != "PLANEANGLEUNIT") {
+            return;
+        }
+
+        ConvertUnit(unit, conv);
+    } catch (std::bad_cast &) {
+        // not entity, somehow
+        IFCImporter::LogError("skipping unknown IfcUnit entry - expected entity");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SetUnits(ConversionData &conv) {
+    // see if we can determine the coordinate space used to express.
+    for (size_t i = 0; i < conv.proj.UnitsInContext->Units.size(); ++i) {
+        ConvertUnit(*conv.proj.UnitsInContext->Units[i], conv);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SetCoordinateSpace(ConversionData &conv) {
+    const Schema_2x3::IfcRepresentationContext *fav = nullptr;
+    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") {
+            break;
+        }
+    }
+    if (fav) {
+        if (const Schema_2x3::IfcGeometricRepresentationContext *const geo = fav->ToPtr<Schema_2x3::IfcGeometricRepresentationContext>()) {
+            ConvertAxisPlacement(conv.wcs, *geo->WorldCoordinateSystem, conv);
+            IFCImporter::LogDebug("got world coordinate system");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ResolveObjectPlacement(aiMatrix4x4 &m, const Schema_2x3::IfcObjectPlacement &place, ConversionData &conv) {
+    if (const Schema_2x3::IfcLocalPlacement *const local = place.ToPtr<Schema_2x3::IfcLocalPlacement>()) {
+        IfcMatrix4 tmp;
+        ConvertAxisPlacement(tmp, *local->RelativePlacement, conv);
+
+        m = static_cast<aiMatrix4x4>(tmp);
+
+        if (local->PlacementRelTo) {
+            aiMatrix4x4 tmpM;
+            ResolveObjectPlacement(tmpM, local->PlacementRelTo.Get(), conv);
+            m = tmpM * m;
+        }
+    } else {
+        IFCImporter::LogWarn("skipping unknown IfcObjectPlacement entity, type is ", place.GetClassName());
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+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 carthesian transform operator is simply a conventional transformation matrix
+    std::unique_ptr<aiNode> nd(new aiNode());
+    nd->mName.Set("IfcMappedItem");
+
+    // handle the Cartesian operator
+    IfcMatrix4 m;
+    ConvertTransformOperator(m, *mapped.MappingTarget);
+
+    IfcMatrix4 msrc;
+    ConvertAxisPlacement(msrc, *mapped.MappingSource->MappingOrigin, conv);
+
+    msrc = m * msrc;
+
+    std::set<unsigned int> meshes;
+    const size_t old_openings = conv.collect_openings ? conv.collect_openings->size() : 0;
+    if (conv.apply_openings) {
+        IfcMatrix4 minv = msrc;
+        minv.Inverse();
+        for (TempOpening &open : *conv.apply_openings) {
+            open.Transform(minv);
+        }
+    }
+
+    unsigned int localmatid = ProcessMaterials(mapped.GetID(), matid, conv, false);
+    const Schema_2x3::IfcRepresentation &repr = mapped.MappingSource->MappedRepresentation;
+
+    bool got = false;
+    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");
+        } else
+            got = true;
+    }
+
+    if (!got) {
+        return false;
+    }
+
+    AssignAddedMeshes(meshes, nd.get(), conv);
+    if (conv.collect_openings) {
+
+        // if this pass serves us only to collect opening geometry,
+        // make sure we transform the TempMesh's which we need to
+        // preserve as well.
+        if (const size_t diff = conv.collect_openings->size() - old_openings) {
+            for (size_t i = 0; i < diff; ++i) {
+                (*conv.collect_openings)[old_openings + i].Transform(msrc);
+            }
+        }
+    }
+
+    nd->mTransformation = nd_src->mTransformation * static_cast<aiMatrix4x4>(msrc);
+    subnodes_src.push_back(nd.release());
+
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+struct RateRepresentationPredicate {
+    int Rate(const Schema_2x3::IfcRepresentation *r) const {
+        // the smaller, the better
+
+        if (!r->RepresentationIdentifier) {
+            // neutral choice if no extra information is specified
+            return 0;
+        }
+
+        const std::string &name = r->RepresentationIdentifier.Get();
+        if (name == "MappedRepresentation") {
+            if (!r->Items.empty()) {
+                // take the first item and base our choice on it
+                const Schema_2x3::IfcMappedItem *const m = r->Items.front()->ToPtr<Schema_2x3::IfcMappedItem>();
+                if (m) {
+                    return Rate(m->MappingSource->MappedRepresentation);
+                }
+            }
+            return 100;
+        }
+
+        return Rate(name);
+    }
+
+    int Rate(const std::string &r) const {
+        if (r == "SolidModel") {
+            return -3;
+        }
+
+        // give strong preference to extruded geometry.
+        if (r == "SweptSolid") {
+            return -10;
+        }
+
+        if (r == "Clipping") {
+            return -5;
+        }
+
+        // 'Brep' is difficult to get right due to possible voids in the
+        // polygon boundaries, so take it only if we are forced to (i.e.
+        // if the only alternative is (non-clipping) boolean operations,
+        // which are not supported at all).
+        if (r == "Brep") {
+            return -2;
+        }
+
+        // Curves, bounding boxes - those will most likely not be loaded
+        // as we can't make any use out of this data. So consider them
+        // last.
+        if (r == "BoundingBox" || r == "Curve2D") {
+            return 100;
+        }
+        return 0;
+    }
+
+    bool operator()(const Schema_2x3::IfcRepresentation *a, const Schema_2x3::IfcRepresentation *b) const {
+        return Rate(a) < Rate(b);
+    }
+};
+
+// ------------------------------------------------------------------------------------------------
+void ProcessProductRepresentation(const Schema_2x3::IfcProduct &el, aiNode *nd, std::vector<aiNode *> &subnodes, ConversionData &conv) {
+    if (!el.Representation) {
+        return;
+    }
+
+    // extract Color from metadata, if present
+    unsigned int matid = ProcessMaterials(el.GetID(), std::numeric_limits<uint32_t>::max(), conv, false);
+    std::set<unsigned int> meshes;
+
+    // we want only one representation type, so bring them in a suitable order (i.e try those
+    // that look as if we could read them quickly at first). This way of reading
+    // 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<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 Schema_2x3::IfcRepresentation *repr : repr_ordered) {
+        bool res = false;
+        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 {
+                res = ProcessRepresentationItem(item, matid, meshes, conv) || res;
+            }
+        }
+        // if we got something meaningful at this point, skip any further representations
+        if (res) {
+            break;
+        }
+    }
+    AssignAddedMeshes(meshes, nd, conv);
+}
+
+typedef std::map<std::string, std::string> Metadata;
+
+// ------------------------------------------------------------------------------------------------
+void ProcessMetadata(const Schema_2x3::ListOf<Schema_2x3::Lazy<Schema_2x3::IfcProperty>, 1, 0> &set, ConversionData &conv, Metadata &properties,
+        const std::string &prefix = std::string(),
+        unsigned int nest = 0) {
+    for (const Schema_2x3::IfcProperty &property : set) {
+        const std::string &key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
+        if (const Schema_2x3::IfcPropertySingleValue *const singleValue = property.ToPtr<Schema_2x3::IfcPropertySingleValue>()) {
+            if (singleValue->NominalValue) {
+                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 ::Assimp::STEP::EXPRESS::REAL *val1 = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
+                    float value = static_cast<float>(*val1);
+                    std::stringstream s;
+                    s << value;
+                    properties[key] = s.str();
+                } else if (const ::Assimp::STEP::EXPRESS::INTEGER *val2 = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
+                    int64_t curValue = static_cast<int64_t>(*val2);
+                    std::stringstream s;
+                    s << curValue;
+                    properties[key] = s.str();
+                }
+            }
+        } else if (const Schema_2x3::IfcPropertyListValue *const listValue = property.ToPtr<Schema_2x3::IfcPropertyListValue>()) {
+            std::stringstream ss;
+            ss << "[";
+            unsigned index = 0;
+            for (const Schema_2x3::IfcValue::Out &v : listValue->ListValues) {
+                if (!v) continue;
+                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 ::Assimp::STEP::EXPRESS::REAL *val1 = v->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
+                    float value = static_cast<float>(*val1);
+                    ss << value;
+                } else if (const ::Assimp::STEP::EXPRESS::INTEGER *val2 = v->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
+                    int64_t value = static_cast<int64_t>(*val2);
+                    ss << value;
+                }
+                if (index + 1 < listValue->ListValues.size()) {
+                    ss << ",";
+                }
+                index++;
+            }
+            ss << "]";
+            properties[key] = ss.str();
+        } 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.");
+            } else {
+                ProcessMetadata(complexProp->HasProperties, conv, properties, key, nest + 1);
+            }
+        } else {
+            properties[key] = std::string();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessMetadata(uint64_t relDefinesByPropertiesID, ConversionData &conv, Metadata &properties) {
+    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 Schema_2x3::IfcProduct &el, ConversionData &conv,
+        std::vector<TempOpening> *collect_openings = nullptr) {
+    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<Schema_2x3::IfcSpace>()) {
+            IFCImporter::LogVerboseDebug("skipping IfcSpace entity due to importer settings");
+            skipGeometry = true;
+        }
+    }
+
+    if (conv.settings.skipAnnotations) {
+        if (el.ToPtr<Schema_2x3::IfcAnnotation>()) {
+            IFCImporter::LogVerboseDebug("skipping IfcAnnotation entity due to importer settings");
+            return nullptr;
+        }
+    }
+
+    // add an output node for this spatial structure
+    aiNode *nd(new aiNode);
+    nd->mName.Set(el.GetClassName() + "_" + (el.Name ? el.Name.Get() : "Unnamed") + "_" + el.GlobalId);
+    nd->mParent = parent;
+
+    conv.already_processed.insert(el.GetID());
+
+    // check for node metadata
+    STEP::DB::RefMapRange children = refs.equal_range(el.GetID());
+    if (children.first != refs.end()) {
+        Metadata properties;
+        if (children.first == children.second) {
+            // handles single property set
+            ProcessMetadata((*children.first).second, conv, properties);
+        } else {
+            // handles multiple property sets (currently all property sets are merged,
+            // which may not be the best solution in the long run)
+            for (STEP::DB::RefMap::const_iterator it = children.first; it != children.second; ++it) {
+                ProcessMetadata((*it).second, conv, properties);
+            }
+        }
+
+        if (!properties.empty()) {
+            aiMetadata *data = aiMetadata::Alloc(static_cast<unsigned int>(properties.size()));
+            unsigned int index(0);
+            for (const Metadata::value_type &kv : properties) {
+                data->Set(index++, kv.first, aiString(kv.second));
+            }
+            nd->mMetaData = data;
+        }
+    }
+
+    if (el.ObjectPlacement) {
+        ResolveObjectPlacement(nd->mTransformation, el.ObjectPlacement.Get(), conv);
+    }
+
+    std::vector<TempOpening> openings;
+
+    IfcMatrix4 myInv;
+    bool didinv = false;
+
+    // convert everything contained directly within this structure,
+    // this may result in more nodes.
+    std::vector<aiNode *> subnodes;
+    try {
+        // locate aggregates and 'contained-in-here'-elements of this spatial structure and add them in recursively
+        // on our way, collect openings in *this* element
+        STEP::DB::RefMapRange range = refs.equal_range(el.GetID());
+
+        for (STEP::DB::RefMapRange range2 = range; range2.first != range.second; ++range2.first) {
+            // skip over meshes that have already been processed before. This is strictly necessary
+            // because the reverse indices also include references contained in argument lists and
+            // therefore every element has a back-reference hold by its parent.
+            if (conv.already_processed.find((*range2.first).second) != conv.already_processed.end()) {
+                continue;
+            }
+            const STEP::LazyObject &obj = conv.db.MustGetObject((*range2.first).second);
+
+            // handle regularly-contained elements
+            if (const Schema_2x3::IfcRelContainedInSpatialStructure *const cont = obj->ToPtr<Schema_2x3::IfcRelContainedInSpatialStructure>()) {
+                if (cont->RelatingStructure->GetID() != el.GetID()) {
+                    continue;
+                }
+                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.
+                        continue;
+                    }
+
+                    aiNode *const ndnew = ProcessSpatialStructure(nd, pro, conv, nullptr);
+                    if (ndnew) {
+                        subnodes.push_back(ndnew);
+                    }
+                }
+            }
+            // handle openings, which we collect in a list rather than adding them to the node graph
+            else if (const Schema_2x3::IfcRelVoidsElement *const fills = obj->ToPtr<Schema_2x3::IfcRelVoidsElement>()) {
+                if (fills->RelatingBuildingElement->GetID() == el.GetID()) {
+                    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());
+                    nd_aggr->mName.Set("$RelVoidsElement");
+                    nd_aggr->mParent = nd;
+
+                    nd_aggr->mTransformation = nd->mTransformation;
+
+                    std::vector<TempOpening> openings_local;
+                    aiNode *const ndnew = ProcessSpatialStructure(nd_aggr.get(), open, conv, &openings_local);
+                    if (ndnew) {
+
+                        nd_aggr->mNumChildren = 1;
+                        nd_aggr->mChildren = new aiNode *[1]();
+
+                        nd_aggr->mChildren[0] = ndnew;
+
+                        if (openings_local.size()) {
+                            if (!didinv) {
+                                myInv = aiMatrix4x4(nd->mTransformation).Inverse();
+                                didinv = true;
+                            }
+
+                            // we need all openings to be in the local space of *this* node, so transform them
+                            for (TempOpening &op : openings_local) {
+                                op.Transform(myInv * nd_aggr->mChildren[0]->mTransformation);
+                                openings.push_back(op);
+                            }
+                        }
+                        subnodes.push_back(nd_aggr.release());
+                    }
+                }
+            }
+        }
+
+        for (; range.first != range.second; ++range.first) {
+            // see note in loop above
+            if (conv.already_processed.find((*range.first).second) != conv.already_processed.end()) {
+                continue;
+            }
+            if (const Schema_2x3::IfcRelAggregates *const aggr = conv.db.GetObject((*range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
+                if (aggr->RelatingObject->GetID() != el.GetID()) {
+                    continue;
+                }
+
+                // move aggregate elements to a separate node since they are semantically different than elements that are just 'contained'
+                std::unique_ptr<aiNode> nd_aggr(new aiNode());
+                nd_aggr->mName.Set("$RelAggregates");
+                nd_aggr->mParent = nd;
+
+                nd_aggr->mTransformation = nd->mTransformation;
+
+                nd_aggr->mChildren = new aiNode *[aggr->RelatedObjects.size()]();
+                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, nullptr);
+                        if (ndnew) {
+                            nd_aggr->mChildren[nd_aggr->mNumChildren++] = ndnew;
+                        }
+                    }
+                }
+
+                subnodes.push_back(nd_aggr.release());
+            }
+        }
+
+        conv.collect_openings = collect_openings;
+        if (!conv.collect_openings) {
+            conv.apply_openings = &openings;
+        }
+
+        if (!skipGeometry) {
+            ProcessProductRepresentation(el, nd, subnodes, conv);
+            conv.apply_openings = conv.collect_openings = nullptr;
+        }
+
+        if (subnodes.size()) {
+            nd->mChildren = new aiNode *[subnodes.size()]();
+            for (aiNode *nd2 : subnodes) {
+                nd->mChildren[nd->mNumChildren++] = nd2;
+                nd2->mParent = nd;
+            }
+        }
+    } catch (...) {
+        // it hurts, but I don't want to pull boost::ptr_vector into -noboost only for these few spots here
+        std::for_each(subnodes.begin(), subnodes.end(), delete_fun<aiNode>());
+        throw;
+    }
+
+    ai_assert(conv.already_processed.find(el.GetID()) != conv.already_processed.end());
+    conv.already_processed.erase(conv.already_processed.find(el.GetID()));
+    return nd;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessSpatialStructures(ConversionData &conv) {
+    // XXX add support for multiple sites (i.e. IfcSpatialStructureElements with composition == COMPLEX)
+
+    // process all products in the file. it is reasonable to assume that a
+    // file that is relevant for us contains at least a site or a building.
+    const STEP::DB::ObjectMapByType &map = conv.db.GetObjectsByType();
+
+    ai_assert(map.find("ifcsite") != map.end());
+    const STEP::DB::ObjectSet *range = &map.find("ifcsite")->second;
+
+    if (range->empty()) {
+        ai_assert(map.find("ifcbuilding") != map.end());
+        range = &map.find("ifcbuilding")->second;
+        if (range->empty()) {
+            // no site, no building -  fail;
+            IFCImporter::ThrowException("no root element found (expected IfcBuilding or preferably IfcSite)");
+        }
+    }
+
+    std::vector<aiNode *> nodes;
+
+    for (const STEP::LazyObject *lz : *range) {
+        const Schema_2x3::IfcSpatialStructureElement *const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
+        if (!prod) {
+            continue;
+        }
+        IFCImporter::LogVerboseDebug("looking at spatial structure `", (prod->Name ? prod->Name.Get() : "unnamed"), "`", (prod->ObjectType ? " which is of type " + prod->ObjectType.Get() : ""));
+
+        // the primary sites are referenced by an IFCRELAGGREGATES element which assigns them to the IFCPRODUCT
+        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 Schema_2x3::IfcRelAggregates *const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
+
+                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()) {
+                        IFCImporter::LogVerboseDebug("selecting this spatial structure as root structure");
+                        // got it, this is one primary site.
+                        nodes.push_back(ProcessSpatialStructure(nullptr, *prod, conv, nullptr));
+                    }
+                }
+            }
+        }
+    }
+
+    size_t nb_nodes = nodes.size();
+
+    if (nb_nodes == 0) {
+        IFCImporter::LogWarn("failed to determine primary site element, taking all the IfcSite");
+        for (const STEP::LazyObject *lz : *range) {
+            const Schema_2x3::IfcSpatialStructureElement *const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
+            if (!prod) {
+                continue;
+            }
+
+            nodes.push_back(ProcessSpatialStructure(nullptr, *prod, conv, nullptr));
+        }
+
+        nb_nodes = nodes.size();
+    }
+
+    if (nb_nodes == 1) {
+        conv.out->mRootNode = nodes[0];
+    } else if (nb_nodes > 1) {
+        conv.out->mRootNode = new aiNode("Root");
+        conv.out->mRootNode->mParent = nullptr;
+        conv.out->mRootNode->mNumChildren = static_cast<unsigned int>(nb_nodes);
+        conv.out->mRootNode->mChildren = new aiNode *[conv.out->mRootNode->mNumChildren];
+
+        for (size_t i = 0; i < nb_nodes; ++i) {
+            aiNode *node = nodes[i];
+
+            node->mParent = conv.out->mRootNode;
+
+            conv.out->mRootNode->mChildren[i] = node;
+        }
+    } else {
+        IFCImporter::ThrowException("failed to determine primary site element");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void MakeTreeRelative(aiNode *start, const aiMatrix4x4 &combined) {
+    // combined is the parent's absolute transformation matrix
+    const aiMatrix4x4 old = start->mTransformation;
+
+    if (!combined.IsIdentity()) {
+        start->mTransformation = aiMatrix4x4(combined).Inverse() * start->mTransformation;
+    }
+
+    // All nodes store absolute transformations right now, so we need to make them relative
+    for (unsigned int i = 0; i < start->mNumChildren; ++i) {
+        MakeTreeRelative(start->mChildren[i], old);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void MakeTreeRelative(ConversionData &conv) {
+    MakeTreeRelative(conv.out->mRootNode, IfcMatrix4());
+}
+
+} // namespace
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.h
new file mode 100644
index 0000000..7b2c3aa
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.h
@@ -0,0 +1,116 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFC.h
+ *  @brief Declaration of the Industry Foundation Classes (IFC) loader main class
+ */
+#ifndef INCLUDED_AI_IFC_LOADER_H
+#define INCLUDED_AI_IFC_LOADER_H
+
+#include <assimp/BaseImporter.h>
+#include <assimp/LogAux.h>
+
+namespace Assimp {
+
+// TinyFormatter.h
+namespace Formatter {
+
+template <typename T, typename TR, typename A>
+class basic_formatter;
+typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
+
+} // namespace Formatter
+
+namespace STEP {
+
+class DB;
+
+}
+
+// -------------------------------------------------------------------------------------------
+/** Load the IFC format, which is an open specification to describe building and construction
+    industry data.
+
+ See http://en.wikipedia.org/wiki/Industry_Foundation_Classes
+*/
+// -------------------------------------------------------------------------------------------
+class IFCImporter : public BaseImporter, public LogFunctions<IFCImporter> {
+public:
+    // loader settings, publicly accessible via their corresponding AI_CONFIG constants
+    struct Settings {
+        Settings() :
+                skipSpaceRepresentations(), useCustomTriangulation(), skipAnnotations(), conicSamplingAngle(10.f), cylindricalTessellation(32) {}
+
+        bool skipSpaceRepresentations;
+        bool useCustomTriangulation;
+        bool skipAnnotations;
+        float conicSamplingAngle;
+        int cylindricalTessellation;
+    };
+
+    IFCImporter();
+    ~IFCImporter() override;
+
+    // --------------------
+    bool CanRead(const std::string &pFile,
+            IOSystem *pIOHandler,
+            bool checkSig) const override;
+
+protected:
+    // --------------------
+    const aiImporterDesc *GetInfo() const override;
+
+    // --------------------
+    void SetupProperties(const Importer *pImp) override;
+
+    // --------------------
+    void InternReadFile(const std::string &pFile,
+            aiScene *pScene,
+            IOSystem *pIOHandler) override;
+
+private:
+    Settings settings;
+
+}; // !class IFCImporter
+
+} // end of namespace Assimp
+#endif // !INCLUDED_AI_IFC_LOADER_H
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCMaterial.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCMaterial.cpp
new file mode 100644
index 0000000..6cd0e59
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCMaterial.cpp
@@ -0,0 +1,202 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCMaterial.cpp
+ *  @brief Implementation of conversion routines to convert IFC materials to aiMaterial
+ */
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "IFCUtil.h"
+#include <limits>
+#include <assimp/material.h>
+
+namespace Assimp {
+namespace IFC {
+
+// ------------------------------------------------------------------------------------------------
+static int ConvertShadingMode(const std::string& name) {
+    if (name == "BLINN") {
+        return aiShadingMode_Blinn;
+    }
+    else if (name == "FLAT" || name == "NOTDEFINED") {
+        return aiShadingMode_NoShading;
+    }
+    else if (name == "PHONG") {
+        return aiShadingMode_Phong;
+    }
+    IFCImporter::LogWarn("shading mode ", name, " not recognized by Assimp, using Phong instead");
+    return aiShadingMode_Phong;
+}
+
+// ------------------------------------------------------------------------------------------------
+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 (const 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::Schema_2x3::IfcSurfaceStyleRendering* ren = shade->ToPtr<IFC::Schema_2x3::IfcSurfaceStyleRendering>()) {
+
+                if (ren->Transparency) {
+                    const float t = 1.f-static_cast<float>(ren->Transparency.Get());
+                    mat->AddProperty(&t,1, AI_MATKEY_OPACITY);
+                }
+
+                if (ren->DiffuseColour) {
+                    ConvertColor(col, *ren->DiffuseColour.Get(),conv,&col_base);
+                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_DIFFUSE);
+                }
+
+                if (ren->SpecularColour) {
+                    ConvertColor(col, *ren->SpecularColour.Get(),conv,&col_base);
+                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_SPECULAR);
+                }
+
+                if (ren->TransmissionColour) {
+                    ConvertColor(col, *ren->TransmissionColour.Get(),conv,&col_base);
+                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_TRANSPARENT);
+                }
+
+                if (ren->ReflectionColour) {
+                    ConvertColor(col, *ren->ReflectionColour.Get(),conv,&col_base);
+                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_REFLECTIVE);
+                }
+
+                const int shading = (ren->SpecularHighlight && ren->SpecularColour)?ConvertShadingMode(ren->ReflectanceMethod):static_cast<int>(aiShadingMode_Gouraud);
+                mat->AddProperty(&shading,1, AI_MATKEY_SHADING_MODEL);
+
+                if (ren->SpecularHighlight) {
+                    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);
+                        mat->AddProperty(&e,1,AI_MATKEY_SHININESS);
+                    }
+                    else {
+                        IFCImporter::LogWarn("unexpected type error, SpecularHighlight should be a REAL");
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+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::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 (const std::shared_ptr<const IFC::Schema_2x3::IfcPresentationStyleSelect> &sel : as.Styles) {
+
+                    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() )
+                            return mit->second;
+
+                        // not found, create new material
+                        const std::string side = static_cast<std::string>(surf->Side);
+                        if( side != "BOTH" ) {
+                            IFCImporter::LogWarn("ignoring surface side marker on IFC::IfcSurfaceStyle: ", side);
+                        }
+
+                        std::unique_ptr<aiMaterial> mat(new aiMaterial());
+
+                        FillMaterial(mat.get(), surf, conv);
+
+                        conv.materials.push_back(mat.release());
+                        unsigned int matindex = static_cast<unsigned int>(conv.materials.size() - 1);
+                        conv.cached_materials[surf] = matindex;
+                        return matindex;
+                    }
+                }
+            }
+        }
+    }
+
+    // no local material defined. If there's global one, use that instead
+    if ( prevMatId != std::numeric_limits<uint32_t>::max() ) {
+        return prevMatId;
+    }
+
+    // we're still here - create an default material if required, or simply fail otherwise
+    if ( !forceDefaultMat ) {
+        return std::numeric_limits<uint32_t>::max();
+    }
+
+    aiString name;
+    name.Set("<IFCDefault>");
+    //  ConvertColorToString( color, name);
+
+    // look if there's already a default material with this base color
+    for( size_t a = 0; a < conv.materials.size(); ++a ) {
+        aiString mname;
+        conv.materials[a]->Get(AI_MATKEY_NAME, mname);
+        if ( name == mname ) {
+            return ( unsigned int )a;
+        }
+    }
+
+    // we're here, yet - no default material with suitable color available. Generate one
+    std::unique_ptr<aiMaterial> mat(new aiMaterial());
+    mat->AddProperty(&name,AI_MATKEY_NAME);
+
+    const aiColor4D col = aiColor4D( 0.6f, 0.6f, 0.6f, 1.0f); // aiColor4D( color.r, color.g, color.b, 1.0f);
+    mat->AddProperty(&col,1, AI_MATKEY_COLOR_DIFFUSE);
+
+    conv.materials.push_back(mat.release());
+    return (unsigned int) conv.materials.size() - 1;
+}
+
+} // ! IFC
+} // ! Assimp
+
+#endif // ASSIMP_BUILD_NO_IFC_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCOpenings.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCOpenings.cpp
new file mode 100644
index 0000000..7420019
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCOpenings.cpp
@@ -0,0 +1,1955 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCOpenings.cpp
+ *  @brief Implements a subset of Ifc CSG operations for pouring
+  *    holes for windows and doors into walls.
+ */
+
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+#include "IFCUtil.h"
+#include "Common/PolyTools.h"
+#include "PostProcessing/ProcessHelper.h"
+
+#ifdef ASSIMP_USE_HUNTER
+#  include <poly2tri/poly2tri.h>
+#  include <polyclipping/clipper.hpp>
+#else
+#  include "../contrib/poly2tri/poly2tri/poly2tri.h"
+#  include "../contrib/clipper/clipper.hpp"
+#endif
+
+#include <iterator>
+#include <forward_list>
+#include <deque>
+
+namespace Assimp {
+    namespace IFC {
+
+        using ClipperLib::ulong64;
+        // XXX use full -+ range ...
+        const ClipperLib::long64 max_ulong64 = 1518500249; // clipper.cpp / hiRange var
+
+        //#define to_int64(p)  (static_cast<ulong64>( std::max( 0., std::min( static_cast<IfcFloat>((p)), 1.) ) * max_ulong64 ))
+#define to_int64(p)  (static_cast<ulong64>(static_cast<IfcFloat>((p) ) * max_ulong64 ))
+#define from_int64(p) (static_cast<IfcFloat>((p)) / max_ulong64)
+#define one_vec (IfcVector2(static_cast<IfcFloat>(1.0),static_cast<IfcFloat>(1.0)))
+
+
+        // fallback method to generate wall openings
+        bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,
+            TempMesh& curmesh);
+
+
+typedef std::pair< IfcVector2, IfcVector2 > BoundingBox;
+typedef std::map<IfcVector2,size_t,XYSorter> XYSortedField;
+
+
+// ------------------------------------------------------------------------------------------------
+void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& field,
+    const std::vector< BoundingBox >& bbs,
+    std::vector<IfcVector2>& out)
+{
+    if (!(pmin.x-pmax.x) || !(pmin.y-pmax.y)) {
+        return;
+    }
+
+    IfcFloat xs = 1e10, xe = 1e10;
+    bool found = false;
+
+    // Search along the x-axis until we find an opening
+    XYSortedField::iterator start = field.begin();
+    for(; start != field.end(); ++start) {
+        const BoundingBox& bb = bbs[(*start).second];
+        if(bb.first.x >= pmax.x) {
+            break;
+        }
+
+        if (bb.second.x > pmin.x && bb.second.y > pmin.y && bb.first.y < pmax.y) {
+            xs = bb.first.x;
+            xe = bb.second.x;
+            found = true;
+            break;
+        }
+    }
+
+    if (!found) {
+        // the rectangle [pmin,pend] is opaque, fill it
+        out.push_back(pmin);
+        out.push_back(IfcVector2(pmin.x,pmax.y));
+        out.push_back(pmax);
+        out.push_back(IfcVector2(pmax.x,pmin.y));
+        return;
+    }
+
+    xs = std::max(pmin.x,xs);
+    xe = std::min(pmax.x,xe);
+
+    // see if there's an offset to fill at the top of our quad
+    if (xs - pmin.x) {
+        out.push_back(pmin);
+        out.push_back(IfcVector2(pmin.x,pmax.y));
+        out.push_back(IfcVector2(xs,pmax.y));
+        out.push_back(IfcVector2(xs,pmin.y));
+    }
+
+    // search along the y-axis for all openings that overlap xs and our quad
+    IfcFloat ylast = pmin.y;
+    found = false;
+    for(; start != field.end(); ++start) {
+        const BoundingBox& bb = bbs[(*start).second];
+        if (bb.first.x > xs || bb.first.y >= pmax.y) {
+            break;
+        }
+
+        if (bb.second.y > ylast) {
+
+            found = true;
+            const IfcFloat ys = std::max(bb.first.y,pmin.y), ye = std::min(bb.second.y,pmax.y);
+            if (ys - ylast > 0.0f) {
+                QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,ys) ,field,bbs,out);
+            }
+
+            // the following are the window vertices
+
+            /*wnd.push_back(IfcVector2(xs,ys));
+            wnd.push_back(IfcVector2(xs,ye));
+            wnd.push_back(IfcVector2(xe,ye));
+            wnd.push_back(IfcVector2(xe,ys));*/
+            ylast = ye;
+        }
+    }
+    if (!found) {
+        // the rectangle [pmin,pend] is opaque, fill it
+        out.push_back(IfcVector2(xs,pmin.y));
+        out.push_back(IfcVector2(xs,pmax.y));
+        out.push_back(IfcVector2(xe,pmax.y));
+        out.push_back(IfcVector2(xe,pmin.y));
+        return;
+    }
+    if (ylast < pmax.y) {
+        QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,pmax.y) ,field,bbs,out);
+    }
+
+    // now for the whole rest
+    if (pmax.x-xe) {
+        QuadrifyPart(IfcVector2(xe,pmin.y), pmax ,field,bbs,out);
+    }
+}
+
+typedef std::vector<IfcVector2> Contour;
+typedef std::vector<bool> SkipList; // should probably use int for performance reasons
+
+struct ProjectedWindowContour
+{
+    Contour contour;
+    BoundingBox bb;
+    SkipList skiplist;
+    bool is_rectangular;
+
+
+    ProjectedWindowContour(const Contour& contour, const BoundingBox& bb, bool is_rectangular)
+        : contour(contour)
+        , bb(bb)
+        , is_rectangular(is_rectangular)
+    {}
+
+
+    bool IsInvalid() const {
+        return contour.empty();
+    }
+
+    void FlagInvalid() {
+        contour.clear();
+    }
+
+    void PrepareSkiplist() {
+        skiplist.resize(contour.size(),false);
+    }
+};
+
+typedef std::vector< ProjectedWindowContour > ContourVector;
+
+// ------------------------------------------------------------------------------------------------
+bool BoundingBoxesOverlapping( const BoundingBox &ibb, const BoundingBox &bb )
+{
+    // count the '=' case as non-overlapping but as adjacent to each other
+    return ibb.first.x < bb.second.x && ibb.second.x > bb.first.x &&
+        ibb.first.y < bb.second.y && ibb.second.y > bb.first.y;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool IsDuplicateVertex(const IfcVector2& vv, const std::vector<IfcVector2>& temp_contour)
+{
+    // sanity check for duplicate vertices
+    for(const IfcVector2& cp : temp_contour) {
+        if ((cp-vv).SquareLength() < 1e-5f) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ExtractVerticesFromClipper(const ClipperLib::Polygon& poly, std::vector<IfcVector2>& temp_contour,
+    bool filter_duplicates = false)
+{
+    temp_contour.clear();
+    for(const ClipperLib::IntPoint& point : poly) {
+        IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y));
+        vv = std::max(vv,IfcVector2());
+        vv = std::min(vv,one_vec);
+
+        if (!filter_duplicates || !IsDuplicateVertex(vv, temp_contour)) {
+            temp_contour.push_back(vv);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+BoundingBox GetBoundingBox(const ClipperLib::Polygon& poly)
+{
+    IfcVector2 newbb_min, newbb_max;
+    MinMaxChooser<IfcVector2>()(newbb_min, newbb_max);
+
+    for(const ClipperLib::IntPoint& point : poly) {
+        IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y));
+
+        // sanity rounding
+        vv = std::max(vv,IfcVector2());
+        vv = std::min(vv,one_vec);
+
+        newbb_min = std::min(newbb_min,vv);
+        newbb_max = std::max(newbb_max,vv);
+    }
+    return BoundingBox(newbb_min, newbb_max);
+}
+
+// ------------------------------------------------------------------------------------------------
+void InsertWindowContours(const ContourVector& contours,
+    const std::vector<TempOpening>& /*openings*/,
+    TempMesh& curmesh)
+{
+    // fix windows - we need to insert the real, polygonal shapes into the quadratic holes that we have now
+    for(size_t i = 0; i < contours.size();++i) {
+        const BoundingBox& bb = contours[i].bb;
+        const std::vector<IfcVector2>& contour = contours[i].contour;
+        if(contour.empty()) {
+            continue;
+        }
+
+        // check if we need to do it at all - many windows just fit perfectly into their quadratic holes,
+        // i.e. their contours *are* already their bounding boxes.
+        if (contour.size() == 4) {
+            std::set<IfcVector2,XYSorter> verts;
+            for(size_t n = 0; n < 4; ++n) {
+                verts.insert(contour[n]);
+            }
+            const std::set<IfcVector2,XYSorter>::const_iterator end = verts.end();
+            if (verts.find(bb.first)!=end && verts.find(bb.second)!=end
+                && verts.find(IfcVector2(bb.first.x,bb.second.y))!=end
+                && verts.find(IfcVector2(bb.second.x,bb.first.y))!=end
+                ) {
+                    continue;
+            }
+        }
+
+        const IfcFloat diag = (bb.first-bb.second).Length();
+        const IfcFloat epsilon = diag/1000.f;
+
+        // walk through all contour points and find those that lie on the BB corner
+        size_t last_hit = (size_t)-1, very_first_hit = (size_t)-1;
+        IfcVector2 edge;
+        for(size_t n = 0, e=0, size = contour.size();; n=(n+1)%size, ++e) {
+
+            // sanity checking
+            if (e == size*2) {
+                IFCImporter::LogError("encountered unexpected topology while generating window contour");
+                break;
+            }
+
+            const IfcVector2& v = contour[n];
+
+            bool hit = false;
+            if (std::fabs(v.x-bb.first.x)<epsilon) {
+                edge.x = bb.first.x;
+                hit = true;
+            }
+            else if (std::fabs(v.x-bb.second.x)<epsilon) {
+                edge.x = bb.second.x;
+                hit = true;
+            }
+
+            if (std::fabs(v.y-bb.first.y)<epsilon) {
+                edge.y = bb.first.y;
+                hit = true;
+            }
+            else if (std::fabs(v.y-bb.second.y)<epsilon) {
+                edge.y = bb.second.y;
+                hit = true;
+            }
+
+            if (hit) {
+                if (last_hit != (size_t)-1) {
+
+                    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, ee = 0; ee <= cnt; a=(a+1)%size, ++ee) {
+                        // hack: this is to fix cases where opening contours are self-intersecting.
+                        // Clipper doesn't produce such polygons, but as soon as we're back in
+                        // our brave new floating-point world, very small distances are consumed
+                        // by the maximum available precision, leading to self-intersecting
+                        // polygons. This fix makes concave windows fail even worse, but
+                        // anyway, fail is fail.
+                        if ((contour[a] - edge).SquareLength() > diag*diag*0.7) {
+                            continue;
+                        }
+                        curmesh.mVerts.push_back(IfcVector3(contour[a].x, contour[a].y, 0.0f));
+                    }
+
+                    if (edge != contour[last_hit]) {
+
+                        IfcVector2 corner = edge;
+
+                        if (std::fabs(contour[last_hit].x-bb.first.x)<epsilon) {
+                            corner.x = bb.first.x;
+                        }
+                        else if (std::fabs(contour[last_hit].x-bb.second.x)<epsilon) {
+                            corner.x = bb.second.x;
+                        }
+
+                        if (std::fabs(contour[last_hit].y-bb.first.y)<epsilon) {
+                            corner.y = bb.first.y;
+                        }
+                        else if (std::fabs(contour[last_hit].y-bb.second.y)<epsilon) {
+                            corner.y = bb.second.y;
+                        }
+
+                        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.mVerts.erase(curmesh.mVerts.begin()+old,curmesh.mVerts.end());
+                    }
+
+                    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;
+                    }
+                }
+                else {
+                    very_first_hit = n;
+                }
+
+                last_hit = n;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void MergeWindowContours (const std::vector<IfcVector2>& a,
+    const std::vector<IfcVector2>& b,
+    ClipperLib::ExPolygons& out)
+{
+    out.clear();
+
+    ClipperLib::Clipper clipper;
+    ClipperLib::Polygon clip;
+
+    for(const IfcVector2& pip : a) {
+        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+    }
+
+    if (ClipperLib::Orientation(clip)) {
+        std::reverse(clip.begin(), clip.end());
+    }
+
+    clipper.AddPolygon(clip, ClipperLib::ptSubject);
+    clip.clear();
+
+    for(const IfcVector2& pip : b) {
+        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+    }
+
+    if (ClipperLib::Orientation(clip)) {
+        std::reverse(clip.begin(), clip.end());
+    }
+
+    clipper.AddPolygon(clip, ClipperLib::ptSubject);
+    clipper.Execute(ClipperLib::ctUnion, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Subtract a from b
+void MakeDisjunctWindowContours (const std::vector<IfcVector2>& a,
+    const std::vector<IfcVector2>& b,
+    ClipperLib::ExPolygons& out)
+{
+    out.clear();
+
+    ClipperLib::Clipper clipper;
+    ClipperLib::Polygon clip;
+
+    for(const IfcVector2& pip : a) {
+        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+    }
+
+    if (ClipperLib::Orientation(clip)) {
+        std::reverse(clip.begin(), clip.end());
+    }
+
+    clipper.AddPolygon(clip, ClipperLib::ptClip);
+    clip.clear();
+
+    for(const IfcVector2& pip : b) {
+        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+    }
+
+    if (ClipperLib::Orientation(clip)) {
+        std::reverse(clip.begin(), clip.end());
+    }
+
+    clipper.AddPolygon(clip, ClipperLib::ptSubject);
+    clipper.Execute(ClipperLib::ctDifference, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
+}
+
+// ------------------------------------------------------------------------------------------------
+void CleanupWindowContour(ProjectedWindowContour& window)
+{
+    std::vector<IfcVector2> scratch;
+    std::vector<IfcVector2>& contour = window.contour;
+
+    ClipperLib::Polygon subject;
+    ClipperLib::Clipper clipper;
+    ClipperLib::ExPolygons clipped;
+
+    for(const IfcVector2& pip : contour) {
+        subject.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+    }
+
+    clipper.AddPolygon(subject,ClipperLib::ptSubject);
+    clipper.Execute(ClipperLib::ctUnion,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
+
+    // This should yield only one polygon or something went wrong
+    if (clipped.size() != 1) {
+
+        // Empty polygon? drop the contour altogether
+        if(clipped.empty()) {
+            IFCImporter::LogError("error during polygon clipping, window contour is degenerate");
+            window.FlagInvalid();
+            return;
+        }
+
+        // Else: take the first only
+        IFCImporter::LogError("error during polygon clipping, window contour is not convex");
+    }
+
+    ExtractVerticesFromClipper(clipped[0].outer, scratch);
+    // Assume the bounding box doesn't change during this operation
+}
+
+// ------------------------------------------------------------------------------------------------
+void CleanupWindowContours(ContourVector& contours)
+{
+    // Use PolyClipper to clean up window contours
+    try {
+        for(ProjectedWindowContour& window : contours) {
+            CleanupWindowContour(window);
+        }
+    }
+    catch (const char* sx) {
+        IFCImporter::LogError("error during polygon clipping, window shape may be wrong: (Clipper: "
+            + std::string(sx) + ")");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh& curmesh)
+{
+    std::vector<IfcVector3> vold;
+    std::vector<unsigned int> iold;
+
+    vold.reserve(curmesh.mVerts.size());
+    iold.reserve(curmesh.mVertcnt.size());
+
+    // Fix the outer contour using polyclipper
+    try {
+
+        ClipperLib::Polygon subject;
+        ClipperLib::Clipper clipper;
+        ClipperLib::ExPolygons clipped;
+
+        ClipperLib::Polygon clip;
+        clip.reserve(contour_flat.size());
+        for(const IfcVector2& pip : contour_flat) {
+            clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+        }
+
+        if (!ClipperLib::Orientation(clip)) {
+            std::reverse(clip.begin(), clip.end());
+        }
+
+        // We need to run polyclipper on every single polygon -- we can't run it one all
+        // of them at once or it would merge them all together which would undo all
+        // previous steps
+        subject.reserve(4);
+        size_t index = 0;
+        size_t countdown = 0;
+        for(const IfcVector3& pip : curmesh.mVerts) {
+            if (!countdown) {
+                countdown = curmesh.mVertcnt[index++];
+                if (!countdown) {
+                    continue;
+                }
+            }
+            subject.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
+            if (--countdown == 0) {
+                if (!ClipperLib::Orientation(subject)) {
+                    std::reverse(subject.begin(), subject.end());
+                }
+
+                clipper.AddPolygon(subject,ClipperLib::ptSubject);
+                clipper.AddPolygon(clip,ClipperLib::ptClip);
+
+                clipper.Execute(ClipperLib::ctIntersection,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
+
+                for(const ClipperLib::ExPolygon& ex : clipped) {
+                    iold.push_back(static_cast<unsigned int>(ex.outer.size()));
+                    for(const ClipperLib::IntPoint& point : ex.outer) {
+                        vold.push_back(IfcVector3(
+                            from_int64(point.X),
+                            from_int64(point.Y),
+                            0.0f));
+                    }
+                }
+
+                subject.clear();
+                clipped.clear();
+                clipper.Clear();
+            }
+        }
+    }
+    catch (const char* sx) {
+        IFCImporter::LogError("Ifc: error during polygon clipping, wall contour line may be wrong: (Clipper: "
+            + std::string(sx) + ")");
+
+        return;
+    }
+
+    // swap data arrays
+    std::swap(vold,curmesh.mVerts);
+    std::swap(iold,curmesh.mVertcnt);
+}
+
+typedef std::vector<TempOpening*> OpeningRefs;
+typedef std::vector<OpeningRefs > OpeningRefVector;
+
+typedef std::vector<std::pair<
+    ContourVector::const_iterator,
+    Contour::const_iterator>
+> ContourRefVector;
+
+// ------------------------------------------------------------------------------------------------
+bool BoundingBoxesAdjacent(const BoundingBox& bb, const BoundingBox& ibb)
+{
+    // TODO: I'm pretty sure there is a much more compact way to check this
+    const IfcFloat epsilon = Math::getEpsilon<float>();
+    return  (std::fabs(bb.second.x - ibb.first.x) < epsilon && bb.first.y <= ibb.second.y && bb.second.y >= ibb.first.y) ||
+        (std::fabs(bb.first.x - ibb.second.x) < epsilon && ibb.first.y <= bb.second.y && ibb.second.y >= bb.first.y) ||
+        (std::fabs(bb.second.y - ibb.first.y) < epsilon && bb.first.x <= ibb.second.x && bb.second.x >= ibb.first.x) ||
+        (std::fabs(bb.first.y - ibb.second.y) < epsilon && ibb.first.x <= bb.second.x && ibb.second.x >= bb.first.x);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Check if m0,m1 intersects n0,n1 assuming same ordering of the points in the line segments
+// output the intersection points on n0,n1
+bool IntersectingLineSegments(const IfcVector2& n0, const IfcVector2& n1,
+    const IfcVector2& m0, const IfcVector2& m1,
+    IfcVector2& out0, IfcVector2& out1)
+{
+    const IfcVector2 n0_to_n1 = n1 - n0;
+
+    const IfcVector2 n0_to_m0 = m0 - n0;
+    const IfcVector2 n1_to_m1 = m1 - n1;
+
+    const IfcVector2 n0_to_m1 = m1 - n0;
+
+    const IfcFloat e = 1e-5f;
+    const IfcFloat smalle = 1e-9f;
+
+    static const IfcFloat inf = std::numeric_limits<IfcFloat>::infinity();
+
+    if (!(n0_to_m0.SquareLength() < e*e || std::fabs(n0_to_m0 * n0_to_n1) / (n0_to_m0.Length() * n0_to_n1.Length()) > 1-1e-5 )) {
+        return false;
+    }
+
+    if (!(n1_to_m1.SquareLength() < e*e || std::fabs(n1_to_m1 * n0_to_n1) / (n1_to_m1.Length() * n0_to_n1.Length()) > 1-1e-5 )) {
+        return false;
+    }
+
+    IfcFloat s0;
+    IfcFloat s1;
+
+    // pick the axis with the higher absolute difference so the result
+    // is more accurate. Since we cannot guarantee that the axis with
+    // the higher absolute difference is big enough as to avoid
+    // divisions by zero, the case 0/0 ~ infinity is detected and
+    // handled separately.
+    if(std::fabs(n0_to_n1.x) > std::fabs(n0_to_n1.y)) {
+        s0 = n0_to_m0.x / n0_to_n1.x;
+        s1 = n0_to_m1.x / n0_to_n1.x;
+
+        if (std::fabs(s0) == inf && std::fabs(n0_to_m0.x) < smalle) {
+            s0 = 0.;
+        }
+        if (std::fabs(s1) == inf && std::fabs(n0_to_m1.x) < smalle) {
+            s1 = 0.;
+        }
+    }
+    else {
+        s0 = n0_to_m0.y / n0_to_n1.y;
+        s1 = n0_to_m1.y / n0_to_n1.y;
+
+        if (std::fabs(s0) == inf && std::fabs(n0_to_m0.y) < smalle) {
+            s0 = 0.;
+        }
+        if (std::fabs(s1) == inf && std::fabs(n0_to_m1.y) < smalle) {
+            s1 = 0.;
+        }
+    }
+
+    if (s1 < s0) {
+        std::swap(s1,s0);
+    }
+
+    s0 = std::max(0.0,s0);
+    s1 = std::max(0.0,s1);
+
+    s0 = std::min(1.0,s0);
+    s1 = std::min(1.0,s1);
+
+    if (std::fabs(s1-s0) < e) {
+        return false;
+    }
+
+    out0 = n0 + s0 * n0_to_n1;
+    out1 = n0 + s1 * n0_to_n1;
+
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+void FindAdjacentContours(ContourVector::iterator current, const ContourVector& contours)
+{
+    const IfcFloat sqlen_epsilon = static_cast<IfcFloat>(Math::getEpsilon<float>());
+    const BoundingBox& bb = (*current).bb;
+
+    // What is to be done here is to populate the skip lists for the contour
+    // and to add necessary padding points when needed.
+    SkipList& skiplist = (*current).skiplist;
+
+    // First step to find possible adjacent contours is to check for adjacent bounding
+    // boxes. If the bounding boxes are not adjacent, the contours lines cannot possibly be.
+    for (ContourVector::const_iterator it = contours.begin(), end = contours.end(); it != end; ++it) {
+        if ((*it).IsInvalid()) {
+            continue;
+        }
+
+        // this left here to make clear we also run on the current contour
+        // to check for overlapping contour segments (which can happen due
+        // to projection artifacts).
+        //if(it == current) {
+        //  continue;
+        //}
+
+        const bool is_me = it == current;
+
+        const BoundingBox& ibb = (*it).bb;
+
+        // Assumption: the bounding boxes are pairwise disjoint or identical
+        ai_assert(is_me || !BoundingBoxesOverlapping(bb, ibb));
+
+        if (is_me || BoundingBoxesAdjacent(bb, ibb)) {
+
+            // Now do a each-against-everyone check for intersecting contour
+            // lines. This obviously scales terribly, but in typical real
+            // world Ifc files it will not matter since most windows that
+            // are adjacent to each others are rectangular anyway.
+
+            Contour& ncontour = (*current).contour;
+            const Contour& mcontour = (*it).contour;
+
+            for (size_t n = 0; n < ncontour.size(); ++n) {
+                const IfcVector2 n0 = ncontour[n];
+                const IfcVector2 n1 = ncontour[(n+1) % ncontour.size()];
+
+                for (size_t m = 0, mend = (is_me ? n : mcontour.size()); m < mend; ++m) {
+                    ai_assert(&mcontour != &ncontour || m < n);
+
+                    const IfcVector2 m0 = mcontour[m];
+                    const IfcVector2 m1 = mcontour[(m+1) % mcontour.size()];
+
+                    IfcVector2 isect0, isect1;
+                    if (IntersectingLineSegments(n0,n1, m0, m1, isect0, isect1)) {
+
+                        if ((isect0 - n0).SquareLength() > sqlen_epsilon) {
+                            ++n;
+
+                            ncontour.insert(ncontour.begin() + n, isect0);
+                            skiplist.insert(skiplist.begin() + n, true);
+                        }
+                        else {
+                            skiplist[n] = true;
+                        }
+
+                        if ((isect1 - n1).SquareLength() > sqlen_epsilon) {
+                            ++n;
+
+                            ncontour.insert(ncontour.begin() + n, isect1);
+                            skiplist.insert(skiplist.begin() + n, false);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+AI_FORCE_INLINE bool LikelyBorder(const IfcVector2& vdelta)
+{
+    const IfcFloat dot_point_epsilon = static_cast<IfcFloat>(Math::getEpsilon<float>());
+    return std::fabs(vdelta.x * vdelta.y) < dot_point_epsilon;
+}
+
+// ------------------------------------------------------------------------------------------------
+void FindBorderContours(ContourVector::iterator current)
+{
+    const IfcFloat border_epsilon_upper = static_cast<IfcFloat>(1-1e-4);
+    const IfcFloat border_epsilon_lower = static_cast<IfcFloat>(1e-4);
+
+    bool outer_border = false;
+    bool start_on_outer_border = false;
+
+    SkipList& skiplist = (*current).skiplist;
+    IfcVector2 last_proj_point;
+
+    const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end();
+
+    for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
+        const IfcVector2& proj_point = *cit;
+
+        // Check if this connection is along the outer boundary of the projection
+        // plane. In such a case we better drop it because such 'edges' should
+        // not have any geometry to close them (think of door openings).
+        if (proj_point.x <= border_epsilon_lower || proj_point.x >= border_epsilon_upper ||
+            proj_point.y <= border_epsilon_lower || proj_point.y >= border_epsilon_upper) {
+
+                if (outer_border) {
+                    ai_assert(cit != cbegin);
+                    if (LikelyBorder(proj_point - last_proj_point)) {
+                        skiplist[std::distance(cbegin, cit) - 1] = true;
+                    }
+                }
+                else if (cit == cbegin) {
+                    start_on_outer_border = true;
+                }
+
+                outer_border = true;
+        }
+        else {
+            outer_border = false;
+        }
+
+        last_proj_point = proj_point;
+    }
+
+    // handle last segment
+    if (outer_border && start_on_outer_border) {
+        const IfcVector2& proj_point = *cbegin;
+        if (LikelyBorder(proj_point - last_proj_point)) {
+            skiplist[skiplist.size()-1] = true;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+AI_FORCE_INLINE bool LikelyDiagonal(IfcVector2 vdelta)
+{
+    vdelta.x = std::fabs(vdelta.x);
+    vdelta.y = std::fabs(vdelta.y);
+    return (std::fabs(vdelta.x-vdelta.y) < 0.8 * std::max(vdelta.x, vdelta.y));
+}
+
+// ------------------------------------------------------------------------------------------------
+void FindLikelyCrossingLines(ContourVector::iterator current)
+{
+    SkipList& skiplist = (*current).skiplist;
+    IfcVector2 last_proj_point;
+
+    const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end();
+    for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
+        const IfcVector2& proj_point = *cit;
+
+        if (cit != cbegin) {
+            IfcVector2 vdelta = proj_point - last_proj_point;
+            if (LikelyDiagonal(vdelta)) {
+                skiplist[std::distance(cbegin, cit) - 1] = true;
+            }
+        }
+
+        last_proj_point = proj_point;
+    }
+
+    // handle last segment
+    if (LikelyDiagonal(*cbegin - last_proj_point)) {
+        skiplist[skiplist.size()-1] = true;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+size_t CloseWindows(ContourVector& contours,
+    const IfcMatrix4& minv,
+    OpeningRefVector& contours_to_openings,
+    TempMesh& curmesh)
+{
+    size_t closed = 0;
+    // For all contour points, check if one of the assigned openings does
+    // already have points assigned to it. In this case, assume this is
+    // the other side of the wall and generate connections between
+    // the two holes in order to close the window.
+
+    // All this gets complicated by the fact that contours may pertain to
+    // multiple openings(due to merging of adjacent or overlapping openings).
+    // The code is based on the assumption that this happens symmetrically
+    // on both sides of the wall. If it doesn't (which would be a bug anyway)
+    // wrong geometry may be generated.
+    for (ContourVector::iterator it = contours.begin(), end = contours.end(); it != end; ++it) {
+        if ((*it).IsInvalid()) {
+            continue;
+        }
+        OpeningRefs& refs = contours_to_openings[std::distance(contours.begin(), it)];
+
+        bool has_other_side = false;
+        for(const TempOpening* opening : refs) {
+            if(!opening->wallPoints.empty()) {
+                has_other_side = true;
+                break;
+            }
+        }
+
+        if (has_other_side) {
+
+            ContourRefVector adjacent_contours;
+
+            // prepare a skiplist for this contour. The skiplist is used to
+            // eliminate unwanted contour lines for adjacent windows and
+            // those bordering the outer frame.
+            (*it).PrepareSkiplist();
+
+            FindAdjacentContours(it, contours);
+            FindBorderContours(it);
+
+            // if the window is the result of a finite union or intersection of rectangles,
+            // there shouldn't be any crossing or diagonal lines in it. Such lines would
+            // be artifacts caused by numerical inaccuracies or other bugs in polyclipper
+            // and our own code. Since rectangular openings are by far the most frequent
+            // case, it is worth filtering for this corner case.
+            if((*it).is_rectangular) {
+                FindLikelyCrossingLines(it);
+            }
+
+            ai_assert((*it).skiplist.size() == (*it).contour.size());
+
+            SkipList::const_iterator skipbegin = (*it).skiplist.begin();
+
+            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.mVertcnt.size() > 0) {
+				IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front());
+
+				std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
+
+				for(size_t a = 0; a < it->contour.size(); ++a)
+					worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0);
+
+				IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
+
+				reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
+			}
+
+            // XXX this algorithm is really a bit inefficient - both in terms
+            // of constant factor and of asymptotic runtime.
+            std::vector<bool>::const_iterator skipit = skipbegin;
+
+            IfcVector3 start0;
+            IfcVector3 start1;
+
+            const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end();
+
+            bool drop_this_edge = false;
+            for (Contour::const_iterator cit = cbegin; cit != cend; ++cit, drop_this_edge = *skipit++) {
+                const IfcVector2& proj_point = *cit;
+
+                // Locate the closest opposite point. This should be a good heuristic to
+                // connect only the points that are really intended to be connected.
+                IfcFloat best = static_cast<IfcFloat>(1e10);
+                IfcVector3 bestv;
+
+                const IfcVector3 world_point = minv * IfcVector3(proj_point.x,proj_point.y,0.0f);
+
+                for(const TempOpening* opening : refs) {
+                    for(const IfcVector3& other : opening->wallPoints) {
+                        const IfcFloat sqdist = (world_point - other).SquareLength();
+
+                        if (sqdist < best) {
+                            // avoid self-connections
+                            if(sqdist < 1e-5) {
+                                continue;
+                            }
+
+                            bestv = other;
+                            best = sqdist;
+                        }
+                    }
+                }
+
+                if (drop_this_edge) {
+                    curmesh.mVerts.pop_back();
+                    curmesh.mVerts.pop_back();
+                }
+                else {
+                    curmesh.mVerts.push_back(((cit == cbegin) != reverseCountourFaces) ? world_point : bestv);
+                    curmesh.mVerts.push_back(((cit == cbegin) != reverseCountourFaces) ? bestv : world_point);
+
+                    curmesh.mVertcnt.push_back(4);
+                    ++closed;
+                }
+
+                if (cit == cbegin) {
+                    start0 = world_point;
+                    start1 = bestv;
+                    continue;
+                }
+
+                curmesh.mVerts.push_back(reverseCountourFaces ? bestv : world_point);
+                curmesh.mVerts.push_back(reverseCountourFaces ? world_point : bestv);
+
+                if (cit == cend - 1) {
+                    drop_this_edge = *skipit;
+
+                    // Check if the final connection (last to first element) is itself
+                    // a border edge that needs to be dropped.
+                    if (drop_this_edge) {
+                        --closed;
+                        curmesh.mVertcnt.pop_back();
+                        curmesh.mVerts.pop_back();
+                        curmesh.mVerts.pop_back();
+                    }
+                    else {
+                        curmesh.mVerts.push_back(reverseCountourFaces ? start0 : start1);
+                        curmesh.mVerts.push_back(reverseCountourFaces ? start1 : start0);
+                    }
+                }
+            }
+        }
+        else {
+
+            const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end();
+            for(TempOpening* opening : refs) {
+                ai_assert(opening->wallPoints.empty());
+                opening->wallPoints.reserve(opening->wallPoints.capacity() + (*it).contour.size());
+                for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
+
+                    const IfcVector2& proj_point = *cit;
+                    opening->wallPoints.push_back(minv * IfcVector3(proj_point.x,proj_point.y,0.0f));
+                }
+            }
+        }
+    }
+    return closed;
+}
+
+// ------------------------------------------------------------------------------------------------
+void Quadrify(const std::vector< BoundingBox >& bbs, TempMesh& curmesh)
+{
+    ai_assert(curmesh.IsEmpty());
+
+    std::vector<IfcVector2> quads;
+    quads.reserve(bbs.size()*4);
+
+    // sort openings by x and y axis as a preliminiary to the QuadrifyPart() algorithm
+    XYSortedField field;
+    for (std::vector<BoundingBox>::const_iterator it = bbs.begin(); it != bbs.end(); ++it) {
+        if (field.find((*it).first) != field.end()) {
+            IFCImporter::LogWarn("constraint failure during generation of wall openings, results may be faulty");
+        }
+        field[(*it).first] = std::distance(bbs.begin(),it);
+    }
+
+    QuadrifyPart(IfcVector2(),one_vec,field,bbs,quads);
+    ai_assert(!(quads.size() % 4));
+
+    curmesh.mVertcnt.resize(quads.size()/4,4);
+    curmesh.mVerts.reserve(quads.size());
+    for(const IfcVector2& v2 : quads) {
+        curmesh.mVerts.push_back(IfcVector3(v2.x, v2.y, static_cast<IfcFloat>(0.0)));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void Quadrify(const ContourVector& contours, TempMesh& curmesh)
+{
+    std::vector<BoundingBox> bbs;
+    bbs.reserve(contours.size());
+
+    for(const ContourVector::value_type& val : contours) {
+        bbs.push_back(val.bb);
+    }
+
+    Quadrify(bbs, 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.mVerts;
+    ok = true;
+
+    IfcMatrix4 m = IfcMatrix4(DerivePlaneCoordinateSpace(in_mesh, ok, nor_out));
+    if(!ok) {
+        return IfcMatrix4();
+    }
+#ifdef ASSIMP_BUILD_DEBUG
+    const IfcFloat det = m.Determinant();
+    ai_assert(std::fabs(det-1) < 1e-5);
+#endif
+
+    IfcFloat zcoord = 0;
+    out_contour.reserve(in_verts.size());
+
+
+    IfcVector3 vmin, vmax;
+    MinMaxChooser<IfcVector3>()(vmin, vmax);
+
+    // Project all points into the new coordinate system, collect min/max verts on the way
+    for(const IfcVector3& x : in_verts) {
+        const IfcVector3 vv = m * x;
+        // keep Z offset in the plane coordinate system. Ignoring precision issues
+        // (which  are present, of course), this should be the same value for
+        // all polygon vertices (assuming the polygon is planar).
+
+        // XXX this should be guarded, but we somehow need to pick a suitable
+        // epsilon
+        // if(coord != -1.0f) {
+        //  assert(std::fabs(coord - vv.z) < 1e-3f);
+        // }
+        zcoord += vv.z;
+        vmin = std::min(vv, vmin);
+        vmax = std::max(vv, vmax);
+
+        out_contour.push_back(IfcVector2(vv.x,vv.y));
+    }
+
+    zcoord /= in_verts.size();
+
+    // Further improve the projection by mapping the entire working set into
+    // [0,1] range. This gives us a consistent data range so all epsilons
+    // used below can be constants.
+    vmax -= vmin;
+    for(IfcVector2& vv : out_contour) {
+        vv.x  = (vv.x - vmin.x) / vmax.x;
+        vv.y  = (vv.y - vmin.y) / vmax.y;
+
+        // sanity rounding
+        vv = std::max(vv,IfcVector2());
+        vv = std::min(vv,one_vec);
+    }
+
+    IfcMatrix4 mult;
+    mult.a1 = static_cast<IfcFloat>(1.0) / vmax.x;
+    mult.b2 = static_cast<IfcFloat>(1.0) / vmax.y;
+
+    mult.a4 = -vmin.x * mult.a1;
+    mult.b4 = -vmin.y * mult.b2;
+    mult.c4 = -zcoord;
+    m = mult * m;
+
+    // debug code to verify correctness
+#ifdef ASSIMP_BUILD_DEBUG
+    std::vector<IfcVector2> out_contour2;
+    for(const IfcVector3& x : in_verts) {
+        const IfcVector3& vv = m * x;
+
+        out_contour2.push_back(IfcVector2(vv.x,vv.y));
+        ai_assert(std::fabs(vv.z) < vmax.z + 1e-8);
+    }
+
+    for(size_t i = 0; i < out_contour.size(); ++i) {
+        ai_assert((out_contour[i] - out_contour2[i]).SquareLength() < ai_epsilon);
+    }
+#endif
+
+    return m;
+}
+
+// ------------------------------------------------------------------------------------------------
+bool GenerateOpenings(std::vector<TempOpening>& openings,
+    TempMesh& curmesh,
+    bool check_intersection,
+    bool generate_connection_geometry,
+    const IfcVector3& wall_extrusion_axis)
+{
+    OpeningRefVector contours_to_openings;
+
+    // Try to derive a solid base plane within the current surface for use as
+    // working coordinate system. Map all vertices onto this plane and
+    // rescale them to [0,1] range. This normalization means all further
+    // epsilons need not be scaled.
+    bool ok = true;
+
+    std::vector<IfcVector2> contour_flat;
+
+    IfcVector3 nor;
+    const IfcMatrix4 m = ProjectOntoPlane(contour_flat, curmesh,  ok, nor);
+    if(!ok) {
+        return false;
+    }
+
+    // Obtain inverse transform for getting back to world space later on
+    const IfcMatrix4 minv = IfcMatrix4(m).Inverse();
+
+    // Compute bounding boxes for all 2D openings in projection space
+    ContourVector contours;
+
+    std::vector<IfcVector2> temp_contour;
+    std::vector<IfcVector2> temp_contour2;
+
+    IfcVector3 wall_extrusion_axis_norm = wall_extrusion_axis;
+    wall_extrusion_axis_norm.Normalize();
+
+    for(TempOpening& opening :openings) {
+
+        // extrusionDir may be 0,0,0 on case where the opening mesh is not an
+        // IfcExtrudedAreaSolid but something else (i.e. a brep)
+        IfcVector3 norm_extrusion_dir = opening.extrusionDir;
+        if (norm_extrusion_dir.SquareLength() > 1e-10) {
+            norm_extrusion_dir.Normalize();
+        }
+        else {
+            norm_extrusion_dir = IfcVector3();
+        }
+
+        TempMesh* profile_data =  opening.profileMesh.get();
+        bool is_2d_source = false;
+        if (opening.profileMesh2D && norm_extrusion_dir.SquareLength() > 0) {
+            if (std::fabs(norm_extrusion_dir * nor) > 0.9) {
+                profile_data = opening.profileMesh2D.get();
+                is_2d_source = true;
+            }
+        }
+        std::vector<IfcVector3> profile_verts = profile_data->mVerts;
+        std::vector<unsigned int> profile_vertcnts = profile_data->mVertcnt;
+        if(profile_verts.size() <= 2) {
+            continue;
+        }
+
+        // The opening meshes are real 3D meshes so skip over all faces
+        // clearly facing into the wrong direction. Also, we need to check
+        // whether the meshes do actually intersect the base surface plane.
+        // This is done by recording minimum and maximum values for the
+        // d component of the plane equation for all polys and checking
+        // against surface d.
+
+        // Use the sign of the dot product of the face normal to the plane
+        // normal to determine to which side of the difference mesh a
+        // triangle belongs. Get independent bounding boxes and vertex
+        // sets for both sides and take the better one (we can't just
+        // take both - this would likely cause major screwup of vertex
+        // winding, producing errors as late as in CloseWindows()).
+        IfcFloat dmin, dmax;
+        MinMaxChooser<IfcFloat>()(dmin,dmax);
+
+        temp_contour.clear();
+        temp_contour2.clear();
+
+        IfcVector2 vpmin,vpmax;
+        MinMaxChooser<IfcVector2>()(vpmin,vpmax);
+
+        IfcVector2 vpmin2,vpmax2;
+        MinMaxChooser<IfcVector2>()(vpmin2,vpmax2);
+
+        for (size_t f = 0, vi_total = 0, fend = profile_vertcnts.size(); f < fend; ++f) {
+
+            bool side_flag = true;
+            if (!is_2d_source) {
+                const IfcVector3 face_nor = ((profile_verts[vi_total+2] - profile_verts[vi_total]) ^
+                    (profile_verts[vi_total+1] - profile_verts[vi_total])).Normalize();
+
+                const IfcFloat abs_dot_face_nor = std::abs(nor * face_nor);
+                if (abs_dot_face_nor < 0.9) {
+                    vi_total += profile_vertcnts[f];
+                    continue;
+                }
+
+                side_flag = nor * face_nor > 0;
+            }
+
+            for (unsigned int vi = 0, vend = profile_vertcnts[f]; vi < vend; ++vi, ++vi_total) {
+                const IfcVector3& x = profile_verts[vi_total];
+
+                const IfcVector3 v = m * x;
+                IfcVector2 vv(v.x, v.y);
+
+                //if(check_intersection) {
+                    dmin = std::min(dmin, v.z);
+                    dmax = std::max(dmax, v.z);
+                //}
+
+                // sanity rounding
+                vv = std::max(vv,IfcVector2());
+                vv = std::min(vv,one_vec);
+
+                if(side_flag) {
+                    vpmin = std::min(vpmin,vv);
+                    vpmax = std::max(vpmax,vv);
+                }
+                else {
+                    vpmin2 = std::min(vpmin2,vv);
+                    vpmax2 = std::max(vpmax2,vv);
+                }
+
+                std::vector<IfcVector2>& store = side_flag ? temp_contour : temp_contour2;
+
+                if (!IsDuplicateVertex(vv, store)) {
+                    store.push_back(vv);
+                }
+            }
+        }
+
+        if (temp_contour2.size() > 2) {
+            ai_assert(!is_2d_source);
+            const IfcVector2 area = vpmax-vpmin;
+            const IfcVector2 area2 = vpmax2-vpmin2;
+            if (temp_contour.size() <= 2 || std::fabs(area2.x * area2.y) > std::fabs(area.x * area.y)) {
+                temp_contour.swap(temp_contour2);
+
+                vpmax = vpmax2;
+                vpmin = vpmin2;
+            }
+        }
+        if(temp_contour.size() <= 2) {
+            continue;
+        }
+
+        // TODO: This epsilon may be too large
+        const IfcFloat epsilon = std::fabs(dmax-dmin) * 0.0001;
+        if (!is_2d_source && check_intersection && (0 < dmin-epsilon || 0 > dmax+epsilon)) {
+            continue;
+        }
+
+        BoundingBox bb = BoundingBox(vpmin,vpmax);
+
+        // Skip over very small openings - these are likely projection errors
+        // (i.e. they don't belong to this side of the wall)
+        if(std::fabs(vpmax.x - vpmin.x) * std::fabs(vpmax.y - vpmin.y) < static_cast<IfcFloat>(1e-10)) {
+            continue;
+        }
+        std::vector<TempOpening*> joined_openings(1, &opening);
+
+        bool is_rectangle = temp_contour.size() == 4;
+
+        // See if this BB intersects or is in close adjacency to any other BB we have so far.
+        for (ContourVector::iterator it = contours.begin(); it != contours.end(); ) {
+            const BoundingBox& ibb = (*it).bb;
+
+            if (BoundingBoxesOverlapping(ibb, bb)) {
+
+                if (!(*it).is_rectangular) {
+                    is_rectangle = false;
+                }
+
+                const std::vector<IfcVector2>& other = (*it).contour;
+                ClipperLib::ExPolygons poly;
+
+                // First check whether subtracting the old contour (to which ibb belongs)
+                // from the new contour (to which bb belongs) yields an updated bb which
+                // no longer overlaps ibb
+                MakeDisjunctWindowContours(other, temp_contour, poly);
+                if(poly.size() == 1) {
+
+                    const BoundingBox newbb = GetBoundingBox(poly[0].outer);
+                    if (!BoundingBoxesOverlapping(ibb, newbb )) {
+                         // Good guy bounding box
+                         bb = newbb ;
+
+                         ExtractVerticesFromClipper(poly[0].outer, temp_contour, false);
+                         continue;
+                    }
+                }
+
+                // Take these two overlapping contours and try to merge them. If they
+                // overlap (which should not happen, but in fact happens-in-the-real-
+                // world [tm] ), resume using a single contour and a single bounding box.
+                MergeWindowContours(temp_contour, other, poly);
+
+                if (poly.size() > 1) {
+                    return TryAddOpenings_Poly2Tri(openings, curmesh);
+                }
+                else if (poly.size() == 0) {
+                    IFCImporter::LogWarn("ignoring duplicate opening");
+                    temp_contour.clear();
+                    break;
+                }
+                else {
+                    IFCImporter::LogVerboseDebug("merging overlapping openings");
+                    ExtractVerticesFromClipper(poly[0].outer, temp_contour, false);
+
+                    // Generate the union of the bounding boxes
+                    bb.first = std::min(bb.first, ibb.first);
+                    bb.second = std::max(bb.second, ibb.second);
+
+                    // Update contour-to-opening tables accordingly
+                    if (generate_connection_geometry) {
+                        std::vector<TempOpening*>& t = contours_to_openings[std::distance(contours.begin(),it)];
+                        joined_openings.insert(joined_openings.end(), t.begin(), t.end());
+
+                        contours_to_openings.erase(contours_to_openings.begin() + std::distance(contours.begin(),it));
+                    }
+
+                    contours.erase(it);
+
+                    // Restart from scratch because the newly formed BB might now
+                    // overlap any other BB which its constituent BBs didn't
+                    // previously overlap.
+                    it = contours.begin();
+                    continue;
+                }
+            }
+            ++it;
+        }
+
+        if(!temp_contour.empty()) {
+            if (generate_connection_geometry) {
+                contours_to_openings.push_back(std::vector<TempOpening*>(
+                    joined_openings.begin(),
+                    joined_openings.end()));
+            }
+
+            contours.push_back(ProjectedWindowContour(temp_contour, bb, is_rectangle));
+        }
+    }
+
+    // Check if we still have any openings left - it may well be that this is
+    // not the cause, for example if all the opening candidates don't intersect
+    // this surface or point into a direction perpendicular to it.
+    if (contours.empty()) {
+        return false;
+    }
+
+    curmesh.Clear();
+
+    // Generate a base subdivision into quads to accommodate the given list
+    // of window bounding boxes.
+    Quadrify(contours,curmesh);
+
+    // Run a sanity cleanup pass on the window contours to avoid generating
+    // artifacts during the contour generation phase later on.
+    CleanupWindowContours(contours);
+
+    // Previously we reduced all windows to rectangular AABBs in projection
+    // space, now it is time to fill the gaps between the BBs and the real
+    // window openings.
+    InsertWindowContours(contours,openings, curmesh);
+
+    // Clip the entire outer contour of our current result against the real
+    // outer contour of the surface. This is necessary because the result
+    // of the Quadrify() algorithm is always a square area spanning
+    // over [0,1]^2 (i.e. entire projection space).
+    CleanupOuterContour(contour_flat, curmesh);
+
+    // Undo the projection and get back to world (or local object) space
+    for(IfcVector3& v3 : curmesh.mVerts) {
+        v3 = minv * v3;
+    }
+
+    // Generate window caps to connect the symmetric openings on both sides
+    // of the wall.
+    if (generate_connection_geometry) {
+        CloseWindows(contours, minv, contours_to_openings, curmesh);
+    }
+    return true;
+}
+
+std::vector<IfcVector2> GetContourInPlane2D(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
+    IfcVector3 planeNor,IfcFloat planeOffset,
+    IfcVector3 extrusionDir,IfcVector3& wall_extrusion,bool& first,bool& ok) {
+    std::vector<IfcVector2> contour;
+
+    const auto outernor = ((mesh->mVerts[2] - mesh->mVerts[0]) ^ (mesh->mVerts[1] - mesh->mVerts[0])).Normalize();
+    const IfcFloat dot = planeNor * outernor;
+    if (std::fabs(dot) < 1.f - ai_epsilon) {
+        std::stringstream msg;
+        msg << "Skipping: Unaligned opening (" << planeNor.x << ", " << planeNor.y << ", " << planeNor.z << ")";
+        msg << " . ( " << outernor.x << ", " << outernor.y << ", " << outernor.z << ") = " << dot;
+        IFCImporter::LogDebug(msg.str().c_str());
+        ok = false;
+        return contour;
+    }
+
+    const std::vector<IfcVector3>& va = mesh->mVerts;
+    if(va.size() <= 2) {
+        std::stringstream msg;
+        msg << "Skipping: Only " << va.size() << " verticies in opening mesh.";
+        IFCImporter::LogDebug(msg.str().c_str());
+        ok = false;
+        return contour;
+    }
+
+    for(const IfcVector3& xx : mesh->mVerts) {
+        IfcVector3 vv = planeSpace * xx,vv_extr = planeSpace * (xx + extrusionDir);
+
+        const bool is_extruded_side = std::fabs(vv.z - planeOffset) > std::fabs(vv_extr.z - planeOffset);
+        if(first) {
+            first = false;
+            if(dot > 0.f) {
+                wall_extrusion = extrusionDir;
+                if(is_extruded_side) {
+                    wall_extrusion = -wall_extrusion;
+                }
+            }
+        }
+
+        // XXX should not be necessary - but it is. Why? For precision reasons?
+        vv = is_extruded_side ? vv_extr : vv;
+        contour.push_back(IfcVector2(vv.x,vv.y));
+    }
+    ok = true;
+
+    return contour;
+}
+
+const float close{ ai_epsilon };
+
+static bool isClose(IfcVector2 first,IfcVector2 second) {
+    auto diff = (second - first);
+    return (std::fabs(diff.x) < close && std::fabs(diff.y) < close);
+}
+
+static void logSegment(std::pair<IfcVector2,IfcVector2> segment) {
+    std::stringstream msg2;
+    msg2 << " Segment: \n";
+    msg2 << "   " << segment.first.x << " " << segment.first.y << " \n";
+    msg2 << "   " << segment.second.x << " " << segment.second.y << " \n";
+    IFCImporter::LogInfo(msg2.str().c_str());
+}
+
+std::vector<std::vector<IfcVector2>> GetContoursInPlane3D(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
+    IfcFloat planeOffset) {
+
+        {
+            std::stringstream msg;
+            msg << "GetContoursInPlane3D: planeSpace is \n";
+            msg << planeSpace.a1 << " " << planeSpace.a2 << " " << planeSpace.a3 << " " << "\n";
+            msg << planeSpace.b1 << " " << planeSpace.b2 << " " << planeSpace.b3 << " " << "\n";
+            msg << planeSpace.c1 << " " << planeSpace.c2 << " " << planeSpace.c3 << " " << "\n";
+            msg << "\n planeOffset is " << planeOffset;
+            IFCImporter::LogInfo(msg.str().c_str());
+        }
+
+        // we'll put our line segments in here, and then merge them together into contours later
+        std::deque<std::pair<IfcVector2,IfcVector2>> lineSegments;
+
+        // find the lines giving the intersection of the faces with the plane - we'll work in planeSpace throughout.
+        size_t vI0{ 0 }; // vertex index for first vertex in plane
+        for(auto nVertices : mesh->mVertcnt) { // iterate over faces
+            {
+                std::stringstream msg;
+                msg << "GetContoursInPlane3D: face (transformed) is  \n";
+                for(auto vI = vI0; vI < vI0 + nVertices; vI++) {
+                    auto v = planeSpace * mesh->mVerts[vI];
+                    msg << "   " << v.x << " " << v.y << " " << v.z << " " << "\n";
+                }
+                IFCImporter::LogInfo(msg.str().c_str());
+            }
+
+            if(nVertices <= 2) // not a plane, a point or line
+            {
+                std::stringstream msg;
+                msg << "GetContoursInPlane3D: found point or line when expecting plane (only " << nVertices << " vertices)";
+                IFCImporter::LogWarn(msg.str().c_str());
+                vI0 += nVertices;
+                continue;
+            }
+
+            auto v0 = planeSpace * mesh->mVerts[vI0];
+
+            // now calculate intersections between face and plane
+            IfcVector2 firstPoint;
+            bool gotFirstPoint(false);
+
+            if(std::fabs(v0.z - planeOffset) < close) {
+                // first point is on the plane
+                firstPoint.x = v0.x;
+                firstPoint.y = v0.y;
+                gotFirstPoint = true;
+            }
+
+            auto vn = v0;
+            for(auto vI = vI0 + 1; vI < vI0 + nVertices; vI++) {
+                auto vp = vn;
+                vn = planeSpace * mesh->mVerts[vI];
+                IfcVector3 intersection;
+
+                if(std::fabs(vn.z - planeOffset) < close) {
+                    // on the plane
+                    intersection = vn;
+                }
+                else if((vn.z > planeOffset) != (vp.z > planeOffset))
+                {
+                    // passes through the plane
+                    auto vdir = vn - vp;
+                    auto scale = (planeOffset - vp.z) / vdir.z;
+                    intersection = vp + scale * vdir;
+                }
+                else {
+                    // nowhere near - move on
+                    continue;
+                }
+
+                if(!gotFirstPoint) {
+                    if(std::fabs(vp.z - planeOffset) < close) {
+                        // just had a second line along the plane
+                        firstPoint.x = vp.x;
+                        firstPoint.y = vp.y;
+                        IfcVector2 secondPoint(intersection.x,intersection.y);
+                        auto s = std::pair<IfcVector2,IfcVector2>(firstPoint,secondPoint);
+                        logSegment(s);
+                        lineSegments.push_back(s);
+                        // next firstpoint should be this one
+                    }
+                    else {
+                        // store the first intersection point
+                        firstPoint.x = intersection.x;
+                        firstPoint.y = intersection.y;
+                        gotFirstPoint = true;
+                    }
+                }
+                else {
+                    // now got the second point, so store the pair
+                    IfcVector2 secondPoint(intersection.x,intersection.y);
+                    auto s = std::pair<IfcVector2,IfcVector2>(firstPoint,secondPoint);
+                    logSegment(s);
+                    lineSegments.push_back(s);
+
+                    // - note that we don't move onto the next face as a non-convex face can create two or more intersections with a plane
+                    gotFirstPoint = false;
+                }
+            }
+            if(gotFirstPoint) {
+                IFCImporter::LogWarn("GetContoursInPlane3D: odd number of intersections with plane");
+            }
+            vI0 += nVertices;
+        }
+
+        {
+            std::stringstream msg;
+            msg << "GetContoursInPlane3D: found " << lineSegments.size() << " line segments:\n";
+            IFCImporter::LogInfo(msg.str().c_str());
+
+            for(auto& s : lineSegments) {
+                logSegment(s);
+            }
+
+        }
+
+        // now merge contours until we have the best-looking polygons we can
+        std::vector<Contour> contours;
+        while(!lineSegments.empty()) {
+            // start with a polygon and make the best closed contour we can
+            const auto& firstSeg = lineSegments.front();
+            std::deque<IfcVector2> contour{ firstSeg.first, firstSeg.second };
+            lineSegments.pop_front();
+            bool foundNextPoint{ true };
+            bool closedContour{ false };
+            while(foundNextPoint) {
+                foundNextPoint = false;
+                for(auto nextSeg = lineSegments.begin(); nextSeg != lineSegments.end(); nextSeg++) {
+                    // see if we can match up both ends - in which case we've closed the contour
+                    if((isClose(contour.front(),nextSeg->first) && isClose(contour.back(),nextSeg->second)) ||
+                        (isClose(contour.back(),nextSeg->first) && isClose(contour.front(),nextSeg->second))
+                        ) {
+                        lineSegments.erase(nextSeg);
+                        closedContour = true;
+                        break;
+                    }
+
+                    // otherwise, see if we can match up either end
+                    foundNextPoint = true;
+                    if(isClose(contour.front(),nextSeg->first)) {
+                        contour.push_front(nextSeg->second);
+                    }
+                    else if(isClose(contour.front(),nextSeg->second)) {
+                        contour.push_front(nextSeg->first);
+                    }
+                    else if(isClose(contour.back(),nextSeg->first)) {
+                        contour.push_back(nextSeg->second);
+                    }
+                    else if(isClose(contour.back(),nextSeg->second)) {
+                        contour.push_back(nextSeg->first);
+                    }
+                    else {
+                        foundNextPoint = false;
+                    }
+                    if(foundNextPoint) {
+                        lineSegments.erase(nextSeg);
+                        break;
+                    }
+                }
+            }
+
+            if(!closedContour) {
+                IFCImporter::LogWarn("GetContoursInPlane3D: did not close contour");
+            }
+
+            // now add the contour if we can
+            if(contour.size() <= 2) {
+                IFCImporter::LogWarn("GetContoursInPlane3D: discarding line/point contour");
+                continue;
+            }
+            Contour c{};
+            for(auto p : contour)
+            {
+                c.push_back(p);
+            }
+            contours.push_back(c);
+        }
+
+        {
+            std::stringstream msg;
+            msg << "GetContoursInPlane3D: found " << contours.size() << " contours:\n";
+
+            for(auto c : contours) {
+                msg << " Contour: \n";
+                for(auto p : c) {
+                    msg << "   " << p.x << " " << p.y << " \n";
+                }
+            }
+
+            IFCImporter::LogInfo(msg.str().c_str());
+        }
+
+
+        return contours;
+}
+
+std::vector<std::vector<IfcVector2>> GetContoursInPlane(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
+    IfcVector3 planeNor,IfcFloat planeOffset,
+    IfcVector3 extrusionDir,IfcVector3& wall_extrusion,bool& first) {
+
+    if(mesh->mVertcnt.size() == 1)
+    {
+        bool ok;
+        auto contour = GetContourInPlane2D(mesh,planeSpace,planeNor,planeOffset,extrusionDir,wall_extrusion,first,ok);
+        if(ok)
+            return std::vector<std::vector<IfcVector2>> {contour};
+        else
+            return std::vector<std::vector<IfcVector2>> {};
+    }
+    else
+    {
+        return GetContoursInPlane3D(mesh,planeSpace,planeOffset);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,
+    TempMesh& curmesh)
+{
+    IFCImporter::LogWarn("forced to use poly2tri fallback method to generate wall openings");
+    std::vector<IfcVector3>& out = curmesh.mVerts;
+
+    bool result = false;
+
+    // Try to derive a solid base plane within the current surface for use as
+    // working coordinate system.
+    bool ok;
+    IfcVector3 nor;
+    const IfcMatrix3 m = DerivePlaneCoordinateSpace(curmesh, ok, nor);
+    if (!ok) {
+        return false;
+    }
+
+    const IfcMatrix3 minv = IfcMatrix3(m).Inverse();
+
+
+    IfcFloat coord = -1;
+
+    std::vector<IfcVector2> contour_flat;
+    contour_flat.reserve(out.size());
+
+    IfcVector2 vmin, vmax;
+    MinMaxChooser<IfcVector2>()(vmin, vmax);
+
+    // Move all points into the new coordinate system, collecting min/max verts on the way
+    for(IfcVector3& x : out) {
+        const IfcVector3 vv = m * x;
+
+        // keep Z offset in the plane coordinate system. Ignoring precision issues
+        // (which  are present, of course), this should be the same value for
+        // all polygon vertices (assuming the polygon is planar).
+
+
+        // XXX this should be guarded, but we somehow need to pick a suitable
+        // epsilon
+        // if(coord != -1.0f) {
+        //  assert(std::fabs(coord - vv.z) < 1e-3f);
+        // }
+
+        coord = vv.z;
+
+        vmin = std::min(IfcVector2(vv.x, vv.y), vmin);
+        vmax = std::max(IfcVector2(vv.x, vv.y), vmax);
+
+        contour_flat.push_back(IfcVector2(vv.x,vv.y));
+    }
+
+    // With the current code in DerivePlaneCoordinateSpace,
+    // vmin,vmax should always be the 0...1 rectangle (+- numeric inaccuracies)
+    // but here we won't rely on this.
+
+    vmax -= vmin;
+
+    // If this happens then the projection must have been wrong.
+    ai_assert(vmax.Length());
+
+    ClipperLib::ExPolygons clipped;
+    ClipperLib::Polygons holes_union;
+
+
+    IfcVector3 wall_extrusion;
+    bool first = true;
+
+    try {
+
+        ClipperLib::Clipper clipper_holes;
+
+        for(const TempOpening& t : openings) {
+            auto contours = GetContoursInPlane(t.profileMesh,m,nor,coord,t.extrusionDir,wall_extrusion,first);
+
+            for(auto& contour : contours) {
+                // scale to clipping space
+                ClipperLib::Polygon hole;
+                for(IfcVector2& pip : contour) {
+                    pip.x = (pip.x - vmin.x) / vmax.x;
+                    pip.y = (pip.y - vmin.y) / vmax.y;
+
+                    hole.push_back(ClipperLib::IntPoint(to_int64(pip.x),to_int64(pip.y)));
+                }
+
+                if(!ClipperLib::Orientation(hole)) {
+                    std::reverse(hole.begin(),hole.end());
+                    //  assert(ClipperLib::Orientation(hole));
+                }
+
+                /*ClipperLib::Polygons pol_temp(1), pol_temp2(1);
+                pol_temp[0] = hole;
+
+                ClipperLib::OffsetPolygons(pol_temp,pol_temp2,5.0);
+                hole = pol_temp2[0];*/
+
+                clipper_holes.AddPolygon(hole,ClipperLib::ptSubject);
+                {
+                    std::stringstream msg;
+                    msg << "- added polygon ";
+                    for(auto elem : hole) {
+                        msg << " (" << elem.X << ", " << elem.Y << ")";
+                    }
+                    IFCImporter::LogDebug(msg.str().c_str());
+                }
+            }
+        }
+
+        clipper_holes.Execute(ClipperLib::ctUnion,holes_union,
+            ClipperLib::pftNonZero,
+            ClipperLib::pftNonZero);
+
+        if (holes_union.empty()) {
+            return false;
+        }
+
+        // Now that we have the big union of all holes, subtract it from the outer contour
+        // to obtain the final polygon to feed into the triangulator.
+        {
+            ClipperLib::Polygon poly;
+            for(IfcVector2& pip : contour_flat) {
+                pip.x  = (pip.x - vmin.x) / vmax.x;
+                pip.y  = (pip.y - vmin.y) / vmax.y;
+
+                poly.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) ));
+            }
+
+            if (ClipperLib::Orientation(poly)) {
+                std::reverse(poly.begin(), poly.end());
+            }
+            clipper_holes.Clear();
+            clipper_holes.AddPolygon(poly,ClipperLib::ptSubject);
+
+            clipper_holes.AddPolygons(holes_union,ClipperLib::ptClip);
+            clipper_holes.Execute(ClipperLib::ctDifference,clipped,
+                ClipperLib::pftNonZero,
+                ClipperLib::pftNonZero);
+        }
+
+    }
+    catch (const char* sx) {
+        IFCImporter::LogError("Ifc: error during polygon clipping, skipping openings for this face: (Clipper: "
+            + std::string(sx) + ")");
+
+        return false;
+    }
+
+    std::vector<IfcVector3> old_verts;
+    std::vector<unsigned int> old_vertcnt;
+
+    old_verts.swap(curmesh.mVerts);
+    old_vertcnt.swap(curmesh.mVertcnt);
+
+    std::vector< std::vector<p2t::Point*> > contours;
+    for(ClipperLib::ExPolygon& clip : clipped) {
+
+        contours.clear();
+
+        // Build the outer polygon contour line for feeding into poly2tri
+        std::vector<p2t::Point*> contour_points;
+        for(ClipperLib::IntPoint& point : clip.outer) {
+            contour_points.push_back( new p2t::Point(from_int64(point.X), from_int64(point.Y)) );
+        }
+
+        p2t::CDT* cdt ;
+        try {
+            // Note: this relies on custom modifications in poly2tri to raise runtime_error's
+            // instead if assertions. These failures are not debug only, they can actually
+            // happen in production use if the input data is broken. An assertion would be
+            // inappropriate.
+            cdt = new p2t::CDT(contour_points);
+        }
+        catch(const std::exception& e) {
+            IFCImporter::LogError("Ifc: error during polygon triangulation, skipping some openings: (poly2tri: "
+                + std::string(e.what()) + ")");
+            continue;
+        }
+
+
+        // Build the poly2tri inner contours for all holes we got from ClipperLib
+        for(ClipperLib::Polygon& opening : clip.holes) {
+
+            contours.push_back(std::vector<p2t::Point*>());
+            std::vector<p2t::Point*>& contour = contours.back();
+
+            for(ClipperLib::IntPoint& point : opening) {
+                contour.push_back( new p2t::Point(from_int64(point.X), from_int64(point.Y)) );
+            }
+
+            cdt->AddHole(contour);
+        }
+
+        try {
+            // Note: See above
+            cdt->Triangulate();
+        }
+        catch(const std::exception& e) {
+            IFCImporter::LogError("Ifc: error during polygon triangulation, skipping some openings: (poly2tri: "
+                + std::string(e.what()) + ")");
+            continue;
+        }
+
+        const std::vector<p2t::Triangle*> tris = cdt->GetTriangles();
+
+        // Collect the triangles we just produced
+        for(p2t::Triangle* tri : tris) {
+            for(int i = 0; i < 3; ++i) {
+
+                const IfcVector2 v = IfcVector2(
+                    static_cast<IfcFloat>( tri->GetPoint(i)->x ),
+                    static_cast<IfcFloat>( tri->GetPoint(i)->y )
+                );
+
+                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.mVerts.push_back(v3);
+            }
+            curmesh.mVertcnt.push_back(3);
+        }
+
+        result = true;
+    }
+
+    if (!result) {
+        // revert -- it's a shame, but better than nothing
+        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");
+    }
+
+    return result;
+}
+
+
+    } // ! IFC
+} // ! Assimp
+
+#undef to_int64
+#undef from_int64
+#undef one_vec
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCProfile.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCProfile.cpp
new file mode 100644
index 0000000..aa31124
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCProfile.cpp
@@ -0,0 +1,190 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCProfile.cpp
+ *  @brief Read profile and curves entities from IFC files
+ */
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "IFCUtil.h"
+
+namespace Assimp {
+namespace IFC {
+
+// ------------------------------------------------------------------------------------------------
+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 Schema_2x3::IfcCartesianPoint& cp : def.Points) {
+        ConvertCartesianPoint(t,cp);
+        meshout.mVerts.push_back(t);
+    }
+    meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
+}
+
+// ------------------------------------------------------------------------------------------------
+bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv)
+{
+    std::unique_ptr<const Curve> cv(Curve::Convert(curve,conv));
+    if (!cv) {
+        IFCImporter::LogWarn("skipping unknown IfcCurve entity, type is ", curve.GetClassName());
+        return false;
+    }
+
+    // we must have a bounded curve at this point
+    if (const BoundedCurve* bc = dynamic_cast<const BoundedCurve*>(cv.get())) {
+        try {
+            bc->SampleDiscrete(meshout);
+        }
+        catch(const  CurveError& cv) {
+            IFCImporter::LogError(cv.mStr, " (error occurred while processing curve)");
+            return false;
+        }
+        meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
+        return true;
+    }
+
+    IFCImporter::LogError("cannot use unbounded curve as profile");
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessClosedProfile(const Schema_2x3::IfcArbitraryClosedProfileDef& def, TempMesh& meshout, ConversionData& conv)
+{
+    ProcessCurve(def.OuterCurve,meshout,conv);
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessOpenProfile(const Schema_2x3::IfcArbitraryOpenProfileDef& def, TempMesh& meshout, ConversionData& conv)
+{
+    ProcessCurve(def.Curve,meshout,conv);
+}
+
+// ------------------------------------------------------------------------------------------------
+void ProcessParametrizedProfile(const Schema_2x3::IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& conv)
+{
+    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.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 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.mVerts.reserve(segments);
+
+        IfcFloat angle = 0.f;
+        for(size_t i = 0; i < segments; ++i, angle += delta) {
+            meshout.mVerts.push_back( IfcVector3( std::cos(angle)*radius, std::sin(angle)*radius, 0.f ));
+        }
+
+        meshout.mVertcnt.push_back(static_cast<unsigned int>(segments));
+    }
+    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.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());
+        return;
+    }
+
+    IfcMatrix4 trafo;
+    ConvertAxisPlacement(trafo, *def.Position);
+    meshout.Transform(trafo);
+}
+
+// ------------------------------------------------------------------------------------------------
+bool ProcessProfile(const Schema_2x3::IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv)
+{
+    if(const Schema_2x3::IfcArbitraryClosedProfileDef* const cprofile = prof.ToPtr<Schema_2x3::IfcArbitraryClosedProfileDef>()) {
+        ProcessClosedProfile(*cprofile,meshout,conv);
+    }
+    else if(const Schema_2x3::IfcArbitraryOpenProfileDef* const copen = prof.ToPtr<Schema_2x3::IfcArbitraryOpenProfileDef>()) {
+        ProcessOpenProfile(*copen,meshout,conv);
+    }
+    else if(const Schema_2x3::IfcParameterizedProfileDef* const cparam = prof.ToPtr<Schema_2x3::IfcParameterizedProfileDef>()) {
+        ProcessParametrizedProfile(*cparam,meshout,conv);
+    }
+    else {
+        IFCImporter::LogWarn("skipping unknown IfcProfileDef entity, type is ", prof.GetClassName());
+        return false;
+    }
+    meshout.RemoveAdjacentDuplicates();
+    if (!meshout.mVertcnt.size() || meshout.mVertcnt.front() <= 1) {
+        return false;
+    }
+    return true;
+}
+
+} // ! IFC
+} // ! Assimp
+
+#endif // ASSIMP_BUILD_NO_IFC_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
new file mode 100644
index 0000000..a6f7ae3
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
@@ -0,0 +1,3177 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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_2x3.h"
+
+#if _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4702)
+#endif // _MSC_VER
+
+namespace Assimp {
+
+using namespace ::Assimp::IFC;
+using namespace ::Assimp::IFC::Schema_2x3;
+
+namespace {
+	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
+
+    static const SchemaEntry schema_raw_2x3[] =  {
+		SchemaEntry("ifcstairtypeenum",nullptr )
+,		SchemaEntry("ifcspacetypeenum",nullptr )
+,		SchemaEntry("ifcwalltypeenum",nullptr )
+,		SchemaEntry("ifcmonthinyearnumber",nullptr )
+,		SchemaEntry("ifcheatfluxdensitymeasure",nullptr )
+,		SchemaEntry("ifckinematicviscositymeasure",nullptr )
+,		SchemaEntry("ifcsequenceenum",nullptr )
+,		SchemaEntry("ifcairtoairheatrecoverytypeenum",nullptr )
+,		SchemaEntry("ifcactorselect",nullptr )
+,		SchemaEntry("ifctransformertypeenum",nullptr )
+,		SchemaEntry("ifcunitaryequipmenttypeenum",nullptr )
+,		SchemaEntry("ifcelectricflowstoragedevicetypeenum",nullptr )
+,		SchemaEntry("ifcenergysequenceenum",nullptr )
+,		SchemaEntry("ifcworkcontroltypeenum",nullptr )
+,		SchemaEntry("ifccurvaturemeasure",nullptr )
+,		SchemaEntry("ifcparametervalue",nullptr )
+,		SchemaEntry("ifcappliedvalueselect",nullptr )
+,		SchemaEntry("ifcwarpingconstantmeasure",nullptr )
+,		SchemaEntry("ifcarithmeticoperatorenum",nullptr )
+,		SchemaEntry("ifclinearforcemeasure",nullptr )
+,		SchemaEntry("ifcwindowpanelpositionenum",nullptr )
+,		SchemaEntry("ifcflowmetertypeenum",nullptr )
+,		SchemaEntry("ifcrampflighttypeenum",nullptr )
+,		SchemaEntry("ifcspecularhighlightselect",nullptr )
+,		SchemaEntry("ifcactiontypeenum",nullptr )
+,		SchemaEntry("ifcgeometricprojectionenum",nullptr )
+,		SchemaEntry("ifctimeseriesdatatypeenum",nullptr )
+,		SchemaEntry("ifcmagneticfluxmeasure",nullptr )
+,		SchemaEntry("ifcobjecttypeenum",nullptr )
+,		SchemaEntry("ifcdataoriginenum",nullptr )
+,		SchemaEntry("ifcmassdensitymeasure",nullptr )
+,		SchemaEntry("ifclightfixturetypeenum",nullptr )
+,		SchemaEntry("ifcservicelifetypeenum",nullptr )
+,		SchemaEntry("ifcelectricvoltagemeasure",nullptr )
+,		SchemaEntry("ifcheatingvaluemeasure",nullptr )
+,		SchemaEntry("ifcpresentabletext",nullptr )
+,		SchemaEntry("ifcaheadorbehind",nullptr )
+,		SchemaEntry("ifcsimplevalue",nullptr )
+,		SchemaEntry("ifcsensortypeenum",nullptr )
+,		SchemaEntry("ifcderivedunitenum",nullptr )
+,		SchemaEntry("ifcsizeselect",nullptr )
+,		SchemaEntry("ifctransportelementtypeenum",nullptr )
+,		SchemaEntry("ifcinventorytypeenum",nullptr )
+,		SchemaEntry("ifctextdecoration",nullptr )
+,		SchemaEntry("ifcdirectionsenseenum",nullptr )
+,		SchemaEntry("ifcductfittingtypeenum",nullptr )
+,		SchemaEntry("ifcdocumentstatusenum",nullptr )
+,		SchemaEntry("ifcslabtypeenum",nullptr )
+,		SchemaEntry("ifcdoorstyleconstructionenum",nullptr )
+,		SchemaEntry("ifcvolumemeasure",nullptr )
+,		SchemaEntry("ifcinductancemeasure",nullptr )
+,		SchemaEntry("ifccurtainwalltypeenum",nullptr )
+,		SchemaEntry("ifcsiunitname",nullptr )
+,		SchemaEntry("ifcspecularexponent",nullptr )
+,		SchemaEntry("ifcsoundpressuremeasure",nullptr )
+,		SchemaEntry("ifcanalysistheorytypeenum",nullptr )
+,		SchemaEntry("ifcgasterminaltypeenum",nullptr )
+,		SchemaEntry("ifcyearnumber",nullptr )
+,		SchemaEntry("ifcmodulusofelasticitymeasure",nullptr )
+,		SchemaEntry("ifcchangeactionenum",nullptr )
+,		SchemaEntry("ifcdampertypeenum",nullptr )
+,		SchemaEntry("ifcevaporatortypeenum",nullptr )
+,		SchemaEntry("ifcionconcentrationmeasure",nullptr )
+,		SchemaEntry("ifcductsegmenttypeenum",nullptr )
+,		SchemaEntry("ifcprotectivedevicetypeenum",nullptr )
+,		SchemaEntry("ifcabsorbeddosemeasure",nullptr )
+,		SchemaEntry("ifcmassperlengthmeasure",nullptr )
+,		SchemaEntry("ifctextfontname",nullptr )
+,		SchemaEntry("ifcorientationselect",nullptr )
+,		SchemaEntry("ifcilluminancemeasure",nullptr )
+,		SchemaEntry("ifcfiresuppressionterminaltypeenum",nullptr )
+,		SchemaEntry("ifcfontstyle",nullptr )
+,		SchemaEntry("ifcmomentofinertiameasure",nullptr )
+,		SchemaEntry("ifcmodulusofsubgradereactionmeasure",nullptr )
+,		SchemaEntry("ifccomplexnumber",nullptr )
+,		SchemaEntry("ifchumidifiertypeenum",nullptr )
+,		SchemaEntry("ifcpresentationstyleselect",nullptr )
+,		SchemaEntry("ifcthermaltransmittancemeasure",nullptr )
+,		SchemaEntry("ifcribplatedirectionenum",nullptr )
+,		SchemaEntry("ifcclassificationnotationselect",nullptr )
+,		SchemaEntry("ifcminuteinhour",nullptr )
+,		SchemaEntry("ifcinternalorexternalenum",nullptr )
+,		SchemaEntry("ifcrotationalfrequencymeasure",nullptr )
+,		SchemaEntry("ifcsanitaryterminaltypeenum",nullptr )
+,		SchemaEntry("ifcsymbolstyleselect",nullptr )
+,		SchemaEntry("ifcelementcompositionenum",nullptr )
+,		SchemaEntry("ifctextpath",nullptr )
+,		SchemaEntry("ifcpowermeasure",nullptr )
+,		SchemaEntry("ifcsurfacestyleelementselect",nullptr )
+,		SchemaEntry("ifcresourceconsumptionenum",nullptr )
+,		SchemaEntry("ifcelectriccapacitancemeasure",nullptr )
+,		SchemaEntry("ifclayersetdirectionenum",nullptr )
+,		SchemaEntry("ifcrailingtypeenum",nullptr )
+,		SchemaEntry("ifcobjectiveenum",nullptr )
+,		SchemaEntry("ifcdocumentselect",nullptr )
+,		SchemaEntry("ifcmodulusoflinearsubgradereactionmeasure",nullptr )
+,		SchemaEntry("ifcthermaladmittancemeasure",nullptr )
+,		SchemaEntry("ifctransitioncode",nullptr )
+,		SchemaEntry("ifcconnectiontypeenum",nullptr )
+,		SchemaEntry("ifcmonetarymeasure",nullptr )
+,		SchemaEntry("ifcstackterminaltypeenum",nullptr )
+,		SchemaEntry("ifccolour",nullptr )
+,		SchemaEntry("ifctext",nullptr )
+,		SchemaEntry("ifccontextdependentmeasure",nullptr )
+,		SchemaEntry("ifcthermalconductivitymeasure",nullptr )
+,		SchemaEntry("ifcprojectedortruelengthenum",nullptr )
+,		SchemaEntry("ifcpressuremeasure",nullptr )
+,		SchemaEntry("ifcmoisturediffusivitymeasure",nullptr )
+,		SchemaEntry("ifcbooleanoperator",nullptr )
+,		SchemaEntry("ifcpropertysourceenum",nullptr )
+,		SchemaEntry("ifctimestamp",nullptr )
+,		SchemaEntry("ifcmaterialselect",nullptr )
+,		SchemaEntry("ifcgloballyuniqueid",nullptr )
+,		SchemaEntry("ifcreflectancemethodenum",nullptr )
+,		SchemaEntry("ifcvaporpermeabilitymeasure",nullptr )
+,		SchemaEntry("ifctimeseriesscheduletypeenum",nullptr )
+,		SchemaEntry("ifclinearmomentmeasure",nullptr )
+,		SchemaEntry("ifcgeometricsetselect",nullptr )
+,		SchemaEntry("ifcsectionmodulusmeasure",nullptr )
+,		SchemaEntry("ifcbsplinecurveform",nullptr )
+,		SchemaEntry("ifcdimensionextentusage",nullptr )
+,		SchemaEntry("ifcthermalexpansioncoefficientmeasure",nullptr )
+,		SchemaEntry("ifchourinday",nullptr )
+,		SchemaEntry("ifclinearvelocitymeasure",nullptr )
+,		SchemaEntry("ifctorquemeasure",nullptr )
+,		SchemaEntry("ifctemperaturegradientmeasure",nullptr )
+,		SchemaEntry("ifcfillstyleselect",nullptr )
+,		SchemaEntry("ifcelectricchargemeasure",nullptr )
+,		SchemaEntry("ifcheatexchangertypeenum",nullptr )
+,		SchemaEntry("ifcelectriccurrentenum",nullptr )
+,		SchemaEntry("ifcdaylightsavinghour",nullptr )
+,		SchemaEntry("ifcshell",nullptr )
+,		SchemaEntry("ifcdoseequivalentmeasure",nullptr )
+,		SchemaEntry("ifcprojectordertypeenum",nullptr )
+,		SchemaEntry("ifcderivedmeasurevalue",nullptr )
+,		SchemaEntry("ifclightdistributioncurveenum",nullptr )
+,		SchemaEntry("ifcwarpingmomentmeasure",nullptr )
+,		SchemaEntry("ifcmembertypeenum",nullptr )
+,		SchemaEntry("ifcsoundpowermeasure",nullptr )
+,		SchemaEntry("ifctextalignment",nullptr )
+,		SchemaEntry("ifccurveoredgecurve",nullptr )
+,		SchemaEntry("ifcmassflowratemeasure",nullptr )
+,		SchemaEntry("ifcisothermalmoisturecapacitymeasure",nullptr )
+,		SchemaEntry("ifccsgselect",nullptr )
+,		SchemaEntry("ifccoolingtowertypeenum",nullptr )
+,		SchemaEntry("ifcmassmeasure",nullptr )
+,		SchemaEntry("ifcpileconstructionenum",nullptr )
+,		SchemaEntry("ifcdoorstyleoperationenum",nullptr )
+,		SchemaEntry("ifcflowdirectionenum",nullptr )
+,		SchemaEntry("ifcthermalloadsourceenum",nullptr )
+,		SchemaEntry("ifclengthmeasure",nullptr )
+,		SchemaEntry("ifcconstraintenum",nullptr )
+,		SchemaEntry("ifcaxis2placement",nullptr )
+,		SchemaEntry("ifcloadgrouptypeenum",nullptr )
+,		SchemaEntry("ifcvalue",nullptr )
+,		SchemaEntry("ifcreinforcingbarsurfaceenum",nullptr )
+,		SchemaEntry("ifcprojectorderrecordtypeenum",nullptr )
+,		SchemaEntry("ifcdatetimeselect",nullptr )
+,		SchemaEntry("ifcstructuralsurfacetypeenum",nullptr )
+,		SchemaEntry("ifcpermeablecoveringoperationenum",nullptr )
+,		SchemaEntry("ifcfontweight",nullptr )
+,		SchemaEntry("ifcphmeasure",nullptr )
+,		SchemaEntry("ifcdescriptivemeasure",nullptr )
+,		SchemaEntry("ifccurvestylefontselect",nullptr )
+,		SchemaEntry("ifcunit",nullptr )
+,		SchemaEntry("ifchatchlinedistanceselect",nullptr )
+,		SchemaEntry("ifctextstyleselect",nullptr )
+,		SchemaEntry("ifcmetricvalueselect",nullptr )
+,		SchemaEntry("ifcvectorordirection",nullptr )
+,		SchemaEntry("ifcassemblyplaceenum",nullptr )
+,		SchemaEntry("ifcairterminaltypeenum",nullptr )
+,		SchemaEntry("ifccoveringtypeenum",nullptr )
+,		SchemaEntry("ifcplanarforcemeasure",nullptr )
+,		SchemaEntry("ifcvalvetypeenum",nullptr )
+,		SchemaEntry("ifcalarmtypeenum",nullptr )
+,		SchemaEntry("ifcdynamicviscositymeasure",nullptr )
+,		SchemaEntry("ifccurrencyenum",nullptr )
+,		SchemaEntry("ifcmodulusofrotationalsubgradereactionmeasure",nullptr )
+,		SchemaEntry("ifccablecarrierfittingtypeenum",nullptr )
+,		SchemaEntry("ifcboolean",nullptr )
+,		SchemaEntry("ifcactionsourcetypeenum",nullptr )
+,		SchemaEntry("ifcstructuralactivityassignmentselect",nullptr )
+,		SchemaEntry("ifcdistributionchamberelementtypeenum",nullptr )
+,		SchemaEntry("ifcevaporativecoolertypeenum",nullptr )
+,		SchemaEntry("ifcmagneticfluxdensitymeasure",nullptr )
+,		SchemaEntry("ifclightdistributiondatasourceselect",nullptr )
+,		SchemaEntry("ifctubebundletypeenum",nullptr )
+,		SchemaEntry("ifcaccelerationmeasure",nullptr )
+,		SchemaEntry("ifcboilertypeenum",nullptr )
+,		SchemaEntry("ifcramptypeenum",nullptr )
+,		SchemaEntry("ifcluminousintensitydistributionmeasure",nullptr )
+,		SchemaEntry("ifctrimmingpreference",nullptr )
+,		SchemaEntry("ifcspecificheatcapacitymeasure",nullptr )
+,		SchemaEntry("ifcamountofsubstancemeasure",nullptr )
+,		SchemaEntry("ifcroleenum",nullptr )
+,		SchemaEntry("ifcdocumentconfidentialityenum",nullptr )
+,		SchemaEntry("ifcfrequencymeasure",nullptr )
+,		SchemaEntry("ifcsectiontypeenum",nullptr )
+,		SchemaEntry("ifcelementassemblytypeenum",nullptr )
+,		SchemaEntry("ifcfootingtypeenum",nullptr )
+,		SchemaEntry("ifclayereditem",nullptr )
+,		SchemaEntry("ifccablesegmenttypeenum",nullptr )
+,		SchemaEntry("ifcdefinedsymbolselect",nullptr )
+,		SchemaEntry("ifcbuildingelementproxytypeenum",nullptr )
+,		SchemaEntry("ifcelectricgeneratortypeenum",nullptr )
+,		SchemaEntry("ifcrotationalstiffnessmeasure",nullptr )
+,		SchemaEntry("ifcspaceheatertypeenum",nullptr )
+,		SchemaEntry("ifcareameasure",nullptr )
+,		SchemaEntry("ifclabel",nullptr )
+,		SchemaEntry("ifccostscheduletypeenum",nullptr )
+,		SchemaEntry("ifcswitchingdevicetypeenum",nullptr )
+,		SchemaEntry("ifcelectrictimecontroltypeenum",nullptr )
+,		SchemaEntry("ifcfiltertypeenum",nullptr )
+,		SchemaEntry("ifcpositivelengthmeasure",nullptr )
+,		SchemaEntry("ifcnullstyle",nullptr )
+,		SchemaEntry("ifcconditioncriterionselect",nullptr )
+,		SchemaEntry("ifcshearmodulusmeasure",nullptr )
+,		SchemaEntry("ifcnormalisedratiomeasure",nullptr )
+,		SchemaEntry("ifcdoorpaneloperationenum",nullptr )
+,		SchemaEntry("ifcpointorvertexpoint",nullptr )
+,		SchemaEntry("ifcrooftypeenum",nullptr )
+,		SchemaEntry("ifccountmeasure",nullptr )
+,		SchemaEntry("ifcelectricconductancemeasure",nullptr )
+,		SchemaEntry("ifcproceduretypeenum",nullptr )
+,		SchemaEntry("ifcflowinstrumenttypeenum",nullptr )
+,		SchemaEntry("ifcelectricmotortypeenum",nullptr )
+,		SchemaEntry("ifcsurfaceside",nullptr )
+,		SchemaEntry("ifcstructuralcurvetypeenum",nullptr )
+,		SchemaEntry("ifccondensertypeenum",nullptr )
+,		SchemaEntry("ifclinearstiffnessmeasure",nullptr )
+,		SchemaEntry("ifcunitenum",nullptr )
+,		SchemaEntry("ifcoccupanttypeenum",nullptr )
+,		SchemaEntry("ifcthermalloadtypeenum",nullptr )
+,		SchemaEntry("ifcreinforcingbarroleenum",nullptr )
+,		SchemaEntry("ifcbenchmarkenum",nullptr )
+,		SchemaEntry("ifcpositiveplaneanglemeasure",nullptr )
+,		SchemaEntry("ifctexttransformation",nullptr )
+,		SchemaEntry("ifcdraughtingcalloutelement",nullptr )
+,		SchemaEntry("ifcratiomeasure",nullptr )
+,		SchemaEntry("ifcsolidanglemeasure",nullptr )
+,		SchemaEntry("ifcpipesegmenttypeenum",nullptr )
+,		SchemaEntry("ifccablecarriersegmenttypeenum",nullptr )
+,		SchemaEntry("ifccolourorfactor",nullptr )
+,		SchemaEntry("ifcidentifier",nullptr )
+,		SchemaEntry("ifctendontypeenum",nullptr )
+,		SchemaEntry("ifccontrollertypeenum",nullptr )
+,		SchemaEntry("ifcradioactivitymeasure",nullptr )
+,		SchemaEntry("ifctimemeasure",nullptr )
+,		SchemaEntry("ifcpumptypeenum",nullptr )
+,		SchemaEntry("ifcelectricheatertypeenum",nullptr )
+,		SchemaEntry("ifcbeamtypeenum",nullptr )
+,		SchemaEntry("ifcstateenum",nullptr )
+,		SchemaEntry("ifcsiprefix",nullptr )
+,		SchemaEntry("ifcnumericmeasure",nullptr )
+,		SchemaEntry("ifcoutlettypeenum",nullptr )
+,		SchemaEntry("ifccompoundplaneanglemeasure",nullptr )
+,		SchemaEntry("ifcservicelifefactortypeenum",nullptr )
+,		SchemaEntry("ifclogicaloperatorenum",nullptr )
+,		SchemaEntry("ifcbooleanoperand",nullptr )
+,		SchemaEntry("ifcobjectreferenceselect",nullptr )
+,		SchemaEntry("ifccooledbeamtypeenum",nullptr )
+,		SchemaEntry("ifcductsilencertypeenum",nullptr )
+,		SchemaEntry("ifcsectionalareaintegralmeasure",nullptr )
+,		SchemaEntry("ifcfontvariant",nullptr )
+,		SchemaEntry("ifcvolumetricflowratemeasure",nullptr )
+,		SchemaEntry("ifcplatetypeenum",nullptr )
+,		SchemaEntry("ifcenvironmentalimpactcategoryenum",nullptr )
+,		SchemaEntry("ifcvibrationisolatortypeenum",nullptr )
+,		SchemaEntry("ifcthermodynamictemperaturemeasure",nullptr )
+,		SchemaEntry("ifcrotationalmassmeasure",nullptr )
+,		SchemaEntry("ifcsecondinminute",nullptr )
+,		SchemaEntry("ifcdayinmonthnumber",nullptr )
+,		SchemaEntry("ifcdimensioncount",nullptr )
+,		SchemaEntry("ifcwindowstyleoperationenum",nullptr )
+,		SchemaEntry("ifcthermalresistancemeasure",nullptr )
+,		SchemaEntry("ifcmeasurevalue",nullptr )
+,		SchemaEntry("ifcwindowpaneloperationenum",nullptr )
+,		SchemaEntry("ifcchillertypeenum",nullptr )
+,		SchemaEntry("ifcpositiveratiomeasure",nullptr )
+,		SchemaEntry("ifcinteger",nullptr )
+,		SchemaEntry("ifclogical",nullptr )
+,		SchemaEntry("ifcjunctionboxtypeenum",nullptr )
+,		SchemaEntry("ifcaddresstypeenum",nullptr )
+,		SchemaEntry("ifcwasteterminaltypeenum",nullptr )
+,		SchemaEntry("ifctrimmingselect",nullptr )
+,		SchemaEntry("ifclightemissionsourceenum",nullptr )
+,		SchemaEntry("ifcsoundscaleenum",nullptr )
+,		SchemaEntry("ifcluminousfluxmeasure",nullptr )
+,		SchemaEntry("ifcelectricresistancemeasure",nullptr )
+,		SchemaEntry("ifcintegercountratemeasure",nullptr )
+,		SchemaEntry("ifcphysicalorvirtualenum",nullptr )
+,		SchemaEntry("ifcmolecularweightmeasure",nullptr )
+,		SchemaEntry("ifcprofiletypeenum",nullptr )
+,		SchemaEntry("ifcboxalignment",nullptr )
+,		SchemaEntry("ifcglobalorlocalenum",nullptr )
+,		SchemaEntry("ifcspecularroughness",nullptr )
+,		SchemaEntry("ifclamptypeenum",nullptr )
+,		SchemaEntry("ifcpiletypeenum",nullptr )
+,		SchemaEntry("ifcelectriccurrentmeasure",nullptr )
+,		SchemaEntry("ifcfantypeenum",nullptr )
+,		SchemaEntry("ifcsurfaceorfacesurface",nullptr )
+,		SchemaEntry("ifcpipefittingtypeenum",nullptr )
+,		SchemaEntry("ifctanktypeenum",nullptr )
+,		SchemaEntry("ifccurvefontorscaledcurvefontselect",nullptr )
+,		SchemaEntry("ifcwindowstyleconstructionenum",nullptr )
+,		SchemaEntry("ifcairterminalboxtypeenum",nullptr )
+,		SchemaEntry("ifcstairflighttypeenum",nullptr )
+,		SchemaEntry("ifcluminousintensitymeasure",nullptr )
+,		SchemaEntry("ifcmotorconnectiontypeenum",nullptr )
+,		SchemaEntry("ifcplaneanglemeasure",nullptr )
+,		SchemaEntry("ifcactuatortypeenum",nullptr )
+,		SchemaEntry("ifccolumntypeenum",nullptr )
+,		SchemaEntry("ifctextfontselect",nullptr )
+,		SchemaEntry("ifcdoorpanelpositionenum",nullptr )
+,		SchemaEntry("ifccoiltypeenum",nullptr )
+,		SchemaEntry("ifcangularvelocitymeasure",nullptr )
+,		SchemaEntry("ifcanalysismodeltypeenum",nullptr )
+,		SchemaEntry("ifclibraryselect",nullptr )
+,		SchemaEntry("ifcforcemeasure",nullptr )
+,		SchemaEntry("ifcfillareastyletileshapeselect",nullptr )
+,		SchemaEntry("ifcelectricappliancetypeenum",nullptr )
+,		SchemaEntry("ifcsurfacetextureenum",nullptr )
+,		SchemaEntry("ifccharacterstyleselect",nullptr )
+,		SchemaEntry("ifcenergymeasure",nullptr )
+,		SchemaEntry("ifcreal",nullptr )
+,		SchemaEntry("ifccompressortypeenum",nullptr )
+,		SchemaEntry("ifcelectricdistributionpointfunctionenum",nullptr )
+,		SchemaEntry("ifcroot",&STEP::ObjectHelper<IfcRoot,4>::Construct )
+,		SchemaEntry("ifcobjectdefinition",&STEP::ObjectHelper<IfcObjectDefinition,0>::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("ifcdistributionflowelementtype",&STEP::ObjectHelper<IfcDistributionFlowElementType,0>::Construct )
+,		SchemaEntry("ifcflowcontrollertype",&STEP::ObjectHelper<IfcFlowControllerType,0>::Construct )
+,		SchemaEntry("ifcelectrictimecontroltype",&STEP::ObjectHelper<IfcElectricTimeControlType,1>::Construct )
+,		SchemaEntry("ifcrepresentation",&STEP::ObjectHelper<IfcRepresentation,4>::Construct )
+,		SchemaEntry("ifcshapemodel",&STEP::ObjectHelper<IfcShapeModel,0>::Construct )
+,		SchemaEntry("ifctopologyrepresentation",&STEP::ObjectHelper<IfcTopologyRepresentation,0>::Construct )
+,		SchemaEntry("ifcrelationship",&STEP::ObjectHelper<IfcRelationship,0>::Construct )
+,		SchemaEntry("ifcrelconnects",&STEP::ObjectHelper<IfcRelConnects,0>::Construct )
+,		SchemaEntry("ifcrelcoversspaces",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowfittingtype",&STEP::ObjectHelper<IfcFlowFittingType,0>::Construct )
+,		SchemaEntry("ifccablecarrierfittingtype",&STEP::ObjectHelper<IfcCableCarrierFittingType,1>::Construct )
+,		SchemaEntry("ifcstructuralconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcslippageconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcenergyconversiondevicetype",&STEP::ObjectHelper<IfcEnergyConversionDeviceType,0>::Construct )
+,		SchemaEntry("ifccoiltype",&STEP::ObjectHelper<IfcCoilType,1>::Construct )
+,		SchemaEntry("ifcobject",&STEP::ObjectHelper<IfcObject,1>::Construct )
+,		SchemaEntry("ifccontrol",&STEP::ObjectHelper<IfcControl,0>::Construct )
+,		SchemaEntry("ifcperformancehistory",&STEP::ObjectHelper<IfcPerformanceHistory,1>::Construct )
+,		SchemaEntry("ifcrepresentationitem",&STEP::ObjectHelper<IfcRepresentationItem,0>::Construct )
+,		SchemaEntry("ifcgeometricrepresentationitem",&STEP::ObjectHelper<IfcGeometricRepresentationItem,0>::Construct )
+,		SchemaEntry("ifctextliteral",&STEP::ObjectHelper<IfcTextLiteral,3>::Construct )
+,		SchemaEntry("ifctextliteralwithextent",&STEP::ObjectHelper<IfcTextLiteralWithExtent,2>::Construct )
+,		SchemaEntry("ifcproductrepresentation",&STEP::ObjectHelper<IfcProductRepresentation,3>::Construct )
+,		SchemaEntry("ifcproduct",&STEP::ObjectHelper<IfcProduct,2>::Construct )
+,		SchemaEntry("ifcelement",&STEP::ObjectHelper<IfcElement,1>::Construct )
+,		SchemaEntry("ifcdistributionelement",&STEP::ObjectHelper<IfcDistributionElement,0>::Construct )
+,		SchemaEntry("ifcdistributionflowelement",&STEP::ObjectHelper<IfcDistributionFlowElement,0>::Construct )
+,		SchemaEntry("ifccurve",&STEP::ObjectHelper<IfcCurve,0>::Construct )
+,		SchemaEntry("ifcboundedcurve",&STEP::ObjectHelper<IfcBoundedCurve,0>::Construct )
+,		SchemaEntry("ifccompositecurve",&STEP::ObjectHelper<IfcCompositeCurve,2>::Construct )
+,		SchemaEntry("ifc2dcompositecurve",&STEP::ObjectHelper<Ifc2DCompositeCurve,0>::Construct )
+,		SchemaEntry("ifcboundarycondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboundaryfacecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator",&STEP::ObjectHelper<IfcCartesianTransformationOperator,4>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator3d",&STEP::ObjectHelper<IfcCartesianTransformationOperator3D,1>::Construct )
+,		SchemaEntry("ifcproperty",&STEP::ObjectHelper<IfcProperty,2>::Construct )
+,		SchemaEntry("ifcsimpleproperty",&STEP::ObjectHelper<IfcSimpleProperty,0>::Construct )
+,		SchemaEntry("ifcpropertyenumeratedvalue",&STEP::ObjectHelper<IfcPropertyEnumeratedValue,2>::Construct )
+,		SchemaEntry("ifcpresentationlayerassignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpresentationlayerwithstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcbuildingelementtype",&STEP::ObjectHelper<IfcBuildingElementType,0>::Construct )
+,		SchemaEntry("ifcstairflighttype",&STEP::ObjectHelper<IfcStairFlightType,1>::Construct )
+,		SchemaEntry("ifcsurface",&STEP::ObjectHelper<IfcSurface,0>::Construct )
+,		SchemaEntry("ifcelementarysurface",&STEP::ObjectHelper<IfcElementarySurface,1>::Construct )
+,		SchemaEntry("ifcplane",&STEP::ObjectHelper<IfcPlane,0>::Construct )
+,		SchemaEntry("ifcbooleanresult",&STEP::ObjectHelper<IfcBooleanResult,3>::Construct )
+,		SchemaEntry("ifcbooleanclippingresult",&STEP::ObjectHelper<IfcBooleanClippingResult,0>::Construct )
+,		SchemaEntry("ifcsolidmodel",&STEP::ObjectHelper<IfcSolidModel,0>::Construct )
+,		SchemaEntry("ifcmanifoldsolidbrep",&STEP::ObjectHelper<IfcManifoldSolidBrep,1>::Construct )
+,		SchemaEntry("ifcprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcgeneralprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowterminaltype",&STEP::ObjectHelper<IfcFlowTerminalType,0>::Construct )
+,		SchemaEntry("ifcstackterminaltype",&STEP::ObjectHelper<IfcStackTerminalType,1>::Construct )
+,		SchemaEntry("ifcstructuralitem",&STEP::ObjectHelper<IfcStructuralItem,0>::Construct )
+,		SchemaEntry("ifcstructuralconnection",&STEP::ObjectHelper<IfcStructuralConnection,1>::Construct )
+,		SchemaEntry("ifcstructuralcurveconnection",&STEP::ObjectHelper<IfcStructuralCurveConnection,0>::Construct )
+,		SchemaEntry("ifcjunctionboxtype",&STEP::ObjectHelper<IfcJunctionBoxType,1>::Construct )
+,		SchemaEntry("ifcrelassociates",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertydefinition",&STEP::ObjectHelper<IfcPropertyDefinition,0>::Construct )
+,		SchemaEntry("ifcpropertysetdefinition",&STEP::ObjectHelper<IfcPropertySetDefinition,0>::Construct )
+,		SchemaEntry("ifcdoorpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconstraintrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcspacethermalloadproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclibraryinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcprocess",&STEP::ObjectHelper<IfcProcess,0>::Construct )
+,		SchemaEntry("ifctask",&STEP::ObjectHelper<IfcTask,5>::Construct )
+,		SchemaEntry("ifcappliedvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcenvironmentalimpactvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelfillselement",&STEP::ObjectHelper<IfcRelFillsElement,2>::Construct )
+,		SchemaEntry("ifcprocedure",&STEP::ObjectHelper<IfcProcedure,3>::Construct )
+,		SchemaEntry("ifcstructuralload",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadstatic",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingledisplacement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcproxy",&STEP::ObjectHelper<IfcProxy,2>::Construct )
+,		SchemaEntry("ifccurvestylefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcresource",&STEP::ObjectHelper<IfcResource,0>::Construct )
+,		SchemaEntry("ifcconstructionresource",&STEP::ObjectHelper<IfcConstructionResource,4>::Construct )
+,		SchemaEntry("ifcsubcontractresource",&STEP::ObjectHelper<IfcSubContractResource,2>::Construct )
+,		SchemaEntry("ifccalendardate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdocumentelectronicformat",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelcontainedinspatialstructure",&STEP::ObjectHelper<IfcRelContainedInSpatialStructure,2>::Construct )
+,		SchemaEntry("ifcmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcproductsofcombustionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctopologicalrepresentationitem",&STEP::ObjectHelper<IfcTopologicalRepresentationItem,0>::Construct )
+,		SchemaEntry("ifcedge",&STEP::ObjectHelper<IfcEdge,2>::Construct )
+,		SchemaEntry("ifcedgecurve",&STEP::ObjectHelper<IfcEdgeCurve,2>::Construct )
+,		SchemaEntry("ifcplatetype",&STEP::ObjectHelper<IfcPlateType,1>::Construct )
+,		SchemaEntry("ifcobjectplacement",&STEP::ObjectHelper<IfcObjectPlacement,0>::Construct )
+,		SchemaEntry("ifcgridplacement",&STEP::ObjectHelper<IfcGridPlacement,2>::Construct )
+,		SchemaEntry("ifcfiresuppressionterminaltype",&STEP::ObjectHelper<IfcFireSuppressionTerminalType,1>::Construct )
+,		SchemaEntry("ifcmechanicalmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowstoragedevice",&STEP::ObjectHelper<IfcFlowStorageDevice,0>::Construct )
+,		SchemaEntry("ifcperson",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsweptsurface",&STEP::ObjectHelper<IfcSweptSurface,2>::Construct )
+,		SchemaEntry("ifcsurfaceofrevolution",&STEP::ObjectHelper<IfcSurfaceOfRevolution,1>::Construct )
+,		SchemaEntry("ifcorientededge",&STEP::ObjectHelper<IfcOrientedEdge,2>::Construct )
+,		SchemaEntry("ifcownerhistory",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassigns",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstoactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdirection",&STEP::ObjectHelper<IfcDirection,1>::Construct )
+,		SchemaEntry("ifcreinforcementbarproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcprofiledef",&STEP::ObjectHelper<IfcProfileDef,2>::Construct )
+,		SchemaEntry("ifcparameterizedprofiledef",&STEP::ObjectHelper<IfcParameterizedProfileDef,1>::Construct )
+,		SchemaEntry("ifccshapeprofiledef",&STEP::ObjectHelper<IfcCShapeProfileDef,6>::Construct )
+,		SchemaEntry("ifcfeatureelement",&STEP::ObjectHelper<IfcFeatureElement,0>::Construct )
+,		SchemaEntry("ifcfeatureelementsubtraction",&STEP::ObjectHelper<IfcFeatureElementSubtraction,0>::Construct )
+,		SchemaEntry("ifcedgefeature",&STEP::ObjectHelper<IfcEdgeFeature,1>::Construct )
+,		SchemaEntry("ifcchamferedgefeature",&STEP::ObjectHelper<IfcChamferEdgeFeature,2>::Construct )
+,		SchemaEntry("ifcbuildingelement",&STEP::ObjectHelper<IfcBuildingElement,0>::Construct )
+,		SchemaEntry("ifccolumn",&STEP::ObjectHelper<IfcColumn,0>::Construct )
+,		SchemaEntry("ifcpropertyreferencevalue",&STEP::ObjectHelper<IfcPropertyReferenceValue,2>::Construct )
+,		SchemaEntry("ifcmaterialclassificationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelectricmotortype",&STEP::ObjectHelper<IfcElectricMotorType,1>::Construct )
+,		SchemaEntry("ifcspatialstructureelementtype",&STEP::ObjectHelper<IfcSpatialStructureElementType,0>::Construct )
+,		SchemaEntry("ifcspacetype",&STEP::ObjectHelper<IfcSpaceType,1>::Construct )
+,		SchemaEntry("ifcexternalreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcexternallydefinedhatchstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccolumntype",&STEP::ObjectHelper<IfcColumnType,1>::Construct )
+,		SchemaEntry("ifccranerailashapeprofiledef",&STEP::ObjectHelper<IfcCraneRailAShapeProfileDef,12>::Construct )
+,		SchemaEntry("ifccondensertype",&STEP::ObjectHelper<IfcCondenserType,1>::Construct )
+,		SchemaEntry("ifcrelconnectselements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelconnectswithrealizingelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccircleprofiledef",&STEP::ObjectHelper<IfcCircleProfileDef,1>::Construct )
+,		SchemaEntry("ifccirclehollowprofiledef",&STEP::ObjectHelper<IfcCircleHollowProfileDef,1>::Construct )
+,		SchemaEntry("ifcorganizationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcplacement",&STEP::ObjectHelper<IfcPlacement,1>::Construct )
+,		SchemaEntry("ifcaxis2placement3d",&STEP::ObjectHelper<IfcAxis2Placement3D,2>::Construct )
+,		SchemaEntry("ifcpresentationstyle",&STEP::ObjectHelper<IfcPresentationStyle,1>::Construct )
+,		SchemaEntry("ifccurvestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcequipmentelement",&STEP::ObjectHelper<IfcEquipmentElement,0>::Construct )
+,		SchemaEntry("ifccompositecurvesegment",&STEP::ObjectHelper<IfcCompositeCurveSegment,3>::Construct )
+,		SchemaEntry("ifcrectangleprofiledef",&STEP::ObjectHelper<IfcRectangleProfileDef,2>::Construct )
+,		SchemaEntry("ifcphysicalquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcphysicalcomplexquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociateslibrary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelsequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcbuildingelementproxy",&STEP::ObjectHelper<IfcBuildingElementProxy,1>::Construct )
+,		SchemaEntry("ifcdistributioncontrolelementtype",&STEP::ObjectHelper<IfcDistributionControlElementType,0>::Construct )
+,		SchemaEntry("ifcflowinstrumenttype",&STEP::ObjectHelper<IfcFlowInstrumentType,1>::Construct )
+,		SchemaEntry("ifcdraughtingcallout",&STEP::ObjectHelper<IfcDraughtingCallout,1>::Construct )
+,		SchemaEntry("ifcdimensioncurvedirectedcallout",&STEP::ObjectHelper<IfcDimensionCurveDirectedCallout,0>::Construct )
+,		SchemaEntry("ifclineardimension",&STEP::ObjectHelper<IfcLinearDimension,0>::Construct )
+,		SchemaEntry("ifcelementassembly",&STEP::ObjectHelper<IfcElementAssembly,2>::Construct )
+,		SchemaEntry("ifcdraughtingcalloutrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccsgprimitive3d",&STEP::ObjectHelper<IfcCsgPrimitive3D,1>::Construct )
+,		SchemaEntry("ifcrightcircularcone",&STEP::ObjectHelper<IfcRightCircularCone,2>::Construct )
+,		SchemaEntry("ifcexternallydefinedsurfacestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcprojectorder",&STEP::ObjectHelper<IfcProjectOrder,3>::Construct )
+,		SchemaEntry("ifcpropertyconstraintrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclshapeprofiledef",&STEP::ObjectHelper<IfcLShapeProfileDef,8>::Construct )
+,		SchemaEntry("ifcangulardimension",&STEP::ObjectHelper<IfcAngularDimension,0>::Construct )
+,		SchemaEntry("ifctextstylefordefinedfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclocalplacement",&STEP::ObjectHelper<IfcLocalPlacement,2>::Construct )
+,		SchemaEntry("ifcsweptareasolid",&STEP::ObjectHelper<IfcSweptAreaSolid,2>::Construct )
+,		SchemaEntry("ifcrevolvedareasolid",&STEP::ObjectHelper<IfcRevolvedAreaSolid,2>::Construct )
+,		SchemaEntry("ifcstructuralsurfaceconnection",&STEP::ObjectHelper<IfcStructuralSurfaceConnection,0>::Construct )
+,		SchemaEntry("ifcradiusdimension",&STEP::ObjectHelper<IfcRadiusDimension,0>::Construct )
+,		SchemaEntry("ifcsweptdisksolid",&STEP::ObjectHelper<IfcSweptDiskSolid,5>::Construct )
+,		SchemaEntry("ifchalfspacesolid",&STEP::ObjectHelper<IfcHalfSpaceSolid,2>::Construct )
+,		SchemaEntry("ifcpolygonalboundedhalfspace",&STEP::ObjectHelper<IfcPolygonalBoundedHalfSpace,2>::Construct )
+,		SchemaEntry("ifctimeseriesschedule",&STEP::ObjectHelper<IfcTimeSeriesSchedule,3>::Construct )
+,		SchemaEntry("ifcdimensioncalloutrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccooledbeamtype",&STEP::ObjectHelper<IfcCooledBeamType,1>::Construct )
+,		SchemaEntry("ifcproject",&STEP::ObjectHelper<IfcProject,4>::Construct )
+,		SchemaEntry("ifcapprovalrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcevaporatortype",&STEP::ObjectHelper<IfcEvaporatorType,1>::Construct )
+,		SchemaEntry("ifclaborresource",&STEP::ObjectHelper<IfcLaborResource,1>::Construct )
+,		SchemaEntry("ifcstructuralloadsingledisplacementdistortion",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertyboundedvalue",&STEP::ObjectHelper<IfcPropertyBoundedValue,3>::Construct )
+,		SchemaEntry("ifcrampflighttype",&STEP::ObjectHelper<IfcRampFlightType,1>::Construct )
+,		SchemaEntry("ifcmember",&STEP::ObjectHelper<IfcMember,0>::Construct )
+,		SchemaEntry("ifcstructuralloadplanarforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctubebundletype",&STEP::ObjectHelper<IfcTubeBundleType,1>::Construct )
+,		SchemaEntry("ifcvalvetype",&STEP::ObjectHelper<IfcValveType,1>::Construct )
+,		SchemaEntry("ifcexternallydefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctrimmedcurve",&STEP::ObjectHelper<IfcTrimmedCurve,5>::Construct )
+,		SchemaEntry("ifcreldefines",&STEP::ObjectHelper<IfcRelDefines,1>::Construct )
+,		SchemaEntry("ifcreldefinesbyproperties",&STEP::ObjectHelper<IfcRelDefinesByProperties,1>::Construct )
+,		SchemaEntry("ifcrelassignstocontrol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcactor",&STEP::ObjectHelper<IfcActor,1>::Construct )
+,		SchemaEntry("ifcoccupant",&STEP::ObjectHelper<IfcOccupant,1>::Construct )
+,		SchemaEntry("ifchumidifiertype",&STEP::ObjectHelper<IfcHumidifierType,1>::Construct )
+,		SchemaEntry("ifcarbitraryopenprofiledef",&STEP::ObjectHelper<IfcArbitraryOpenProfileDef,1>::Construct )
+,		SchemaEntry("ifcrelassignstoprojectorder",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpermit",&STEP::ObjectHelper<IfcPermit,1>::Construct )
+,		SchemaEntry("ifcoffsetcurve3d",&STEP::ObjectHelper<IfcOffsetCurve3D,4>::Construct )
+,		SchemaEntry("ifclightsource",&STEP::ObjectHelper<IfcLightSource,4>::Construct )
+,		SchemaEntry("ifclightsourcepositional",&STEP::ObjectHelper<IfcLightSourcePositional,5>::Construct )
+,		SchemaEntry("ifcsurfacetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcblobtexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccompositeprofiledef",&STEP::ObjectHelper<IfcCompositeProfileDef,2>::Construct )
+,		SchemaEntry("ifcdocumentinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacestylelighting",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcphysicalsimplequantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantityarea",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcclassificationnotation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcramp",&STEP::ObjectHelper<IfcRamp,1>::Construct )
+,		SchemaEntry("ifcpredefineditem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurrencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowmovingdevice",&STEP::ObjectHelper<IfcFlowMovingDevice,0>::Construct )
+,		SchemaEntry("ifcspaceheatertype",&STEP::ObjectHelper<IfcSpaceHeaterType,1>::Construct )
+,		SchemaEntry("ifclamptype",&STEP::ObjectHelper<IfcLampType,1>::Construct )
+,		SchemaEntry("ifcbuildingelementcomponent",&STEP::ObjectHelper<IfcBuildingElementComponent,0>::Construct )
+,		SchemaEntry("ifcreinforcingelement",&STEP::ObjectHelper<IfcReinforcingElement,1>::Construct )
+,		SchemaEntry("ifcreinforcingbar",&STEP::ObjectHelper<IfcReinforcingBar,5>::Construct )
+,		SchemaEntry("ifcelectricheatertype",&STEP::ObjectHelper<IfcElectricHeaterType,1>::Construct )
+,		SchemaEntry("ifctshapeprofiledef",&STEP::ObjectHelper<IfcTShapeProfileDef,10>::Construct )
+,		SchemaEntry("ifcconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcobjective",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralactivity",&STEP::ObjectHelper<IfcStructuralActivity,2>::Construct )
+,		SchemaEntry("ifcstructuralaction",&STEP::ObjectHelper<IfcStructuralAction,2>::Construct )
+,		SchemaEntry("ifctexturecoordinate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmonetaryunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantitytime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctablerow",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclightdistributiondata",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcductfittingtype",&STEP::ObjectHelper<IfcDuctFittingType,1>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator2d",&STEP::ObjectHelper<IfcCartesianTransformationOperator2D,0>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator2dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1>::Construct )
+,		SchemaEntry("ifcclassificationnotationfacet",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdraughtingpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingleforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadsingleforcewarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurvestylefontandscaling",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcvirtualelement",&STEP::ObjectHelper<IfcVirtualElement,0>::Construct )
+,		SchemaEntry("ifcrightcircularcylinder",&STEP::ObjectHelper<IfcRightCircularCylinder,2>::Construct )
+,		SchemaEntry("ifcoutlettype",&STEP::ObjectHelper<IfcOutletType,1>::Construct )
+,		SchemaEntry("ifcreldecomposes",&STEP::ObjectHelper<IfcRelDecomposes,2>::Construct )
+,		SchemaEntry("ifcrelnests",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccovering",&STEP::ObjectHelper<IfcCovering,1>::Construct )
+,		SchemaEntry("ifcexternallydefinedsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcirregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpolyline",&STEP::ObjectHelper<IfcPolyline,1>::Construct )
+,		SchemaEntry("ifcpath",&STEP::ObjectHelper<IfcPath,1>::Construct )
+,		SchemaEntry("ifcelementcomponent",&STEP::ObjectHelper<IfcElementComponent,0>::Construct )
+,		SchemaEntry("ifcfastener",&STEP::ObjectHelper<IfcFastener,0>::Construct )
+,		SchemaEntry("ifcmappeditem",&STEP::ObjectHelper<IfcMappedItem,2>::Construct )
+,		SchemaEntry("ifcmetric",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdocumentreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsectionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrectangularpyramid",&STEP::ObjectHelper<IfcRectangularPyramid,3>::Construct )
+,		SchemaEntry("ifcrelreferencedinspatialstructure",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccrewresource",&STEP::ObjectHelper<IfcCrewResource,0>::Construct )
+,		SchemaEntry("ifcnamedunit",&STEP::ObjectHelper<IfcNamedUnit,2>::Construct )
+,		SchemaEntry("ifccontextdependentunit",&STEP::ObjectHelper<IfcContextDependentUnit,1>::Construct )
+,		SchemaEntry("ifcunitaryequipmenttype",&STEP::ObjectHelper<IfcUnitaryEquipmentType,1>::Construct )
+,		SchemaEntry("ifcroof",&STEP::ObjectHelper<IfcRoof,1>::Construct )
+,		SchemaEntry("ifcrelassignstasks",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralmember",&STEP::ObjectHelper<IfcStructuralMember,0>::Construct )
+,		SchemaEntry("ifcrelconnectsports",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstylemodel",&STEP::ObjectHelper<IfcStyleModel,0>::Construct )
+,		SchemaEntry("ifcstyledrepresentation",&STEP::ObjectHelper<IfcStyledRepresentation,0>::Construct )
+,		SchemaEntry("ifcspatialstructureelement",&STEP::ObjectHelper<IfcSpatialStructureElement,2>::Construct )
+,		SchemaEntry("ifcbuilding",&STEP::ObjectHelper<IfcBuilding,3>::Construct )
+,		SchemaEntry("ifcconnectedfaceset",&STEP::ObjectHelper<IfcConnectedFaceSet,1>::Construct )
+,		SchemaEntry("ifcopenshell",&STEP::ObjectHelper<IfcOpenShell,0>::Construct )
+,		SchemaEntry("ifcfacetedbrep",&STEP::ObjectHelper<IfcFacetedBrep,0>::Construct )
+,		SchemaEntry("ifclocaltime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmechanicalconcretematerialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconic",&STEP::ObjectHelper<IfcConic,1>::Construct )
+,		SchemaEntry("ifccoveringtype",&STEP::ObjectHelper<IfcCoveringType,1>::Construct )
+,		SchemaEntry("ifcroundedrectangleprofiledef",&STEP::ObjectHelper<IfcRoundedRectangleProfileDef,1>::Construct )
+,		SchemaEntry("ifcairterminaltype",&STEP::ObjectHelper<IfcAirTerminalType,1>::Construct )
+,		SchemaEntry("ifcflowmovingdevicetype",&STEP::ObjectHelper<IfcFlowMovingDeviceType,0>::Construct )
+,		SchemaEntry("ifccompressortype",&STEP::ObjectHelper<IfcCompressorType,1>::Construct )
+,		SchemaEntry("ifcwindowpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpredefinedterminatorsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcishapeprofiledef",&STEP::ObjectHelper<IfcIShapeProfileDef,5>::Construct )
+,		SchemaEntry("ifcasymmetricishapeprofiledef",&STEP::ObjectHelper<IfcAsymmetricIShapeProfileDef,4>::Construct )
+,		SchemaEntry("ifccontrollertype",&STEP::ObjectHelper<IfcControllerType,1>::Construct )
+,		SchemaEntry("ifcrailing",&STEP::ObjectHelper<IfcRailing,1>::Construct )
+,		SchemaEntry("ifcgroup",&STEP::ObjectHelper<IfcGroup,0>::Construct )
+,		SchemaEntry("ifcasset",&STEP::ObjectHelper<IfcAsset,9>::Construct )
+,		SchemaEntry("ifcmaterialdefinitionrepresentation",&STEP::ObjectHelper<IfcMaterialDefinitionRepresentation,1>::Construct )
+,		SchemaEntry("ifccurvestylefontpattern",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcapprovalpropertyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrailingtype",&STEP::ObjectHelper<IfcRailingType,1>::Construct )
+,		SchemaEntry("ifcwall",&STEP::ObjectHelper<IfcWall,0>::Construct )
+,		SchemaEntry("ifcclassificationitem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralpointconnection",&STEP::ObjectHelper<IfcStructuralPointConnection,0>::Construct )
+,		SchemaEntry("ifcconnectiongeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconnectionpointgeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertylistvalue",&STEP::ObjectHelper<IfcPropertyListValue,2>::Construct )
+,		SchemaEntry("ifcfurniturestandard",&STEP::ObjectHelper<IfcFurnitureStandard,0>::Construct )
+,		SchemaEntry("ifcrelschedulescostitems",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelectricgeneratortype",&STEP::ObjectHelper<IfcElectricGeneratorType,1>::Construct )
+,		SchemaEntry("ifcdoor",&STEP::ObjectHelper<IfcDoor,2>::Construct )
+,		SchemaEntry("ifcstyleditem",&STEP::ObjectHelper<IfcStyledItem,3>::Construct )
+,		SchemaEntry("ifcannotationoccurrence",&STEP::ObjectHelper<IfcAnnotationOccurrence,0>::Construct )
+,		SchemaEntry("ifcannotationsymboloccurrence",&STEP::ObjectHelper<IfcAnnotationSymbolOccurrence,0>::Construct )
+,		SchemaEntry("ifcarbitraryclosedprofiledef",&STEP::ObjectHelper<IfcArbitraryClosedProfileDef,1>::Construct )
+,		SchemaEntry("ifcarbitraryprofiledefwithvoids",&STEP::ObjectHelper<IfcArbitraryProfileDefWithVoids,1>::Construct )
+,		SchemaEntry("ifcline",&STEP::ObjectHelper<IfcLine,2>::Construct )
+,		SchemaEntry("ifcmateriallayerset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowsegmenttype",&STEP::ObjectHelper<IfcFlowSegmentType,0>::Construct )
+,		SchemaEntry("ifcairterminalboxtype",&STEP::ObjectHelper<IfcAirTerminalBoxType,1>::Construct )
+,		SchemaEntry("ifcrelconnectsstructuralmember",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpropertysinglevalue",&STEP::ObjectHelper<IfcPropertySingleValue,2>::Construct )
+,		SchemaEntry("ifcalarmtype",&STEP::ObjectHelper<IfcAlarmType,1>::Construct )
+,		SchemaEntry("ifcellipseprofiledef",&STEP::ObjectHelper<IfcEllipseProfileDef,2>::Construct )
+,		SchemaEntry("ifcstair",&STEP::ObjectHelper<IfcStair,1>::Construct )
+,		SchemaEntry("ifcpredefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctextstylefontmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacestyleshading",&STEP::ObjectHelper<IfcSurfaceStyleShading,1>::Construct )
+,		SchemaEntry("ifcpumptype",&STEP::ObjectHelper<IfcPumpType,1>::Construct )
+,		SchemaEntry("ifcdefinedsymbol",&STEP::ObjectHelper<IfcDefinedSymbol,2>::Construct )
+,		SchemaEntry("ifcclassificationitemrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcgeneralmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelementcomponenttype",&STEP::ObjectHelper<IfcElementComponentType,0>::Construct )
+,		SchemaEntry("ifcfastenertype",&STEP::ObjectHelper<IfcFastenerType,0>::Construct )
+,		SchemaEntry("ifcmechanicalfastenertype",&STEP::ObjectHelper<IfcMechanicalFastenerType,0>::Construct )
+,		SchemaEntry("ifcpermeablecoveringproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowfitting",&STEP::ObjectHelper<IfcFlowFitting,0>::Construct )
+,		SchemaEntry("ifcapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcshapeaspect",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconstraintclassificationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifclightsourcedirectional",&STEP::ObjectHelper<IfcLightSourceDirectional,1>::Construct )
+,		SchemaEntry("ifcsurfacestyle",&STEP::ObjectHelper<IfcSurfaceStyle,2>::Construct )
+,		SchemaEntry("ifcrelconnectsstructuralactivity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcannotationsurface",&STEP::ObjectHelper<IfcAnnotationSurface,2>::Construct )
+,		SchemaEntry("ifcfuelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowcontroller",&STEP::ObjectHelper<IfcFlowController,0>::Construct )
+,		SchemaEntry("ifcfailureconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcbuildingstorey",&STEP::ObjectHelper<IfcBuildingStorey,1>::Construct )
+,		SchemaEntry("ifcworkcontrol",&STEP::ObjectHelper<IfcWorkControl,10>::Construct )
+,		SchemaEntry("ifcworkschedule",&STEP::ObjectHelper<IfcWorkSchedule,0>::Construct )
+,		SchemaEntry("ifctable",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcductsegmenttype",&STEP::ObjectHelper<IfcDuctSegmentType,1>::Construct )
+,		SchemaEntry("ifcstructuralsteelprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdraughtingpredefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcface",&STEP::ObjectHelper<IfcFace,1>::Construct )
+,		SchemaEntry("ifcstructuralsurfacemember",&STEP::ObjectHelper<IfcStructuralSurfaceMember,2>::Construct )
+,		SchemaEntry("ifcstructuralsurfacemembervarying",&STEP::ObjectHelper<IfcStructuralSurfaceMemberVarying,2>::Construct )
+,		SchemaEntry("ifcfacesurface",&STEP::ObjectHelper<IfcFaceSurface,2>::Construct )
+,		SchemaEntry("ifcclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmateriallist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccostschedule",&STEP::ObjectHelper<IfcCostSchedule,8>::Construct )
+,		SchemaEntry("ifccoordinateduniversaltimeoffset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcplanarextent",&STEP::ObjectHelper<IfcPlanarExtent,2>::Construct )
+,		SchemaEntry("ifcplanarbox",&STEP::ObjectHelper<IfcPlanarBox,1>::Construct )
+,		SchemaEntry("ifcfillareastyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsectionreinforcementproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccolourspecification",&STEP::ObjectHelper<IfcColourSpecification,1>::Construct )
+,		SchemaEntry("ifcvector",&STEP::ObjectHelper<IfcVector,2>::Construct )
+,		SchemaEntry("ifcbeam",&STEP::ObjectHelper<IfcBeam,0>::Construct )
+,		SchemaEntry("ifccolourrgb",&STEP::ObjectHelper<IfcColourRgb,3>::Construct )
+,		SchemaEntry("ifcstructuralplanaraction",&STEP::ObjectHelper<IfcStructuralPlanarAction,1>::Construct )
+,		SchemaEntry("ifcstructuralplanaractionvarying",&STEP::ObjectHelper<IfcStructuralPlanarActionVarying,2>::Construct )
+,		SchemaEntry("ifcsite",&STEP::ObjectHelper<IfcSite,5>::Construct )
+,		SchemaEntry("ifcdiscreteaccessorytype",&STEP::ObjectHelper<IfcDiscreteAccessoryType,0>::Construct )
+,		SchemaEntry("ifcvibrationisolatortype",&STEP::ObjectHelper<IfcVibrationIsolatorType,1>::Construct )
+,		SchemaEntry("ifcevaporativecoolertype",&STEP::ObjectHelper<IfcEvaporativeCoolerType,1>::Construct )
+,		SchemaEntry("ifcdistributionchamberelementtype",&STEP::ObjectHelper<IfcDistributionChamberElementType,1>::Construct )
+,		SchemaEntry("ifcfeatureelementaddition",&STEP::ObjectHelper<IfcFeatureElementAddition,0>::Construct )
+,		SchemaEntry("ifcrelassignstoresource",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructureddimensioncallout",&STEP::ObjectHelper<IfcStructuredDimensionCallout,0>::Construct )
+,		SchemaEntry("ifccoolingtowertype",&STEP::ObjectHelper<IfcCoolingTowerType,1>::Construct )
+,		SchemaEntry("ifccenterlineprofiledef",&STEP::ObjectHelper<IfcCenterLineProfileDef,1>::Construct )
+,		SchemaEntry("ifctexturevertex",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwindowstyle",&STEP::ObjectHelper<IfcWindowStyle,4>::Construct )
+,		SchemaEntry("ifclightsourcegoniometric",&STEP::ObjectHelper<IfcLightSourceGoniometric,6>::Construct )
+,		SchemaEntry("ifcribplateprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctransformertype",&STEP::ObjectHelper<IfcTransformerType,1>::Construct )
+,		SchemaEntry("ifcmembertype",&STEP::ObjectHelper<IfcMemberType,1>::Construct )
+,		SchemaEntry("ifcsurfaceoflinearextrusion",&STEP::ObjectHelper<IfcSurfaceOfLinearExtrusion,2>::Construct )
+,		SchemaEntry("ifcmotorconnectiontype",&STEP::ObjectHelper<IfcMotorConnectionType,1>::Construct )
+,		SchemaEntry("ifcflowtreatmentdevicetype",&STEP::ObjectHelper<IfcFlowTreatmentDeviceType,0>::Construct )
+,		SchemaEntry("ifcductsilencertype",&STEP::ObjectHelper<IfcDuctSilencerType,1>::Construct )
+,		SchemaEntry("ifcwindowliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfurnishingelementtype",&STEP::ObjectHelper<IfcFurnishingElementType,0>::Construct )
+,		SchemaEntry("ifcsystemfurnitureelementtype",&STEP::ObjectHelper<IfcSystemFurnitureElementType,0>::Construct )
+,		SchemaEntry("ifcconnectionpointeccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwasteterminaltype",&STEP::ObjectHelper<IfcWasteTerminalType,1>::Construct )
+,		SchemaEntry("ifcbsplinecurve",&STEP::ObjectHelper<IfcBSplineCurve,5>::Construct )
+,		SchemaEntry("ifcbeziercurve",&STEP::ObjectHelper<IfcBezierCurve,0>::Construct )
+,		SchemaEntry("ifcdocumentinformationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcactuatortype",&STEP::ObjectHelper<IfcActuatorType,1>::Construct )
+,		SchemaEntry("ifcdistributioncontrolelement",&STEP::ObjectHelper<IfcDistributionControlElement,1>::Construct )
+,		SchemaEntry("ifcannotation",&STEP::ObjectHelper<IfcAnnotation,0>::Construct )
+,		SchemaEntry("ifcrelassociatesdocument",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdoorliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcshellbasedsurfacemodel",&STEP::ObjectHelper<IfcShellBasedSurfaceModel,1>::Construct )
+,		SchemaEntry("ifcactionrequest",&STEP::ObjectHelper<IfcActionRequest,1>::Construct )
+,		SchemaEntry("ifcextrudedareasolid",&STEP::ObjectHelper<IfcExtrudedAreaSolid,2>::Construct )
+,		SchemaEntry("ifcsystem",&STEP::ObjectHelper<IfcSystem,0>::Construct )
+,		SchemaEntry("ifcfillareastylehatching",&STEP::ObjectHelper<IfcFillAreaStyleHatching,5>::Construct )
+,		SchemaEntry("ifcrelvoidselement",&STEP::ObjectHelper<IfcRelVoidsElement,2>::Construct )
+,		SchemaEntry("ifcrelconnectspathelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelspaceboundary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacecurvesweptareasolid",&STEP::ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4>::Construct )
+,		SchemaEntry("ifccartesiantransformationoperator3dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2>::Construct )
+,		SchemaEntry("ifcrelinteractionrequirements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurtainwalltype",&STEP::ObjectHelper<IfcCurtainWallType,1>::Construct )
+,		SchemaEntry("ifcquantitylength",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcequipmentstandard",&STEP::ObjectHelper<IfcEquipmentStandard,0>::Construct )
+,		SchemaEntry("ifcflowstoragedevicetype",&STEP::ObjectHelper<IfcFlowStorageDeviceType,0>::Construct )
+,		SchemaEntry("ifcvirtualgridintersection",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdiameterdimension",&STEP::ObjectHelper<IfcDiameterDimension,0>::Construct )
+,		SchemaEntry("ifcswitchingdevicetype",&STEP::ObjectHelper<IfcSwitchingDeviceType,1>::Construct )
+,		SchemaEntry("ifcaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctelecomaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwindow",&STEP::ObjectHelper<IfcWindow,2>::Construct )
+,		SchemaEntry("ifcmechanicalsteelmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowtreatmentdevice",&STEP::ObjectHelper<IfcFlowTreatmentDevice,0>::Construct )
+,		SchemaEntry("ifcrelservicesbuildings",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcchillertype",&STEP::ObjectHelper<IfcChillerType,1>::Construct )
+,		SchemaEntry("ifcrelassignstoproduct",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrectanglehollowprofiledef",&STEP::ObjectHelper<IfcRectangleHollowProfileDef,3>::Construct )
+,		SchemaEntry("ifcenergyproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboxedhalfspace",&STEP::ObjectHelper<IfcBoxedHalfSpace,1>::Construct )
+,		SchemaEntry("ifcaxis2placement2d",&STEP::ObjectHelper<IfcAxis2Placement2D,1>::Construct )
+,		SchemaEntry("ifcspaceprogram",&STEP::ObjectHelper<IfcSpaceProgram,5>::Construct )
+,		SchemaEntry("ifcpoint",&STEP::ObjectHelper<IfcPoint,0>::Construct )
+,		SchemaEntry("ifccartesianpoint",&STEP::ObjectHelper<IfcCartesianPoint,1>::Construct )
+,		SchemaEntry("ifcboundedsurface",&STEP::ObjectHelper<IfcBoundedSurface,0>::Construct )
+,		SchemaEntry("ifcloop",&STEP::ObjectHelper<IfcLoop,0>::Construct )
+,		SchemaEntry("ifcpolyloop",&STEP::ObjectHelper<IfcPolyLoop,1>::Construct )
+,		SchemaEntry("ifcpredefinedpointmarkersymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcterminatorsymbol",&STEP::ObjectHelper<IfcTerminatorSymbol,1>::Construct )
+,		SchemaEntry("ifcdimensioncurveterminator",&STEP::ObjectHelper<IfcDimensionCurveTerminator,1>::Construct )
+,		SchemaEntry("ifcrelprojectselement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctrapeziumprofiledef",&STEP::ObjectHelper<IfcTrapeziumProfileDef,4>::Construct )
+,		SchemaEntry("ifcrepresentationcontext",&STEP::ObjectHelper<IfcRepresentationContext,2>::Construct )
+,		SchemaEntry("ifcgeometricrepresentationcontext",&STEP::ObjectHelper<IfcGeometricRepresentationContext,4>::Construct )
+,		SchemaEntry("ifctextstylewithboxcharacteristics",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurveboundedplane",&STEP::ObjectHelper<IfcCurveBoundedPlane,3>::Construct )
+,		SchemaEntry("ifcquantitycount",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctimeseriesreferencerelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadtemperature",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsiunit",&STEP::ObjectHelper<IfcSIUnit,2>::Construct )
+,		SchemaEntry("ifcstructuralreaction",&STEP::ObjectHelper<IfcStructuralReaction,0>::Construct )
+,		SchemaEntry("ifcstructuralpointreaction",&STEP::ObjectHelper<IfcStructuralPointReaction,0>::Construct )
+,		SchemaEntry("ifcaxis1placement",&STEP::ObjectHelper<IfcAxis1Placement,1>::Construct )
+,		SchemaEntry("ifcreinforcementdefinitionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelectricappliancetype",&STEP::ObjectHelper<IfcElectricApplianceType,1>::Construct )
+,		SchemaEntry("ifcsensortype",&STEP::ObjectHelper<IfcSensorType,1>::Construct )
+,		SchemaEntry("ifcfurnishingelement",&STEP::ObjectHelper<IfcFurnishingElement,0>::Construct )
+,		SchemaEntry("ifcprotectivedevicetype",&STEP::ObjectHelper<IfcProtectiveDeviceType,1>::Construct )
+,		SchemaEntry("ifczshapeprofiledef",&STEP::ObjectHelper<IfcZShapeProfileDef,6>::Construct )
+,		SchemaEntry("ifcscheduletimecontrol",&STEP::ObjectHelper<IfcScheduleTimeControl,18>::Construct )
+,		SchemaEntry("ifcrepresentationmap",&STEP::ObjectHelper<IfcRepresentationMap,2>::Construct )
+,		SchemaEntry("ifcclosedshell",&STEP::ObjectHelper<IfcClosedShell,0>::Construct )
+,		SchemaEntry("ifcbuildingelementpart",&STEP::ObjectHelper<IfcBuildingElementPart,0>::Construct )
+,		SchemaEntry("ifcdraughtingpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpostaladdress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcblock",&STEP::ObjectHelper<IfcBlock,3>::Construct )
+,		SchemaEntry("ifclightfixturetype",&STEP::ObjectHelper<IfcLightFixtureType,1>::Construct )
+,		SchemaEntry("ifcopeningelement",&STEP::ObjectHelper<IfcOpeningElement,0>::Construct )
+,		SchemaEntry("ifclightsourcespot",&STEP::ObjectHelper<IfcLightSourceSpot,4>::Construct )
+,		SchemaEntry("ifctendonanchor",&STEP::ObjectHelper<IfcTendonAnchor,0>::Construct )
+,		SchemaEntry("ifcsurfacestylerefraction",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelectricflowstoragedevicetype",&STEP::ObjectHelper<IfcElectricFlowStorageDeviceType,1>::Construct )
+,		SchemaEntry("ifcfluidflowproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsphere",&STEP::ObjectHelper<IfcSphere,1>::Construct )
+,		SchemaEntry("ifcrelassociatesappliedvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdampertype",&STEP::ObjectHelper<IfcDamperType,1>::Construct )
+,		SchemaEntry("ifcprojectorderrecord",&STEP::ObjectHelper<IfcProjectOrderRecord,2>::Construct )
+,		SchemaEntry("ifcdimensionalexponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcreldefinesbytype",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcdistributionchamberelement",&STEP::ObjectHelper<IfcDistributionChamberElement,0>::Construct )
+,		SchemaEntry("ifcmechanicalfastener",&STEP::ObjectHelper<IfcMechanicalFastener,2>::Construct )
+,		SchemaEntry("ifcquantityvolume",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrectangulartrimmedsurface",&STEP::ObjectHelper<IfcRectangularTrimmedSurface,7>::Construct )
+,		SchemaEntry("ifcdateandtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifczone",&STEP::ObjectHelper<IfcZone,0>::Construct )
+,		SchemaEntry("ifcfantype",&STEP::ObjectHelper<IfcFanType,1>::Construct )
+,		SchemaEntry("ifcgeometricset",&STEP::ObjectHelper<IfcGeometricSet,1>::Construct )
+,		SchemaEntry("ifcfillareastyletiles",&STEP::ObjectHelper<IfcFillAreaStyleTiles,3>::Construct )
+,		SchemaEntry("ifcpixeltexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccablesegmenttype",&STEP::ObjectHelper<IfcCableSegmentType,1>::Construct )
+,		SchemaEntry("ifcreloverridesproperties",&STEP::ObjectHelper<IfcRelOverridesProperties,1>::Construct )
+,		SchemaEntry("ifcmeasurewithunit",&STEP::ObjectHelper<IfcMeasureWithUnit,2>::Construct )
+,		SchemaEntry("ifcslabtype",&STEP::ObjectHelper<IfcSlabType,1>::Construct )
+,		SchemaEntry("ifcservicelife",&STEP::ObjectHelper<IfcServiceLife,2>::Construct )
+,		SchemaEntry("ifcfurnituretype",&STEP::ObjectHelper<IfcFurnitureType,1>::Construct )
+,		SchemaEntry("ifccostitem",&STEP::ObjectHelper<IfcCostItem,0>::Construct )
+,		SchemaEntry("ifcreinforcingmesh",&STEP::ObjectHelper<IfcReinforcingMesh,8>::Construct )
+,		SchemaEntry("ifcextendedmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcactorrole",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfacetedbrepwithvoids",&STEP::ObjectHelper<IfcFacetedBrepWithVoids,1>::Construct )
+,		SchemaEntry("ifcconstraintaggregationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcgasterminaltype",&STEP::ObjectHelper<IfcGasTerminalType,1>::Construct )
+,		SchemaEntry("ifcrelconnectswitheccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpile",&STEP::ObjectHelper<IfcPile,2>::Construct )
+,		SchemaEntry("ifcfillareastyletilesymbolwithstyle",&STEP::ObjectHelper<IfcFillAreaStyleTileSymbolWithStyle,1>::Construct )
+,		SchemaEntry("ifcelectricalbaseproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconstructionmaterialresource",&STEP::ObjectHelper<IfcConstructionMaterialResource,2>::Construct )
+,		SchemaEntry("ifcannotationcurveoccurrence",&STEP::ObjectHelper<IfcAnnotationCurveOccurrence,0>::Construct )
+,		SchemaEntry("ifcdimensioncurve",&STEP::ObjectHelper<IfcDimensionCurve,0>::Construct )
+,		SchemaEntry("ifcgeometriccurveset",&STEP::ObjectHelper<IfcGeometricCurveSet,0>::Construct )
+,		SchemaEntry("ifcrelaggregates",&STEP::ObjectHelper<IfcRelAggregates,0>::Construct )
+,		SchemaEntry("ifcfacebasedsurfacemodel",&STEP::ObjectHelper<IfcFaceBasedSurfaceModel,1>::Construct )
+,		SchemaEntry("ifcenergyconversiondevice",&STEP::ObjectHelper<IfcEnergyConversionDevice,0>::Construct )
+,		SchemaEntry("ifcrampflight",&STEP::ObjectHelper<IfcRampFlight,0>::Construct )
+,		SchemaEntry("ifcpropertyenumeration",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcvertexloop",&STEP::ObjectHelper<IfcVertexLoop,1>::Construct )
+,		SchemaEntry("ifcplate",&STEP::ObjectHelper<IfcPlate,0>::Construct )
+,		SchemaEntry("ifcushapeprofiledef",&STEP::ObjectHelper<IfcUShapeProfileDef,8>::Construct )
+,		SchemaEntry("ifchygroscopicmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfacebound",&STEP::ObjectHelper<IfcFaceBound,2>::Construct )
+,		SchemaEntry("ifcfaceouterbound",&STEP::ObjectHelper<IfcFaceOuterBound,0>::Construct )
+,		SchemaEntry("ifconedirectionrepeatfactor",&STEP::ObjectHelper<IfcOneDirectionRepeatFactor,1>::Construct )
+,		SchemaEntry("ifcboilertype",&STEP::ObjectHelper<IfcBoilerType,1>::Construct )
+,		SchemaEntry("ifcconstructionequipmentresource",&STEP::ObjectHelper<IfcConstructionEquipmentResource,0>::Construct )
+,		SchemaEntry("ifccomplexproperty",&STEP::ObjectHelper<IfcComplexProperty,2>::Construct )
+,		SchemaEntry("ifcfooting",&STEP::ObjectHelper<IfcFooting,1>::Construct )
+,		SchemaEntry("ifcopticalmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconstructionproductresource",&STEP::ObjectHelper<IfcConstructionProductResource,0>::Construct )
+,		SchemaEntry("ifcboundaryedgecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcderivedprofiledef",&STEP::ObjectHelper<IfcDerivedProfileDef,3>::Construct )
+,		SchemaEntry("ifcpropertytablevalue",&STEP::ObjectHelper<IfcPropertyTableValue,5>::Construct )
+,		SchemaEntry("ifcrelassignstogroup",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcflowmetertype",&STEP::ObjectHelper<IfcFlowMeterType,1>::Construct )
+,		SchemaEntry("ifcdoorstyle",&STEP::ObjectHelper<IfcDoorStyle,4>::Construct )
+,		SchemaEntry("ifcrelconnectsporttoelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcunitassignment",&STEP::ObjectHelper<IfcUnitAssignment,1>::Construct )
+,		SchemaEntry("ifcflowterminal",&STEP::ObjectHelper<IfcFlowTerminal,0>::Construct )
+,		SchemaEntry("ifccranerailfshapeprofiledef",&STEP::ObjectHelper<IfcCraneRailFShapeProfileDef,9>::Construct )
+,		SchemaEntry("ifcflowsegment",&STEP::ObjectHelper<IfcFlowSegment,0>::Construct )
+,		SchemaEntry("ifcelementquantity",&STEP::ObjectHelper<IfcElementQuantity,2>::Construct )
+,		SchemaEntry("ifcboundarynodecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcboundarynodeconditionwarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccurtainwall",&STEP::ObjectHelper<IfcCurtainWall,0>::Construct )
+,		SchemaEntry("ifcdiscreteaccessory",&STEP::ObjectHelper<IfcDiscreteAccessory,0>::Construct )
+,		SchemaEntry("ifcgrid",&STEP::ObjectHelper<IfcGrid,3>::Construct )
+,		SchemaEntry("ifcsanitaryterminaltype",&STEP::ObjectHelper<IfcSanitaryTerminalType,1>::Construct )
+,		SchemaEntry("ifcsoundproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsubedge",&STEP::ObjectHelper<IfcSubedge,1>::Construct )
+,		SchemaEntry("ifctextstyletextmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcfiltertype",&STEP::ObjectHelper<IfcFilterType,1>::Construct )
+,		SchemaEntry("ifcsymbolstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctendon",&STEP::ObjectHelper<IfcTendon,8>::Construct )
+,		SchemaEntry("ifcdimensionpair",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralloadgroup",&STEP::ObjectHelper<IfcStructuralLoadGroup,5>::Construct )
+,		SchemaEntry("ifcpresentationstyleassignment",&STEP::ObjectHelper<IfcPresentationStyleAssignment,1>::Construct )
+,		SchemaEntry("ifcregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralcurvemember",&STEP::ObjectHelper<IfcStructuralCurveMember,1>::Construct )
+,		SchemaEntry("ifclightsourceambient",&STEP::ObjectHelper<IfcLightSourceAmbient,0>::Construct )
+,		SchemaEntry("ifccondition",&STEP::ObjectHelper<IfcCondition,0>::Construct )
+,		SchemaEntry("ifcport",&STEP::ObjectHelper<IfcPort,0>::Construct )
+,		SchemaEntry("ifcspace",&STEP::ObjectHelper<IfcSpace,2>::Construct )
+,		SchemaEntry("ifcheatexchangertype",&STEP::ObjectHelper<IfcHeatExchangerType,1>::Construct )
+,		SchemaEntry("ifctanktype",&STEP::ObjectHelper<IfcTankType,1>::Construct )
+,		SchemaEntry("ifcinventory",&STEP::ObjectHelper<IfcInventory,6>::Construct )
+,		SchemaEntry("ifctextstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcappliedvaluerelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsoundvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctransportelementtype",&STEP::ObjectHelper<IfcTransportElementType,1>::Construct )
+,		SchemaEntry("ifcairtoairheatrecoverytype",&STEP::ObjectHelper<IfcAirToAirHeatRecoveryType,1>::Construct )
+,		SchemaEntry("ifcstairflight",&STEP::ObjectHelper<IfcStairFlight,4>::Construct )
+,		SchemaEntry("ifcelectricalelement",&STEP::ObjectHelper<IfcElectricalElement,0>::Construct )
+,		SchemaEntry("ifclightintensitydistribution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcclassificationreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcsurfacestylewithtextures",&STEP::ObjectHelper<IfcSurfaceStyleWithTextures,1>::Construct )
+,		SchemaEntry("ifcboundingbox",&STEP::ObjectHelper<IfcBoundingBox,4>::Construct )
+,		SchemaEntry("ifcapplication",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwalltype",&STEP::ObjectHelper<IfcWallType,1>::Construct )
+,		SchemaEntry("ifcmove",&STEP::ObjectHelper<IfcMove,3>::Construct )
+,		SchemaEntry("ifccircle",&STEP::ObjectHelper<IfcCircle,1>::Construct )
+,		SchemaEntry("ifcoffsetcurve2d",&STEP::ObjectHelper<IfcOffsetCurve2D,3>::Construct )
+,		SchemaEntry("ifcmateriallayersetusage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpointoncurve",&STEP::ObjectHelper<IfcPointOnCurve,2>::Construct )
+,		SchemaEntry("ifcstructuralresultgroup",&STEP::ObjectHelper<IfcStructuralResultGroup,3>::Construct )
+,		SchemaEntry("ifcsectionedspine",&STEP::ObjectHelper<IfcSectionedSpine,3>::Construct )
+,		SchemaEntry("ifcslab",&STEP::ObjectHelper<IfcSlab,1>::Construct )
+,		SchemaEntry("ifcconnectionportgeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcquantityweight",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassociatesmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcvertex",&STEP::ObjectHelper<IfcVertex,0>::Construct )
+,		SchemaEntry("ifcvertexpoint",&STEP::ObjectHelper<IfcVertexPoint,1>::Construct )
+,		SchemaEntry("ifcreferencesvaluedocument",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpersonandorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelflowcontrolelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcrelassignstoprocess",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructurallinearaction",&STEP::ObjectHelper<IfcStructuralLinearAction,1>::Construct )
+,		SchemaEntry("ifcstructurallinearactionvarying",&STEP::ObjectHelper<IfcStructuralLinearActionVarying,2>::Construct )
+,		SchemaEntry("ifcbuildingelementproxytype",&STEP::ObjectHelper<IfcBuildingElementProxyType,1>::Construct )
+,		SchemaEntry("ifcprojectionelement",&STEP::ObjectHelper<IfcProjectionElement,0>::Construct )
+,		SchemaEntry("ifcderivedunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcapprovalactorrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconversionbasedunit",&STEP::ObjectHelper<IfcConversionBasedUnit,2>::Construct )
+,		SchemaEntry("ifcmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcgeometricrepresentationsubcontext",&STEP::ObjectHelper<IfcGeometricRepresentationSubContext,4>::Construct )
+,		SchemaEntry("ifcannotationsurfaceoccurrence",&STEP::ObjectHelper<IfcAnnotationSurfaceOccurrence,0>::Construct )
+,		SchemaEntry("ifcpredefineddimensionsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcroundededgefeature",&STEP::ObjectHelper<IfcRoundedEdgeFeature,1>::Construct )
+,		SchemaEntry("ifcrelcoversbldgelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcelectricdistributionpoint",&STEP::ObjectHelper<IfcElectricDistributionPoint,2>::Construct )
+,		SchemaEntry("ifccablecarriersegmenttype",&STEP::ObjectHelper<IfcCableCarrierSegmentType,1>::Construct )
+,		SchemaEntry("ifcstructuralloadlinearforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcgridaxis",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcirregulartimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcwallstandardcase",&STEP::ObjectHelper<IfcWallStandardCase,0>::Construct )
+,		SchemaEntry("ifcreloccupiesspaces",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcderivedunitelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccsgsolid",&STEP::ObjectHelper<IfcCsgSolid,1>::Construct )
+,		SchemaEntry("ifcbeamtype",&STEP::ObjectHelper<IfcBeamType,1>::Construct )
+,		SchemaEntry("ifcannotationfillarea",&STEP::ObjectHelper<IfcAnnotationFillArea,2>::Construct )
+,		SchemaEntry("ifcrelaxation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralcurvemembervarying",&STEP::ObjectHelper<IfcStructuralCurveMemberVarying,0>::Construct )
+,		SchemaEntry("ifcpointonsurface",&STEP::ObjectHelper<IfcPointOnSurface,3>::Construct )
+,		SchemaEntry("ifcpropertydependencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcvertexbasedtexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcorderaction",&STEP::ObjectHelper<IfcOrderAction,1>::Construct )
+,		SchemaEntry("ifclibraryreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcedgeloop",&STEP::ObjectHelper<IfcEdgeLoop,1>::Construct )
+,		SchemaEntry("ifcannotationfillareaoccurrence",&STEP::ObjectHelper<IfcAnnotationFillAreaOccurrence,2>::Construct )
+,		SchemaEntry("ifcrelconnectsstructuralelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcworkplan",&STEP::ObjectHelper<IfcWorkPlan,0>::Construct )
+,		SchemaEntry("ifcellipse",&STEP::ObjectHelper<IfcEllipse,2>::Construct )
+,		SchemaEntry("ifcproductdefinitionshape",&STEP::ObjectHelper<IfcProductDefinitionShape,0>::Construct )
+,		SchemaEntry("ifcprojectioncurve",&STEP::ObjectHelper<IfcProjectionCurve,0>::Construct )
+,		SchemaEntry("ifcelectricalcircuit",&STEP::ObjectHelper<IfcElectricalCircuit,0>::Construct )
+,		SchemaEntry("ifcrationalbeziercurve",&STEP::ObjectHelper<IfcRationalBezierCurve,1>::Construct )
+,		SchemaEntry("ifcstructuralpointaction",&STEP::ObjectHelper<IfcStructuralPointAction,0>::Construct )
+,		SchemaEntry("ifcservicelifefactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcthermalmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifctexturecoordinategenerator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpipesegmenttype",&STEP::ObjectHelper<IfcPipeSegmentType,1>::Construct )
+,		SchemaEntry("ifctwodirectionrepeatfactor",&STEP::ObjectHelper<IfcTwoDirectionRepeatFactor,1>::Construct )
+,		SchemaEntry("ifcshaperepresentation",&STEP::ObjectHelper<IfcShapeRepresentation,0>::Construct )
+,		SchemaEntry("ifcpropertyset",&STEP::ObjectHelper<IfcPropertySet,1>::Construct )
+,		SchemaEntry("ifcsurfacestylerendering",&STEP::ObjectHelper<IfcSurfaceStyleRendering,8>::Construct )
+,		SchemaEntry("ifcdistributionport",&STEP::ObjectHelper<IfcDistributionPort,1>::Construct )
+,		SchemaEntry("ifcimagetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcpipefittingtype",&STEP::ObjectHelper<IfcPipeFittingType,1>::Construct )
+,		SchemaEntry("ifctransportelement",&STEP::ObjectHelper<IfcTransportElement,3>::Construct )
+,		SchemaEntry("ifcannotationtextoccurrence",&STEP::ObjectHelper<IfcAnnotationTextOccurrence,0>::Construct )
+,		SchemaEntry("ifcconnectionsurfacegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcstructuralanalysismodel",&STEP::ObjectHelper<IfcStructuralAnalysisModel,4>::Construct )
+,		SchemaEntry("ifcconnectioncurvegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcconditioncriterion",&STEP::ObjectHelper<IfcConditionCriterion,2>::Construct )
+,		SchemaEntry("ifcwaterproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifcmateriallayer",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ifccostvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+
+	};
+}
+
+// -----------------------------------------------------------------------------------------------------------
+void IFC::Schema_2x3::GetSchema(EXPRESS::ConversionSchema& out) {
+	out = EXPRESS::ConversionSchema(schema_raw_2x3);
+}
+
+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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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::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`")); }
+    } 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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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::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);
+	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<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<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<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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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`")); }
+    } 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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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);
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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`")); }
+    } 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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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`")); }
+    } 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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<Ifc2DCompositeCurve>(const DB& db, const LIST& params, Ifc2DCompositeCurve* 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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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::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`")); }
+    } while(0);
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, IfcProperty* in)
+{
+	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::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::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`")); }
+    } while(0);
+	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<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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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);
+	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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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<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<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<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<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<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<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<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
+        std::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
+        std::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<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<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<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<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<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
+        std::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
+        std::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 `IfcSpatialStructureElement`")); }
+    } while(0);
+	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<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<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<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<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<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<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<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<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<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
+        std::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 REAL`")); }
+    } while(0);
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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`")); }
+    } while(0);
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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<IfcEdgeFeature>(const DB& db, const LIST& params, IfcEdgeFeature* 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<IfcChamferEdgeFeature>(const DB& db, const LIST& params, IfcChamferEdgeFeature* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEdgeFeature*>(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<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<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<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<IfcSpatialStructureElementType>(const DB& db, const LIST& params, IfcSpatialStructureElementType* 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<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<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<IfcCraneRailAShapeProfileDef>(const DB& db, const LIST& params, IfcCraneRailAShapeProfileDef* 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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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
+        std::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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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
+        std::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
+        std::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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcEquipmentElement>(const DB& db, const LIST& params, IfcEquipmentElement* 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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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 `BOOLEAN`")); }
+    } while(0);
+    do { // convert the 'ParentCurve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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);
+	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<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<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<IfcDraughtingCallout>(const DB& db, const LIST& params, IfcDraughtingCallout* 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<IfcDimensionCurveDirectedCallout>(const DB& db, const LIST& params, IfcDimensionCurveDirectedCallout* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDraughtingCallout*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcLinearDimension>(const DB& db, const LIST& params, IfcLinearDimension* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(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<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<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<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<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<IfcAngularDimension>(const DB& db, const LIST& params, IfcAngularDimension* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	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
+        std::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
+        std::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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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);
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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<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<IfcRadiusDimension>(const DB& db, const LIST& params, IfcRadiusDimension* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::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 IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
+    } while(0);
+    do { // convert the 'InnerRadius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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);
+	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
+        std::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
+        std::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<IfcTimeSeriesSchedule>(const DB& db, const LIST& params, IfcTimeSeriesSchedule* 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<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<IfcProject>(const DB& db, const LIST& params, IfcProject* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
+	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); }    do { // convert the 'LongName' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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 IfcProject to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'Phase' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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 IfcProject to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'RepresentationContexts' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->RepresentationContexts, arg, db ); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcProject to be a `SET [1:?] OF IfcRepresentationContext`")); }
+    } while(0);
+    do { // convert the 'UnitsInContext' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->UnitsInContext, arg, db ); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcProject to be a `IfcUnitAssignment`")); }
+    } while(0);
+	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<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<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<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<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<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<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<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
+        std::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
+        std::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
+        std::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
+        std::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 `BOOLEAN`")); }
+    } while(0);
+    do { // convert the 'MasterRepresentation' argument
+        std::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<IfcRelDefines>(const DB& db, const LIST& params, IfcRelDefines* in)
+{
+	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::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);
+	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 'RelatingPropertyDefinition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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<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<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<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<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<IfcSpaceHeaterType>(const DB& db, const LIST& params, IfcSpaceHeaterType* 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<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<IfcBuildingElementComponent>(const DB& db, const LIST& params, IfcBuildingElementComponent* 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<IfcReinforcingElement>(const DB& db, const LIST& params, IfcReinforcingElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementComponent*>(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<IfcElectricHeaterType>(const DB& db, const LIST& params, IfcElectricHeaterType* 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<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<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<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<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<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<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<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<IfcRelDecomposes>(const DB& db, const LIST& params, IfcRelDecomposes* in)
+{
+	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::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::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);
+	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<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
+        std::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<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<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<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<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
+        std::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
+        std::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<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<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<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
+        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::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::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);
+	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<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<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<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<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<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<IfcSpatialStructureElement>(const DB& db, const LIST& params, IfcSpatialStructureElement* in)
+{
+	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::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::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);
+	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
+        std::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
+        std::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
+        std::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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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<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<IfcIShapeProfileDef>(const DB& db, const LIST& params, IfcIShapeProfileDef* in)
+{
+	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::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::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::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::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::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`")); }
+    } 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<IfcIShapeProfileDef*>(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<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<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<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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::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<IfcFurnitureStandard>(const DB& db, const LIST& params, IfcFurnitureStandard* 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<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<IfcDoor>(const DB& db, const LIST& params, IfcDoor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
+	if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcDoor"); }    do { // convert the 'OverallHeight' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAnnotationOccurrence>(const DB& db, const LIST& params, IfcAnnotationOccurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStyledItem*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcAnnotationSymbolOccurrence>(const DB& db, const LIST& params, IfcAnnotationSymbolOccurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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));
+// 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
+        std::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
+        std::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<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<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<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
+        std::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
+        std::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<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<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<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<IfcSurfaceStyleShading>(const DB& db, const LIST& params, IfcSurfaceStyleShading* in)
+{
+	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::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);
+	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<IfcDefinedSymbol>(const DB& db, const LIST& params, IfcDefinedSymbol* 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<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<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<IfcMechanicalFastenerType>(const DB& db, const LIST& params, IfcMechanicalFastenerType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFastenerType*>(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<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;
+}
+// -----------------------------------------------------------------------------------------------------------
+
+} // ! STEP
+} // ! Assimp
+
+#if _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
new file mode 100644
index 0000000..0d70511
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
@@ -0,0 +1,1927 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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.
+
+----------------------------------------------------------------------
+*/
+
+//#include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "IFCReaderGen_2x3.h"
+
+#if _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4702)
+#endif // _MSC_VER
+
+namespace Assimp {
+using namespace IFC;
+using namespace ::Assimp::IFC::Schema_2x3;
+
+namespace STEP {
+
+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
+        std::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
+        std::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<IfcAnnotationSurface>(const DB& db, const LIST& params, IfcAnnotationSurface* 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<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<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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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);
+	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<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<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<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<IfcColourSpecification>(const DB& db, const LIST& params, IfcColourSpecification* in)
+{
+	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::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`")); }
+    } while(0);
+	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
+        std::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
+        std::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<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<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
+        std::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
+        std::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
+        std::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<IfcStructuralPlanarAction>(const DB& db, const LIST& params, IfcStructuralPlanarAction* 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<IfcStructuralPlanarActionVarying>(const DB& db, const LIST& params, IfcStructuralPlanarActionVarying* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralPlanarAction*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	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
+        std::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
+        std::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
+        std::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
+        std::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
+        std::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<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<IfcVibrationIsolatorType>(const DB& db, const LIST& params, IfcVibrationIsolatorType* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDiscreteAccessoryType*>(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<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<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<IfcStructuredDimensionCallout>(const DB& db, const LIST& params, IfcStructuredDimensionCallout* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDraughtingCallout*>(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<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<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<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<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<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<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<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<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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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::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::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);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcBezierCurve>(const DB& db, const LIST& params, IfcBezierCurve* 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<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<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<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<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
+        std::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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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<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<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<IfcRelVoidsElement>(const DB& db, const LIST& params, IfcRelVoidsElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); }    do { // convert the 'RelatingBuildingElement' argument
+        std::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
+        std::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<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<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
+        std::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 `REAL`")); }
+    } while(0);
+    do { // convert the 'Scale3' argument
+        std::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 `REAL`")); }
+    } while(0);
+	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<IfcEquipmentStandard>(const DB& db, const LIST& params, IfcEquipmentStandard* 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<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<IfcDiameterDimension>(const DB& db, const LIST& params, IfcDiameterDimension* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(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<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<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<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<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<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<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
+        std::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<IfcSpaceProgram>(const DB& db, const LIST& params, IfcSpaceProgram* 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<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
+        std::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<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<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<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
+        std::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<IfcTerminatorSymbol>(const DB& db, const LIST& params, IfcTerminatorSymbol* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationSymbolOccurrence*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDimensionCurveTerminator>(const DB& db, const LIST& params, IfcDimensionCurveTerminator* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTerminatorSymbol*>(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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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`")); }
+    } 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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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::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::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`")); }
+    } while(0);
+	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<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
+        std::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
+        std::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<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<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<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
+        std::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<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<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<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<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<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<IfcScheduleTimeControl>(const DB& db, const LIST& params, IfcScheduleTimeControl* 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<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
+        std::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
+        std::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<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<IfcBuildingElementPart>(const DB& db, const LIST& params, IfcBuildingElementPart* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementComponent*>(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<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<IfcOpeningElement>(const DB& db, const LIST& params, IfcOpeningElement* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
+	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcOpeningElement"); }	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<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<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<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<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<IfcProjectOrderRecord>(const DB& db, const LIST& params, IfcProjectOrderRecord* 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<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<IfcMechanicalFastener>(const DB& db, const LIST& params, IfcMechanicalFastener* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcFastener*>(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<IfcZone>(const DB& db, const LIST& params, IfcZone* 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<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<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<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<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<IfcRelOverridesProperties>(const DB& db, const LIST& params, IfcRelOverridesProperties* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcRelDefinesByProperties*>(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
+        std::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
+        std::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<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<IfcServiceLife>(const DB& db, const LIST& params, IfcServiceLife* 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<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<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<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<IfcFacetedBrepWithVoids>(const DB& db, const LIST& params, IfcFacetedBrepWithVoids* 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<IfcGasTerminalType>(const DB& db, const LIST& params, IfcGasTerminalType* 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<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<IfcFillAreaStyleTileSymbolWithStyle>(const DB& db, const LIST& params, IfcFillAreaStyleTileSymbolWithStyle* 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<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<IfcAnnotationCurveOccurrence>(const DB& db, const LIST& params, IfcAnnotationCurveOccurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcDimensionCurve>(const DB& db, const LIST& params, IfcDimensionCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationCurveOccurrence*>(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<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"); }	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
+        std::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<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<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<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<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<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<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
+        std::shared_ptr<const DataType> arg = params[base++];
+        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::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);
+	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<IfcOneDirectionRepeatFactor>(const DB& db, const LIST& params, IfcOneDirectionRepeatFactor* 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<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<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<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
+        std::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
+        std::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<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<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<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<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<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<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<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
+        std::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<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<IfcCraneRailFShapeProfileDef>(const DB& db, const LIST& params, IfcCraneRailFShapeProfileDef* 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<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<IfcElementQuantity>(const DB& db, const LIST& params, IfcElementQuantity* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
+	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); }    do { // convert the 'MethodOfMeasurement' argument
+        std::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
+        std::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<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<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<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<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<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<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<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<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<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
+        std::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<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<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<IfcCondition>(const DB& db, const LIST& params, IfcCondition* 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<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<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 'InteriorOrExteriorSpace' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcInternalOrExternalEnum`")); }
+    } while(0);
+    do { // convert the 'ElevationWithFlooring' argument
+        std::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<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<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<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<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<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<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<IfcElectricalElement>(const DB& db, const LIST& params, IfcElectricalElement* 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<IfcSurfaceStyleWithTextures>(const DB& db, const LIST& params, IfcSurfaceStyleWithTextures* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); }    do { // convert the 'Textures' argument
+        std::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<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
+        std::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
+        std::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
+        std::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
+        std::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<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<IfcMove>(const DB& db, const LIST& params, IfcMove* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTask*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	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
+        std::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<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<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<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<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<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<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<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<IfcStructuralLinearAction>(const DB& db, const LIST& params, IfcStructuralLinearAction* 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<IfcStructuralLinearActionVarying>(const DB& db, const LIST& params, IfcStructuralLinearActionVarying* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcStructuralLinearAction*>(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<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<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
+        std::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 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
+    } while(0);
+    do { // convert the 'ConversionFactor' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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<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<IfcAnnotationSurfaceOccurrence>(const DB& db, const LIST& params, IfcAnnotationSurfaceOccurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcRoundedEdgeFeature>(const DB& db, const LIST& params, IfcRoundedEdgeFeature* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcEdgeFeature*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricDistributionPoint>(const DB& db, const LIST& params, IfcElectricDistributionPoint* 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<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<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<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<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<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<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<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<IfcOrderAction>(const DB& db, const LIST& params, IfcOrderAction* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcTask*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	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<IfcAnnotationFillAreaOccurrence>(const DB& db, const LIST& params, IfcAnnotationFillAreaOccurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(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<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
+        std::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
+        std::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<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<IfcProjectionCurve>(const DB& db, const LIST& params, IfcProjectionCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationCurveOccurrence*>(in));
+// this data structure is not used yet, so there is no code generated to fill its members
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<IfcElectricalCircuit>(const DB& db, const LIST& params, IfcElectricalCircuit* 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<IfcRationalBezierCurve>(const DB& db, const LIST& params, IfcRationalBezierCurve* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcBezierCurve*>(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<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<IfcTwoDirectionRepeatFactor>(const DB& db, const LIST& params, IfcTwoDirectionRepeatFactor* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcOneDirectionRepeatFactor*>(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<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
+        std::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<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 'Transparency' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        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 IfcSurfaceStyleRendering to be a `IfcNormalisedRatioMeasure`")); }
+    } while(0);
+    do { // convert the 'DiffuseColour' argument
+        std::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
+        std::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
+        std::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
+        std::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
+        std::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
+        std::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
+        std::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<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<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<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<IfcAnnotationTextOccurrence>(const DB& db, const LIST& params, IfcAnnotationTextOccurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(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<IfcConditionCriterion>(const DB& db, const LIST& params, IfcConditionCriterion* 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;
+}
+
+} // ! STEP
+} // ! Assimp
+
+#if _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h
new file mode 100644
index 0000000..f87f121
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h
@@ -0,0 +1,4380 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 "AssetLib/Step/STEPFile.h"
+
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning( disable : 4512 )
+#endif // _MSC_VER
+
+namespace Assimp {
+namespace IFC {
+    namespace Schema_2x3 {
+
+    using namespace STEP;
+    using namespace STEP::EXPRESS;
+
+
+    struct NotImplemented : public ObjectHelper<NotImplemented,0> {
+
+    };
+
+
+    // ******************************************************************************
+    // IFC Custom data types
+    // ******************************************************************************
+
+
+    // 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 IfcAreaMeasure
+    typedef REAL IfcAreaMeasure;
+    // C++ wrapper type for IfcBoolean
+    typedef BOOLEAN IfcBoolean;
+    // C++ wrapper type for IfcBoxAlignment
+    typedef STRING IfcBoxAlignment;
+    // C++ wrapper type for IfcCompoundPlaneAngleMeasure
+    typedef ListOf< INTEGER, 3, 3 > 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 IfcDayInMonthNumber
+    typedef INTEGER IfcDayInMonthNumber;
+    // C++ wrapper type for IfcDaylightSavingHour
+    typedef INTEGER IfcDaylightSavingHour;
+    // 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 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 IfcHourInDay
+    typedef INTEGER IfcHourInDay;
+    // 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 IfcLengthMeasure
+    typedef REAL IfcLengthMeasure;
+    // 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 IfcMinuteInHour
+    typedef INTEGER IfcMinuteInHour;
+    // 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 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 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 IfcSecondInMinute
+    typedef REAL IfcSecondInMinute;
+    // 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 IfcSoundPowerMeasure
+    typedef REAL IfcSoundPowerMeasure;
+    // 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 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 IfcTimeMeasure
+    typedef REAL IfcTimeMeasure;
+    // C++ wrapper type for IfcTimeStamp
+    typedef INTEGER IfcTimeStamp;
+    // C++ wrapper type for IfcTorqueMeasure
+    typedef REAL IfcTorqueMeasure;
+    // 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 IfcYearNumber
+    typedef INTEGER IfcYearNumber;
+    // 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 IfcAheadOrBehind
+    typedef ENUMERATION IfcAheadOrBehind;
+    // 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 IfcBSplineCurveForm
+    typedef ENUMERATION IfcBSplineCurveForm;
+    // 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 IfcBuildingElementProxyTypeEnum
+    typedef ENUMERATION IfcBuildingElementProxyTypeEnum;
+    // C++ wrapper type for IfcCableCarrierFittingTypeEnum
+    typedef ENUMERATION IfcCableCarrierFittingTypeEnum;
+    // C++ wrapper type for IfcCableCarrierSegmentTypeEnum
+    typedef ENUMERATION IfcCableCarrierSegmentTypeEnum;
+    // 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 IfcCoilTypeEnum
+    typedef ENUMERATION IfcCoilTypeEnum;
+    // C++ wrapper type for IfcColumnTypeEnum
+    typedef ENUMERATION IfcColumnTypeEnum;
+    // 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 IfcControllerTypeEnum
+    typedef ENUMERATION IfcControllerTypeEnum;
+    // C++ wrapper type for IfcCooledBeamTypeEnum
+    typedef ENUMERATION IfcCooledBeamTypeEnum;
+    // C++ wrapper type for IfcCoolingTowerTypeEnum
+    typedef ENUMERATION IfcCoolingTowerTypeEnum;
+    // C++ wrapper type for IfcCostScheduleTypeEnum
+    typedef ENUMERATION IfcCostScheduleTypeEnum;
+    // C++ wrapper type for IfcCoveringTypeEnum
+    typedef ENUMERATION IfcCoveringTypeEnum;
+    // C++ wrapper type for IfcCurrencyEnum
+    typedef ENUMERATION IfcCurrencyEnum;
+    // C++ wrapper type for IfcCurtainWallTypeEnum
+    typedef ENUMERATION IfcCurtainWallTypeEnum;
+    // 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 IfcDimensionExtentUsage
+    typedef ENUMERATION IfcDimensionExtentUsage;
+    // C++ wrapper type for IfcDirectionSenseEnum
+    typedef ENUMERATION IfcDirectionSenseEnum;
+    // C++ wrapper type for IfcDistributionChamberElementTypeEnum
+    typedef ENUMERATION IfcDistributionChamberElementTypeEnum;
+    // 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 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 IfcElectricCurrentEnum
+    typedef ENUMERATION IfcElectricCurrentEnum;
+    // C++ wrapper type for IfcElectricDistributionPointFunctionEnum
+    typedef ENUMERATION IfcElectricDistributionPointFunctionEnum;
+    // C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum
+    typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum;
+    // C++ wrapper type for IfcElectricGeneratorTypeEnum
+    typedef ENUMERATION IfcElectricGeneratorTypeEnum;
+    // C++ wrapper type for IfcElectricHeaterTypeEnum
+    typedef ENUMERATION IfcElectricHeaterTypeEnum;
+    // 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 IfcEnergySequenceEnum
+    typedef ENUMERATION IfcEnergySequenceEnum;
+    // C++ wrapper type for IfcEnvironmentalImpactCategoryEnum
+    typedef ENUMERATION IfcEnvironmentalImpactCategoryEnum;
+    // C++ wrapper type for IfcEvaporativeCoolerTypeEnum
+    typedef ENUMERATION IfcEvaporativeCoolerTypeEnum;
+    // C++ wrapper type for IfcEvaporatorTypeEnum
+    typedef ENUMERATION IfcEvaporatorTypeEnum;
+    // C++ wrapper type for IfcFanTypeEnum
+    typedef ENUMERATION IfcFanTypeEnum;
+    // 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 IfcGasTerminalTypeEnum
+    typedef ENUMERATION IfcGasTerminalTypeEnum;
+    // C++ wrapper type for IfcGeometricProjectionEnum
+    typedef ENUMERATION IfcGeometricProjectionEnum;
+    // C++ wrapper type for IfcGlobalOrLocalEnum
+    typedef ENUMERATION IfcGlobalOrLocalEnum;
+    // C++ wrapper type for IfcHeatExchangerTypeEnum
+    typedef ENUMERATION IfcHeatExchangerTypeEnum;
+    // C++ wrapper type for IfcHumidifierTypeEnum
+    typedef ENUMERATION IfcHumidifierTypeEnum;
+    // 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 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 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 IfcOutletTypeEnum
+    typedef ENUMERATION IfcOutletTypeEnum;
+    // C++ wrapper type for IfcPermeableCoveringOperationEnum
+    typedef ENUMERATION IfcPermeableCoveringOperationEnum;
+    // 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 IfcProcedureTypeEnum
+    typedef ENUMERATION IfcProcedureTypeEnum;
+    // C++ wrapper type for IfcProfileTypeEnum
+    typedef ENUMERATION IfcProfileTypeEnum;
+    // C++ wrapper type for IfcProjectOrderRecordTypeEnum
+    typedef ENUMERATION IfcProjectOrderRecordTypeEnum;
+    // C++ wrapper type for IfcProjectOrderTypeEnum
+    typedef ENUMERATION IfcProjectOrderTypeEnum;
+    // C++ wrapper type for IfcProjectedOrTrueLengthEnum
+    typedef ENUMERATION IfcProjectedOrTrueLengthEnum;
+    // C++ wrapper type for IfcPropertySourceEnum
+    typedef ENUMERATION IfcPropertySourceEnum;
+    // 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 IfcReflectanceMethodEnum
+    typedef ENUMERATION IfcReflectanceMethodEnum;
+    // C++ wrapper type for IfcReinforcingBarRoleEnum
+    typedef ENUMERATION IfcReinforcingBarRoleEnum;
+    // C++ wrapper type for IfcReinforcingBarSurfaceEnum
+    typedef ENUMERATION IfcReinforcingBarSurfaceEnum;
+    // C++ wrapper type for IfcResourceConsumptionEnum
+    typedef ENUMERATION IfcResourceConsumptionEnum;
+    // C++ wrapper type for IfcRibPlateDirectionEnum
+    typedef ENUMERATION IfcRibPlateDirectionEnum;
+    // 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 IfcServiceLifeFactorTypeEnum
+    typedef ENUMERATION IfcServiceLifeFactorTypeEnum;
+    // C++ wrapper type for IfcServiceLifeTypeEnum
+    typedef ENUMERATION IfcServiceLifeTypeEnum;
+    // C++ wrapper type for IfcSlabTypeEnum
+    typedef ENUMERATION IfcSlabTypeEnum;
+    // C++ wrapper type for IfcSoundScaleEnum
+    typedef ENUMERATION IfcSoundScaleEnum;
+    // C++ wrapper type for IfcSpaceHeaterTypeEnum
+    typedef ENUMERATION IfcSpaceHeaterTypeEnum;
+    // C++ wrapper type for IfcSpaceTypeEnum
+    typedef ENUMERATION IfcSpaceTypeEnum;
+    // 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 IfcStructuralCurveTypeEnum
+    typedef ENUMERATION IfcStructuralCurveTypeEnum;
+    // C++ wrapper type for IfcStructuralSurfaceTypeEnum
+    typedef ENUMERATION IfcStructuralSurfaceTypeEnum;
+    // C++ wrapper type for IfcSurfaceSide
+    typedef ENUMERATION IfcSurfaceSide;
+    // C++ wrapper type for IfcSurfaceTextureEnum
+    typedef ENUMERATION IfcSurfaceTextureEnum;
+    // C++ wrapper type for IfcSwitchingDeviceTypeEnum
+    typedef ENUMERATION IfcSwitchingDeviceTypeEnum;
+    // C++ wrapper type for IfcTankTypeEnum
+    typedef ENUMERATION IfcTankTypeEnum;
+    // C++ wrapper type for IfcTendonTypeEnum
+    typedef ENUMERATION IfcTendonTypeEnum;
+    // C++ wrapper type for IfcTextPath
+    typedef ENUMERATION IfcTextPath;
+    // C++ wrapper type for IfcThermalLoadSourceEnum
+    typedef ENUMERATION IfcThermalLoadSourceEnum;
+    // C++ wrapper type for IfcThermalLoadTypeEnum
+    typedef ENUMERATION IfcThermalLoadTypeEnum;
+    // C++ wrapper type for IfcTimeSeriesDataTypeEnum
+    typedef ENUMERATION IfcTimeSeriesDataTypeEnum;
+    // C++ wrapper type for IfcTimeSeriesScheduleTypeEnum
+    typedef ENUMERATION IfcTimeSeriesScheduleTypeEnum;
+    // 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 IfcUnitaryEquipmentTypeEnum
+    typedef ENUMERATION IfcUnitaryEquipmentTypeEnum;
+    // C++ wrapper type for IfcValveTypeEnum
+    typedef ENUMERATION IfcValveTypeEnum;
+    // C++ wrapper type for IfcVibrationIsolatorTypeEnum
+    typedef ENUMERATION IfcVibrationIsolatorTypeEnum;
+    // 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 IfcWorkControlTypeEnum
+    typedef ENUMERATION IfcWorkControlTypeEnum;
+    // 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 IfcBooleanOperand
+    typedef SELECT IfcBooleanOperand;
+    // C++ wrapper type for IfcCharacterStyleSelect
+    typedef SELECT IfcCharacterStyleSelect;
+    // C++ wrapper type for IfcClassificationNotationSelect
+    typedef SELECT IfcClassificationNotationSelect;
+    // C++ wrapper type for IfcColour
+    typedef SELECT IfcColour;
+    // C++ wrapper type for IfcColourOrFactor
+    typedef SELECT IfcColourOrFactor;
+    // C++ wrapper type for IfcConditionCriterionSelect
+    typedef SELECT IfcConditionCriterionSelect;
+    // C++ wrapper type for IfcCsgSelect
+    typedef SELECT IfcCsgSelect;
+    // C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect
+    typedef SELECT IfcCurveFontOrScaledCurveFontSelect;
+    // C++ wrapper type for IfcCurveOrEdgeCurve
+    typedef SELECT IfcCurveOrEdgeCurve;
+    // C++ wrapper type for IfcCurveStyleFontSelect
+    typedef SELECT IfcCurveStyleFontSelect;
+    // C++ wrapper type for IfcDateTimeSelect
+    typedef SELECT IfcDateTimeSelect;
+    // C++ wrapper type for IfcDefinedSymbolSelect
+    typedef SELECT IfcDefinedSymbolSelect;
+    // C++ wrapper type for IfcDerivedMeasureValue
+    typedef SELECT IfcDerivedMeasureValue;
+    // C++ wrapper type for IfcDocumentSelect
+    typedef SELECT IfcDocumentSelect;
+    // C++ wrapper type for IfcDraughtingCalloutElement
+    typedef SELECT IfcDraughtingCalloutElement;
+    // C++ wrapper type for IfcFillAreaStyleTileShapeSelect
+    typedef SELECT IfcFillAreaStyleTileShapeSelect;
+    // C++ wrapper type for IfcFillStyleSelect
+    typedef SELECT IfcFillStyleSelect;
+    // C++ wrapper type for IfcGeometricSetSelect
+    typedef SELECT IfcGeometricSetSelect;
+    // 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 IfcObjectReferenceSelect
+    typedef SELECT IfcObjectReferenceSelect;
+    // C++ wrapper type for IfcOrientationSelect
+    typedef SELECT IfcOrientationSelect;
+    // C++ wrapper type for IfcPointOrVertexPoint
+    typedef SELECT IfcPointOrVertexPoint;
+    // C++ wrapper type for IfcPresentationStyleSelect
+    typedef SELECT IfcPresentationStyleSelect;
+    // 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 IfcSpecularHighlightSelect
+    typedef SELECT IfcSpecularHighlightSelect;
+    // C++ wrapper type for IfcStructuralActivityAssignmentSelect
+    typedef SELECT IfcStructuralActivityAssignmentSelect;
+    // C++ wrapper type for IfcSurfaceOrFaceSurface
+    typedef SELECT IfcSurfaceOrFaceSurface;
+    // C++ wrapper type for IfcSurfaceStyleElementSelect
+    typedef SELECT IfcSurfaceStyleElementSelect;
+    // C++ wrapper type for IfcSymbolStyleSelect
+    typedef SELECT IfcSymbolStyleSelect;
+    // C++ wrapper type for IfcTextFontSelect
+    typedef SELECT IfcTextFontSelect;
+    // C++ wrapper type for IfcTextStyleSelect
+    typedef SELECT IfcTextStyleSelect;
+    // 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;
+
+
+    // ******************************************************************************
+    // IFC Entities
+    // ******************************************************************************
+
+    struct IfcRepresentationItem;
+    struct IfcGeometricRepresentationItem;
+    struct IfcCurve;
+    struct IfcBoundedCurve;
+    struct IfcCompositeCurve;
+    struct Ifc2DCompositeCurve;
+    struct IfcRoot;
+    struct IfcObjectDefinition;
+    struct IfcObject;
+    struct IfcControl;
+    struct IfcActionRequest;
+    struct IfcActor;
+    typedef NotImplemented IfcActorRole; // (not currently used by Assimp)
+    struct IfcTypeObject;
+    struct IfcTypeProduct;
+    struct IfcElementType;
+    struct IfcDistributionElementType;
+    struct IfcDistributionControlElementType;
+    struct IfcActuatorType;
+    typedef NotImplemented IfcAddress; // (not currently used by Assimp)
+    struct IfcDistributionFlowElementType;
+    struct IfcFlowControllerType;
+    struct IfcAirTerminalBoxType;
+    struct IfcFlowTerminalType;
+    struct IfcAirTerminalType;
+    struct IfcEnergyConversionDeviceType;
+    struct IfcAirToAirHeatRecoveryType;
+    struct IfcAlarmType;
+    struct IfcDraughtingCallout;
+    struct IfcDimensionCurveDirectedCallout;
+    struct IfcAngularDimension;
+    struct IfcProduct;
+    struct IfcAnnotation;
+    struct IfcStyledItem;
+    struct IfcAnnotationOccurrence;
+    struct IfcAnnotationCurveOccurrence;
+    struct IfcAnnotationFillArea;
+    struct IfcAnnotationFillAreaOccurrence;
+    struct IfcAnnotationSurface;
+    struct IfcAnnotationSurfaceOccurrence;
+    struct IfcAnnotationSymbolOccurrence;
+    struct IfcAnnotationTextOccurrence;
+    typedef NotImplemented IfcApplication; // (not currently used by Assimp)
+    typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp)
+    typedef NotImplemented IfcAppliedValueRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcApproval; // (not currently used by Assimp)
+    typedef NotImplemented IfcApprovalActorRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcApprovalPropertyRelationship; // (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 IfcIShapeProfileDef;
+    struct IfcAsymmetricIShapeProfileDef;
+    struct IfcPlacement;
+    struct IfcAxis1Placement;
+    struct IfcAxis2Placement2D;
+    struct IfcAxis2Placement3D;
+    struct IfcBSplineCurve;
+    struct IfcElement;
+    struct IfcBuildingElement;
+    struct IfcBeam;
+    struct IfcBuildingElementType;
+    struct IfcBeamType;
+    struct IfcBezierCurve;
+    typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp)
+    typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp)
+    struct IfcCsgPrimitive3D;
+    struct IfcBlock;
+    struct IfcBoilerType;
+    struct IfcBooleanResult;
+    struct IfcBooleanClippingResult;
+    typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp)
+    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 IfcSurface;
+    struct IfcBoundedSurface;
+    struct IfcBoundingBox;
+    struct IfcHalfSpaceSolid;
+    struct IfcBoxedHalfSpace;
+    struct IfcSpatialStructureElement;
+    struct IfcBuilding;
+    struct IfcBuildingElementComponent;
+    struct IfcBuildingElementPart;
+    struct IfcBuildingElementProxy;
+    struct IfcBuildingElementProxyType;
+    struct IfcBuildingStorey;
+    struct IfcCShapeProfileDef;
+    struct IfcFlowFittingType;
+    struct IfcCableCarrierFittingType;
+    struct IfcFlowSegmentType;
+    struct IfcCableCarrierSegmentType;
+    struct IfcCableSegmentType;
+    typedef NotImplemented IfcCalendarDate; // (not currently used by Assimp)
+    struct IfcPoint;
+    struct IfcCartesianPoint;
+    struct IfcCartesianTransformationOperator;
+    struct IfcCartesianTransformationOperator2D;
+    struct IfcCartesianTransformationOperator2DnonUniform;
+    struct IfcCartesianTransformationOperator3D;
+    struct IfcCartesianTransformationOperator3DnonUniform;
+    struct IfcCenterLineProfileDef;
+    struct IfcFeatureElement;
+    struct IfcFeatureElementSubtraction;
+    struct IfcEdgeFeature;
+    struct IfcChamferEdgeFeature;
+    struct IfcChillerType;
+    struct IfcConic;
+    struct IfcCircle;
+    struct IfcCircleProfileDef;
+    struct IfcCircleHollowProfileDef;
+    typedef NotImplemented IfcClassification; // (not currently used by Assimp)
+    typedef NotImplemented IfcClassificationItem; // (not currently used by Assimp)
+    typedef NotImplemented IfcClassificationItemRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcClassificationNotation; // (not currently used by Assimp)
+    typedef NotImplemented IfcClassificationNotationFacet; // (not currently used by Assimp)
+    typedef NotImplemented IfcExternalReference; // (not currently used by Assimp)
+    typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp)
+    struct IfcTopologicalRepresentationItem;
+    struct IfcConnectedFaceSet;
+    struct IfcClosedShell;
+    struct IfcCoilType;
+    struct IfcColourSpecification;
+    struct IfcColourRgb;
+    struct IfcColumn;
+    struct IfcColumnType;
+    struct IfcProperty;
+    struct IfcComplexProperty;
+    struct IfcCompositeCurveSegment;
+    struct IfcCompositeProfileDef;
+    struct IfcFlowMovingDeviceType;
+    struct IfcCompressorType;
+    struct IfcCondenserType;
+    struct IfcCondition;
+    struct IfcConditionCriterion;
+    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 IfcConnectionPortGeometry; // (not currently used by Assimp)
+    typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp)
+    typedef NotImplemented IfcConstraint; // (not currently used by Assimp)
+    typedef NotImplemented IfcConstraintAggregationRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcConstraintClassificationRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcConstraintRelationship; // (not currently used by Assimp)
+    struct IfcResource;
+    struct IfcConstructionResource;
+    struct IfcConstructionEquipmentResource;
+    struct IfcConstructionMaterialResource;
+    struct IfcConstructionProductResource;
+    struct IfcNamedUnit;
+    struct IfcContextDependentUnit;
+    struct IfcControllerType;
+    struct IfcConversionBasedUnit;
+    struct IfcCooledBeamType;
+    struct IfcCoolingTowerType;
+    typedef NotImplemented IfcCoordinatedUniversalTimeOffset; // (not currently used by Assimp)
+    struct IfcCostItem;
+    struct IfcCostSchedule;
+    typedef NotImplemented IfcCostValue; // (not currently used by Assimp)
+    struct IfcCovering;
+    struct IfcCoveringType;
+    struct IfcCraneRailAShapeProfileDef;
+    struct IfcCraneRailFShapeProfileDef;
+    struct IfcCrewResource;
+    struct IfcSolidModel;
+    struct IfcCsgSolid;
+    typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp)
+    struct IfcCurtainWall;
+    struct IfcCurtainWallType;
+    struct IfcCurveBoundedPlane;
+    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 IfcDamperType;
+    typedef NotImplemented IfcDateAndTime; // (not currently used by Assimp)
+    struct IfcDefinedSymbol;
+    struct IfcDerivedProfileDef;
+    typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp)
+    typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp)
+    struct IfcDiameterDimension;
+    typedef NotImplemented IfcDraughtingCalloutRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcDimensionCalloutRelationship; // (not currently used by Assimp)
+    struct IfcDimensionCurve;
+    struct IfcTerminatorSymbol;
+    struct IfcDimensionCurveTerminator;
+    typedef NotImplemented IfcDimensionPair; // (not currently used by Assimp)
+    typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp)
+    struct IfcDirection;
+    struct IfcElementComponent;
+    struct IfcDiscreteAccessory;
+    struct IfcElementComponentType;
+    struct IfcDiscreteAccessoryType;
+    struct IfcDistributionElement;
+    struct IfcDistributionFlowElement;
+    struct IfcDistributionChamberElement;
+    struct IfcDistributionChamberElementType;
+    struct IfcDistributionControlElement;
+    struct IfcPort;
+    struct IfcDistributionPort;
+    typedef NotImplemented IfcDocumentElectronicFormat; // (not currently used by Assimp)
+    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 IfcPropertyDefinition;
+    struct IfcPropertySetDefinition;
+    typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp)
+    struct IfcDoorStyle;
+    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)
+    typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp)
+    typedef NotImplemented IfcDraughtingPreDefinedTextFont; // (not currently used by Assimp)
+    struct IfcDuctFittingType;
+    struct IfcDuctSegmentType;
+    struct IfcFlowTreatmentDeviceType;
+    struct IfcDuctSilencerType;
+    struct IfcEdge;
+    struct IfcEdgeCurve;
+    struct IfcLoop;
+    struct IfcEdgeLoop;
+    struct IfcElectricApplianceType;
+    struct IfcFlowController;
+    struct IfcElectricDistributionPoint;
+    struct IfcFlowStorageDeviceType;
+    struct IfcElectricFlowStorageDeviceType;
+    struct IfcElectricGeneratorType;
+    struct IfcElectricHeaterType;
+    struct IfcElectricMotorType;
+    struct IfcElectricTimeControlType;
+    typedef NotImplemented IfcEnergyProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcElectricalBaseProperties; // (not currently used by Assimp)
+    struct IfcSystem;
+    struct IfcElectricalCircuit;
+    struct IfcElectricalElement;
+    struct IfcElementAssembly;
+    struct IfcElementQuantity;
+    struct IfcElementarySurface;
+    struct IfcEllipse;
+    struct IfcEllipseProfileDef;
+    struct IfcEnergyConversionDevice;
+    typedef NotImplemented IfcEnvironmentalImpactValue; // (not currently used by Assimp)
+    struct IfcEquipmentElement;
+    struct IfcEquipmentStandard;
+    struct IfcEvaporativeCoolerType;
+    struct IfcEvaporatorType;
+    typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcExtendedMaterialProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp)
+    typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp)
+    typedef NotImplemented IfcExternallyDefinedSymbol; // (not currently used by Assimp)
+    typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp)
+    struct IfcSweptAreaSolid;
+    struct IfcExtrudedAreaSolid;
+    struct IfcFace;
+    struct IfcFaceBasedSurfaceModel;
+    struct IfcFaceBound;
+    struct IfcFaceOuterBound;
+    struct IfcFaceSurface;
+    struct IfcManifoldSolidBrep;
+    struct IfcFacetedBrep;
+    struct IfcFacetedBrepWithVoids;
+    typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp)
+    typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp)
+    struct IfcFanType;
+    struct IfcFastener;
+    struct IfcFastenerType;
+    struct IfcFeatureElementAddition;
+    typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp)
+    struct IfcFillAreaStyleHatching;
+    struct IfcFillAreaStyleTileSymbolWithStyle;
+    struct IfcFillAreaStyleTiles;
+    struct IfcFilterType;
+    struct IfcFireSuppressionTerminalType;
+    struct IfcFlowFitting;
+    struct IfcFlowInstrumentType;
+    struct IfcFlowMeterType;
+    struct IfcFlowMovingDevice;
+    struct IfcFlowSegment;
+    struct IfcFlowStorageDevice;
+    struct IfcFlowTerminal;
+    struct IfcFlowTreatmentDevice;
+    typedef NotImplemented IfcFluidFlowProperties; // (not currently used by Assimp)
+    struct IfcFooting;
+    typedef NotImplemented IfcFuelProperties; // (not currently used by Assimp)
+    struct IfcFurnishingElement;
+    struct IfcFurnishingElementType;
+    struct IfcFurnitureStandard;
+    struct IfcFurnitureType;
+    struct IfcGasTerminalType;
+    typedef NotImplemented IfcGeneralMaterialProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcGeneralProfileProperties; // (not currently used by Assimp)
+    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 IfcHeatExchangerType;
+    struct IfcHumidifierType;
+    typedef NotImplemented IfcHygroscopicMaterialProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcImageTexture; // (not currently used by Assimp)
+    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 IfcJunctionBoxType;
+    struct IfcLShapeProfileDef;
+    struct IfcLaborResource;
+    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 IfcLightFixtureType;
+    typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp)
+    struct IfcLightSource;
+    struct IfcLightSourceAmbient;
+    struct IfcLightSourceDirectional;
+    struct IfcLightSourceGoniometric;
+    struct IfcLightSourcePositional;
+    struct IfcLightSourceSpot;
+    struct IfcLine;
+    struct IfcLinearDimension;
+    struct IfcLocalPlacement;
+    typedef NotImplemented IfcLocalTime; // (not currently used by Assimp)
+    struct IfcMappedItem;
+    typedef NotImplemented IfcMaterial; // (not currently used by Assimp)
+    typedef NotImplemented IfcMaterialClassificationRelationship; // (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 IfcMaterialLayerSetUsage; // (not currently used by Assimp)
+    typedef NotImplemented IfcMaterialList; // (not currently used by Assimp)
+    struct IfcMeasureWithUnit;
+    typedef NotImplemented IfcMechanicalMaterialProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcMechanicalConcreteMaterialProperties; // (not currently used by Assimp)
+    struct IfcMechanicalFastener;
+    struct IfcMechanicalFastenerType;
+    typedef NotImplemented IfcMechanicalSteelMaterialProperties; // (not currently used by Assimp)
+    struct IfcMember;
+    struct IfcMemberType;
+    typedef NotImplemented IfcMetric; // (not currently used by Assimp)
+    typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp)
+    struct IfcMotorConnectionType;
+    struct IfcProcess;
+    struct IfcTask;
+    struct IfcMove;
+    typedef NotImplemented IfcObjective; // (not currently used by Assimp)
+    struct IfcOccupant;
+    struct IfcOffsetCurve2D;
+    struct IfcOffsetCurve3D;
+    struct IfcOneDirectionRepeatFactor;
+    struct IfcOpenShell;
+    struct IfcOpeningElement;
+    typedef NotImplemented IfcOpticalMaterialProperties; // (not currently used by Assimp)
+    struct IfcOrderAction;
+    typedef NotImplemented IfcOrganization; // (not currently used by Assimp)
+    typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp)
+    struct IfcOrientedEdge;
+    struct IfcOutletType;
+    typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp)
+    struct IfcPath;
+    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 IfcPipeFittingType;
+    struct IfcPipeSegmentType;
+    typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp)
+    struct IfcPlanarExtent;
+    struct IfcPlanarBox;
+    struct IfcPlane;
+    struct IfcPlate;
+    struct IfcPlateType;
+    struct IfcPointOnCurve;
+    struct IfcPointOnSurface;
+    struct IfcPolyLoop;
+    struct IfcPolygonalBoundedHalfSpace;
+    struct IfcPolyline;
+    typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp)
+    typedef NotImplemented IfcPreDefinedSymbol; // (not currently used by Assimp)
+    typedef NotImplemented IfcPreDefinedDimensionSymbol; // (not currently used by Assimp)
+    typedef NotImplemented IfcPreDefinedPointMarkerSymbol; // (not currently used by Assimp)
+    typedef NotImplemented IfcPreDefinedTerminatorSymbol; // (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 IfcProductDefinitionShape;
+    typedef NotImplemented IfcProductsOfCombustionProperties; // (not currently used by Assimp)
+    struct IfcProject;
+    struct IfcProjectOrder;
+    struct IfcProjectOrderRecord;
+    struct IfcProjectionCurve;
+    struct IfcProjectionElement;
+    struct IfcSimpleProperty;
+    struct IfcPropertyBoundedValue;
+    typedef NotImplemented IfcPropertyConstraintRelationship; // (not currently used by Assimp)
+    typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp)
+    struct IfcPropertyEnumeratedValue;
+    typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp)
+    struct IfcPropertyListValue;
+    struct IfcPropertyReferenceValue;
+    struct IfcPropertySet;
+    struct IfcPropertySingleValue;
+    struct IfcPropertyTableValue;
+    struct IfcProtectiveDeviceType;
+    struct IfcProxy;
+    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 IfcRadiusDimension;
+    struct IfcRailing;
+    struct IfcRailingType;
+    struct IfcRamp;
+    struct IfcRampFlight;
+    struct IfcRampFlightType;
+    struct IfcRationalBezierCurve;
+    struct IfcRectangleProfileDef;
+    struct IfcRectangleHollowProfileDef;
+    struct IfcRectangularPyramid;
+    struct IfcRectangularTrimmedSurface;
+    typedef NotImplemented IfcReferencesValueDocument; // (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 IfcReinforcingMesh;
+    struct IfcRelationship;
+    struct IfcRelDecomposes;
+    struct IfcRelAggregates;
+    typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsTasks; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToProjectOrder; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelAssociatesAppliedValue; // (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)
+    typedef NotImplemented IfcRelAssociatesProfileProperties; // (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 IfcRelConnectsStructuralElement; // (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)
+    struct IfcRelDefines;
+    struct IfcRelDefinesByProperties;
+    typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp)
+    struct IfcRelFillsElement;
+    typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelInteractionRequirements; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelNests; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelOccupiesSpaces; // (not currently used by Assimp)
+    struct IfcRelOverridesProperties;
+    typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp)
+    typedef NotImplemented IfcRelSchedulesCostItems; // (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)
+    struct IfcRelVoidsElement;
+    typedef NotImplemented IfcRelaxation; // (not currently used by Assimp)
+    struct IfcRepresentation;
+    struct IfcRepresentationMap;
+    struct IfcRevolvedAreaSolid;
+    typedef NotImplemented IfcRibPlateProfileProperties; // (not currently used by Assimp)
+    struct IfcRightCircularCone;
+    struct IfcRightCircularCylinder;
+    struct IfcRoof;
+    struct IfcRoundedEdgeFeature;
+    struct IfcRoundedRectangleProfileDef;
+    struct IfcSIUnit;
+    struct IfcSanitaryTerminalType;
+    struct IfcScheduleTimeControl;
+    typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp)
+    struct IfcSectionedSpine;
+    struct IfcSensorType;
+    struct IfcServiceLife;
+    typedef NotImplemented IfcServiceLifeFactor; // (not currently used by Assimp)
+    typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp)
+    struct IfcShapeModel;
+    struct IfcShapeRepresentation;
+    struct IfcShellBasedSurfaceModel;
+    struct IfcSite;
+    struct IfcSlab;
+    struct IfcSlabType;
+    typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp)
+    typedef NotImplemented IfcSoundProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcSoundValue; // (not currently used by Assimp)
+    struct IfcSpace;
+    struct IfcSpaceHeaterType;
+    struct IfcSpaceProgram;
+    typedef NotImplemented IfcSpaceThermalLoadProperties; // (not currently used by Assimp)
+    struct IfcSpatialStructureElementType;
+    struct IfcSpaceType;
+    struct IfcSphere;
+    struct IfcStackTerminalType;
+    struct IfcStair;
+    struct IfcStairFlight;
+    struct IfcStairFlightType;
+    struct IfcStructuralActivity;
+    struct IfcStructuralAction;
+    struct IfcStructuralAnalysisModel;
+    struct IfcStructuralItem;
+    struct IfcStructuralConnection;
+    struct IfcStructuralCurveConnection;
+    struct IfcStructuralMember;
+    struct IfcStructuralCurveMember;
+    struct IfcStructuralCurveMemberVarying;
+    struct IfcStructuralLinearAction;
+    struct IfcStructuralLinearActionVarying;
+    typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp)
+    struct IfcStructuralLoadGroup;
+    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 IfcStructuralPlanarAction;
+    struct IfcStructuralPlanarActionVarying;
+    struct IfcStructuralPointAction;
+    struct IfcStructuralPointConnection;
+    struct IfcStructuralReaction;
+    struct IfcStructuralPointReaction;
+    typedef NotImplemented IfcStructuralProfileProperties; // (not currently used by Assimp)
+    struct IfcStructuralResultGroup;
+    typedef NotImplemented IfcStructuralSteelProfileProperties; // (not currently used by Assimp)
+    struct IfcStructuralSurfaceConnection;
+    struct IfcStructuralSurfaceMember;
+    struct IfcStructuralSurfaceMemberVarying;
+    struct IfcStructuredDimensionCallout;
+    struct IfcStyleModel;
+    struct IfcStyledRepresentation;
+    struct IfcSubContractResource;
+    struct IfcSubedge;
+    struct IfcSurfaceCurveSweptAreaSolid;
+    struct IfcSweptSurface;
+    struct IfcSurfaceOfLinearExtrusion;
+    struct IfcSurfaceOfRevolution;
+    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 IfcSwitchingDeviceType;
+    typedef NotImplemented IfcSymbolStyle; // (not currently used by Assimp)
+    struct IfcSystemFurnitureElementType;
+    struct IfcTShapeProfileDef;
+    typedef NotImplemented IfcTable; // (not currently used by Assimp)
+    typedef NotImplemented IfcTableRow; // (not currently used by Assimp)
+    struct IfcTankType;
+    typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp)
+    struct IfcTendon;
+    struct IfcTendonAnchor;
+    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 IfcTextStyleWithBoxCharacteristics; // (not currently used by Assimp)
+    typedef NotImplemented IfcTextureCoordinate; // (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 IfcThermalMaterialProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcTimeSeriesReferenceRelationship; // (not currently used by Assimp)
+    struct IfcTimeSeriesSchedule;
+    typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp)
+    struct IfcTopologyRepresentation;
+    struct IfcTransformerType;
+    struct IfcTransportElement;
+    struct IfcTransportElementType;
+    struct IfcTrapeziumProfileDef;
+    struct IfcTrimmedCurve;
+    struct IfcTubeBundleType;
+    struct IfcTwoDirectionRepeatFactor;
+    struct IfcUShapeProfileDef;
+    struct IfcUnitAssignment;
+    struct IfcUnitaryEquipmentType;
+    struct IfcValveType;
+    struct IfcVector;
+    struct IfcVertex;
+    typedef NotImplemented IfcVertexBasedTextureMap; // (not currently used by Assimp)
+    struct IfcVertexLoop;
+    struct IfcVertexPoint;
+    struct IfcVibrationIsolatorType;
+    struct IfcVirtualElement;
+    typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp)
+    struct IfcWall;
+    struct IfcWallStandardCase;
+    struct IfcWallType;
+    struct IfcWasteTerminalType;
+    typedef NotImplemented IfcWaterProperties; // (not currently used by Assimp)
+    struct IfcWindow;
+    typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp)
+    typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp)
+    struct IfcWindowStyle;
+    struct IfcWorkControl;
+    struct IfcWorkPlan;
+    struct IfcWorkSchedule;
+    struct IfcZShapeProfileDef;
+    struct IfcZone;
+
+
+
+    // 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 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 IfcCompositeCurve
+    struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {}
+        ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments;
+        LOGICAL::Out SelfIntersect;
+    };
+
+    // C++ wrapper for Ifc2DCompositeCurve
+    struct Ifc2DCompositeCurve : IfcCompositeCurve, ObjectHelper<Ifc2DCompositeCurve,0> { Ifc2DCompositeCurve() : Object("Ifc2DCompositeCurve") {}
+
+    };
+
+    // C++ wrapper for IfcRoot
+    struct IfcRoot :  ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {}
+        IfcGloballyUniqueId::Out GlobalId;
+        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,0> { IfcControl() : Object("IfcControl") {}
+
+    };
+
+    // C++ wrapper for IfcActionRequest
+    struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,1> { IfcActionRequest() : Object("IfcActionRequest") {}
+        IfcIdentifier::Out RequestID;
+    };
+
+    // C++ wrapper for IfcActor
+    struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {}
+        IfcActorSelect::Out TheActor;
+    };
+
+    // C++ wrapper for IfcTypeObject
+    struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {}
+        Maybe< IfcLabel::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 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 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 IfcAlarmType
+    struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {}
+        IfcAlarmTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDraughtingCallout
+    struct IfcDraughtingCallout : IfcGeometricRepresentationItem, ObjectHelper<IfcDraughtingCallout,1> { IfcDraughtingCallout() : Object("IfcDraughtingCallout") {}
+        ListOf< IfcDraughtingCalloutElement, 1, 0 >::Out Contents;
+    };
+
+    // C++ wrapper for IfcDimensionCurveDirectedCallout
+    struct IfcDimensionCurveDirectedCallout : IfcDraughtingCallout, ObjectHelper<IfcDimensionCurveDirectedCallout,0> { IfcDimensionCurveDirectedCallout() : Object("IfcDimensionCurveDirectedCallout") {}
+
+    };
+
+    // C++ wrapper for IfcAngularDimension
+    struct IfcAngularDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcAngularDimension,0> { IfcAngularDimension() : Object("IfcAngularDimension") {}
+
+    };
+
+    // C++ wrapper for IfcProduct
+    struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {}
+        Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement;
+        Maybe< Lazy< IfcProductRepresentation > > Representation;
+    };
+
+    // C++ wrapper for IfcAnnotation
+    struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {}
+
+    };
+
+    // C++ wrapper for IfcStyledItem
+    struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {}
+        Maybe< Lazy< IfcRepresentationItem > > Item;
+        ListOf< Lazy< IfcPresentationStyleAssignment >, 1, 0 > Styles;
+        Maybe< IfcLabel::Out > Name;
+    };
+
+    // C++ wrapper for IfcAnnotationOccurrence
+    struct IfcAnnotationOccurrence : IfcStyledItem, ObjectHelper<IfcAnnotationOccurrence,0> { IfcAnnotationOccurrence() : Object("IfcAnnotationOccurrence") {}
+
+    };
+
+    // C++ wrapper for IfcAnnotationCurveOccurrence
+    struct IfcAnnotationCurveOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationCurveOccurrence,0> { IfcAnnotationCurveOccurrence() : Object("IfcAnnotationCurveOccurrence") {}
+
+    };
+
+    // 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 IfcAnnotationFillAreaOccurrence
+    struct IfcAnnotationFillAreaOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationFillAreaOccurrence,2> { IfcAnnotationFillAreaOccurrence() : Object("IfcAnnotationFillAreaOccurrence") {}
+        Maybe< Lazy< IfcPoint > > FillStyleTarget;
+        Maybe< IfcGlobalOrLocalEnum::Out > GlobalOrLocal;
+    };
+
+    // C++ wrapper for IfcAnnotationSurface
+    struct IfcAnnotationSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationSurface,2> { IfcAnnotationSurface() : Object("IfcAnnotationSurface") {}
+        Lazy< IfcGeometricRepresentationItem > Item;
+        Maybe< Lazy< NotImplemented > > TextureCoordinates;
+    };
+
+    // C++ wrapper for IfcAnnotationSurfaceOccurrence
+    struct IfcAnnotationSurfaceOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSurfaceOccurrence,0> { IfcAnnotationSurfaceOccurrence() : Object("IfcAnnotationSurfaceOccurrence") {}
+
+    };
+
+    // C++ wrapper for IfcAnnotationSymbolOccurrence
+    struct IfcAnnotationSymbolOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSymbolOccurrence,0> { IfcAnnotationSymbolOccurrence() : Object("IfcAnnotationSymbolOccurrence") {}
+
+    };
+
+    // C++ wrapper for IfcAnnotationTextOccurrence
+    struct IfcAnnotationTextOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationTextOccurrence,0> { IfcAnnotationTextOccurrence() : Object("IfcAnnotationTextOccurrence") {}
+
+    };
+
+    // 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") {}
+        IfcIdentifier::Out AssetID;
+        Lazy< NotImplemented > OriginalValue;
+        Lazy< NotImplemented > CurrentValue;
+        Lazy< NotImplemented > TotalReplacementCost;
+        IfcActorSelect::Out Owner;
+        IfcActorSelect::Out User;
+        Lazy< NotImplemented > ResponsiblePerson;
+        Lazy< NotImplemented > IncorporationDate;
+        Lazy< NotImplemented > DepreciatedValue;
+    };
+
+    // C++ wrapper for IfcParameterizedProfileDef
+    struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {}
+        Lazy< IfcAxis2Placement2D > Position;
+    };
+
+    // C++ wrapper for IfcIShapeProfileDef
+    struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,5> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out OverallWidth;
+        IfcPositiveLengthMeasure::Out OverallDepth;
+        IfcPositiveLengthMeasure::Out WebThickness;
+        IfcPositiveLengthMeasure::Out FlangeThickness;
+        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
+    };
+
+    // C++ wrapper for IfcAsymmetricIShapeProfileDef
+    struct IfcAsymmetricIShapeProfileDef : IfcIShapeProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,4> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out TopFlangeWidth;
+        Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness;
+        Maybe< IfcPositiveLengthMeasure::Out > TopFlangeFilletRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
+    };
+
+    // 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 IfcBSplineCurve
+    struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {}
+        INTEGER::Out Degree;
+        ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList;
+        IfcBSplineCurveForm::Out CurveForm;
+        LOGICAL::Out ClosedCurve;
+        LOGICAL::Out SelfIntersect;
+    };
+
+    // C++ wrapper for IfcElement
+    struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {}
+        Maybe< IfcIdentifier::Out > Tag;
+    };
+
+    // C++ wrapper for IfcBuildingElement
+    struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {}
+
+    };
+
+    // C++ wrapper for IfcBeam
+    struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,0> { IfcBeam() : Object("IfcBeam") {}
+
+    };
+
+    // 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 IfcBezierCurve
+    struct IfcBezierCurve : IfcBSplineCurve, ObjectHelper<IfcBezierCurve,0> { IfcBezierCurve() : Object("IfcBezierCurve") {}
+
+    };
+
+    // 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 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 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 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;
+        BOOLEAN::Out AgreementFlag;
+    };
+
+    // C++ wrapper for IfcBoxedHalfSpace
+    struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {}
+        Lazy< IfcBoundingBox > Enclosure;
+    };
+
+    // C++ wrapper for IfcSpatialStructureElement
+    struct IfcSpatialStructureElement : IfcProduct, ObjectHelper<IfcSpatialStructureElement,2> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {}
+        Maybe< IfcLabel::Out > LongName;
+        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 IfcBuildingElementComponent
+    struct IfcBuildingElementComponent : IfcBuildingElement, ObjectHelper<IfcBuildingElementComponent,0> { IfcBuildingElementComponent() : Object("IfcBuildingElementComponent") {}
+
+    };
+
+    // C++ wrapper for IfcBuildingElementPart
+    struct IfcBuildingElementPart : IfcBuildingElementComponent, ObjectHelper<IfcBuildingElementPart,0> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {}
+
+    };
+
+    // C++ wrapper for IfcBuildingElementProxy
+    struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {}
+        Maybe< IfcElementCompositionEnum::Out > CompositionType;
+    };
+
+    // 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 IfcCShapeProfileDef
+    struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,6> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out Depth;
+        IfcPositiveLengthMeasure::Out Width;
+        IfcPositiveLengthMeasure::Out WallThickness;
+        IfcPositiveLengthMeasure::Out Girth;
+        Maybe< IfcPositiveLengthMeasure::Out > InternalFilletRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
+    };
+
+    // 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 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 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 IfcCartesianTransformationOperator
+    struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {}
+        Maybe< Lazy< IfcDirection > > Axis1;
+        Maybe< Lazy< IfcDirection > > Axis2;
+        Lazy< IfcCartesianPoint > LocalOrigin;
+        Maybe< REAL::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< REAL::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< REAL::Out > Scale2;
+        Maybe< REAL::Out > Scale3;
+    };
+
+    // C++ wrapper for IfcCenterLineProfileDef
+    struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {}
+        IfcPositiveLengthMeasure::Out Thickness;
+    };
+
+    // C++ wrapper for IfcFeatureElement
+    struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {}
+
+    };
+
+    // C++ wrapper for IfcFeatureElementSubtraction
+    struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {}
+
+    };
+
+    // C++ wrapper for IfcEdgeFeature
+    struct IfcEdgeFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcEdgeFeature,1> { IfcEdgeFeature() : Object("IfcEdgeFeature") {}
+        Maybe< IfcPositiveLengthMeasure::Out > FeatureLength;
+    };
+
+    // C++ wrapper for IfcChamferEdgeFeature
+    struct IfcChamferEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcChamferEdgeFeature,2> { IfcChamferEdgeFeature() : Object("IfcChamferEdgeFeature") {}
+        Maybe< IfcPositiveLengthMeasure::Out > Width;
+        Maybe< IfcPositiveLengthMeasure::Out > Height;
+    };
+
+    // C++ wrapper for IfcChillerType
+    struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {}
+        IfcChillerTypeEnum::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 IfcTopologicalRepresentationItem
+    struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {}
+
+    };
+
+    // 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 IfcCoilType
+    struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {}
+        IfcCoilTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcColourSpecification
+    struct IfcColourSpecification :  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,0> { IfcColumn() : Object("IfcColumn") {}
+
+    };
+
+    // C++ wrapper for IfcColumnType
+    struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {}
+        IfcColumnTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProperty
+    struct IfcProperty :  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 IfcCompositeCurveSegment
+    struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {}
+        IfcTransitionCode::Out Transition;
+        BOOLEAN::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 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 IfcCondenserType
+    struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {}
+        IfcCondenserTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcCondition
+    struct IfcCondition : IfcGroup, ObjectHelper<IfcCondition,0> { IfcCondition() : Object("IfcCondition") {}
+
+    };
+
+    // C++ wrapper for IfcConditionCriterion
+    struct IfcConditionCriterion : IfcControl, ObjectHelper<IfcConditionCriterion,2> { IfcConditionCriterion() : Object("IfcConditionCriterion") {}
+        IfcConditionCriterionSelect::Out Criterion;
+        IfcDateTimeSelect::Out CriterionDateTime;
+    };
+
+    // C++ wrapper for IfcResource
+    struct IfcResource : IfcObject, ObjectHelper<IfcResource,0> { IfcResource() : Object("IfcResource") {}
+
+    };
+
+    // C++ wrapper for IfcConstructionResource
+    struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,4> { IfcConstructionResource() : Object("IfcConstructionResource") {}
+        Maybe< IfcIdentifier::Out > ResourceIdentifier;
+        Maybe< IfcLabel::Out > ResourceGroup;
+        Maybe< IfcResourceConsumptionEnum::Out > ResourceConsumption;
+        Maybe< Lazy< IfcMeasureWithUnit > > BaseQuantity;
+    };
+
+    // C++ wrapper for IfcConstructionEquipmentResource
+    struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,0> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {}
+
+    };
+
+    // C++ wrapper for IfcConstructionMaterialResource
+    struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,2> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {}
+        Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > Suppliers;
+        Maybe< IfcRatioMeasure::Out > UsageRatio;
+    };
+
+    // C++ wrapper for IfcConstructionProductResource
+    struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,0> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {}
+
+    };
+
+    // 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 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 IfcCooledBeamType
+    struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {}
+        IfcCooledBeamTypeEnum::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,0> { IfcCostItem() : Object("IfcCostItem") {}
+
+    };
+
+    // C++ wrapper for IfcCostSchedule
+    struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,8> { IfcCostSchedule() : Object("IfcCostSchedule") {}
+        Maybe< IfcActorSelect::Out > SubmittedBy;
+        Maybe< IfcActorSelect::Out > PreparedBy;
+        Maybe< IfcDateTimeSelect::Out > SubmittedOn;
+        Maybe< IfcLabel::Out > Status;
+        Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > TargetUsers;
+        Maybe< IfcDateTimeSelect::Out > UpdateDate;
+        IfcIdentifier::Out ID;
+        IfcCostScheduleTypeEnum::Out PredefinedType;
+    };
+
+    // 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 IfcCraneRailAShapeProfileDef
+    struct IfcCraneRailAShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailAShapeProfileDef,12> { IfcCraneRailAShapeProfileDef() : Object("IfcCraneRailAShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out OverallHeight;
+        IfcPositiveLengthMeasure::Out BaseWidth2;
+        Maybe< IfcPositiveLengthMeasure::Out > Radius;
+        IfcPositiveLengthMeasure::Out HeadWidth;
+        IfcPositiveLengthMeasure::Out HeadDepth2;
+        IfcPositiveLengthMeasure::Out HeadDepth3;
+        IfcPositiveLengthMeasure::Out WebThickness;
+        IfcPositiveLengthMeasure::Out BaseWidth4;
+        IfcPositiveLengthMeasure::Out BaseDepth1;
+        IfcPositiveLengthMeasure::Out BaseDepth2;
+        IfcPositiveLengthMeasure::Out BaseDepth3;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
+    };
+
+    // C++ wrapper for IfcCraneRailFShapeProfileDef
+    struct IfcCraneRailFShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailFShapeProfileDef,9> { IfcCraneRailFShapeProfileDef() : Object("IfcCraneRailFShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out OverallHeight;
+        IfcPositiveLengthMeasure::Out HeadWidth;
+        Maybe< IfcPositiveLengthMeasure::Out > Radius;
+        IfcPositiveLengthMeasure::Out HeadDepth2;
+        IfcPositiveLengthMeasure::Out HeadDepth3;
+        IfcPositiveLengthMeasure::Out WebThickness;
+        IfcPositiveLengthMeasure::Out BaseDepth1;
+        IfcPositiveLengthMeasure::Out BaseDepth2;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
+    };
+
+    // C++ wrapper for IfcCrewResource
+    struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,0> { IfcCrewResource() : Object("IfcCrewResource") {}
+
+    };
+
+    // C++ wrapper for IfcSolidModel
+    struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {}
+
+    };
+
+    // 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,0> { IfcCurtainWall() : Object("IfcCurtainWall") {}
+
+    };
+
+    // 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 IfcPresentationStyle
+    struct IfcPresentationStyle :  ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {}
+        Maybe< IfcLabel::Out > Name;
+    };
+
+    // C++ wrapper for IfcDamperType
+    struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {}
+        IfcDamperTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDefinedSymbol
+    struct IfcDefinedSymbol : IfcGeometricRepresentationItem, ObjectHelper<IfcDefinedSymbol,2> { IfcDefinedSymbol() : Object("IfcDefinedSymbol") {}
+        IfcDefinedSymbolSelect::Out Definition;
+        Lazy< IfcCartesianTransformationOperator2D > Target;
+    };
+
+    // 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 IfcDiameterDimension
+    struct IfcDiameterDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcDiameterDimension,0> { IfcDiameterDimension() : Object("IfcDiameterDimension") {}
+
+    };
+
+    // C++ wrapper for IfcDimensionCurve
+    struct IfcDimensionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcDimensionCurve,0> { IfcDimensionCurve() : Object("IfcDimensionCurve") {}
+
+    };
+
+    // C++ wrapper for IfcTerminatorSymbol
+    struct IfcTerminatorSymbol : IfcAnnotationSymbolOccurrence, ObjectHelper<IfcTerminatorSymbol,1> { IfcTerminatorSymbol() : Object("IfcTerminatorSymbol") {}
+        Lazy< IfcAnnotationCurveOccurrence > AnnotatedCurve;
+    };
+
+    // C++ wrapper for IfcDimensionCurveTerminator
+    struct IfcDimensionCurveTerminator : IfcTerminatorSymbol, ObjectHelper<IfcDimensionCurveTerminator,1> { IfcDimensionCurveTerminator() : Object("IfcDimensionCurveTerminator") {}
+        IfcDimensionExtentUsage::Out Role;
+    };
+
+    // C++ wrapper for IfcDirection
+    struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {}
+        ListOf< REAL, 2, 3 >::Out DirectionRatios;
+    };
+
+    // C++ wrapper for IfcElementComponent
+    struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {}
+
+    };
+
+    // C++ wrapper for IfcDiscreteAccessory
+    struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,0> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {}
+
+    };
+
+    // C++ wrapper for IfcElementComponentType
+    struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {}
+
+    };
+
+    // C++ wrapper for IfcDiscreteAccessoryType
+    struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,0> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionElement
+    struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionFlowElement
+    struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionChamberElement
+    struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,0> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionChamberElementType
+    struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {}
+        IfcDistributionChamberElementTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDistributionControlElement
+    struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,1> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {}
+        Maybe< IfcIdentifier::Out > ControlElementId;
+    };
+
+    // C++ wrapper for IfcPort
+    struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {}
+
+    };
+
+    // C++ wrapper for IfcDistributionPort
+    struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,1> { IfcDistributionPort() : Object("IfcDistributionPort") {}
+        Maybe< IfcFlowDirectionEnum::Out > FlowDirection;
+    };
+
+    // C++ wrapper for IfcDoor
+    struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,2> { IfcDoor() : Object("IfcDoor") {}
+        Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
+        Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
+    };
+
+    // C++ wrapper for IfcPropertyDefinition
+    struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {}
+
+    };
+
+    // C++ wrapper for IfcPropertySetDefinition
+    struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {}
+
+    };
+
+    // C++ wrapper for IfcDoorStyle
+    struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {}
+        IfcDoorStyleOperationEnum::Out OperationType;
+        IfcDoorStyleConstructionEnum::Out ConstructionType;
+        BOOLEAN::Out ParameterTakesPrecedence;
+        BOOLEAN::Out Sizeable;
+    };
+
+    // C++ wrapper for IfcDuctFittingType
+    struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {}
+        IfcDuctFittingTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcDuctSegmentType
+    struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {}
+        IfcDuctSegmentTypeEnum::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;
+        BOOLEAN::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 IfcElectricApplianceType
+    struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {}
+        IfcElectricApplianceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowController
+    struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {}
+
+    };
+
+    // C++ wrapper for IfcElectricDistributionPoint
+    struct IfcElectricDistributionPoint : IfcFlowController, ObjectHelper<IfcElectricDistributionPoint,2> { IfcElectricDistributionPoint() : Object("IfcElectricDistributionPoint") {}
+        IfcElectricDistributionPointFunctionEnum::Out DistributionPointFunction;
+        Maybe< IfcLabel::Out > UserDefinedFunction;
+    };
+
+    // 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 IfcElectricGeneratorType
+    struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {}
+        IfcElectricGeneratorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricHeaterType
+    struct IfcElectricHeaterType : IfcFlowTerminalType, ObjectHelper<IfcElectricHeaterType,1> { IfcElectricHeaterType() : Object("IfcElectricHeaterType") {}
+        IfcElectricHeaterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricMotorType
+    struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {}
+        IfcElectricMotorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElectricTimeControlType
+    struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {}
+        IfcElectricTimeControlTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSystem
+    struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {}
+
+    };
+
+    // C++ wrapper for IfcElectricalCircuit
+    struct IfcElectricalCircuit : IfcSystem, ObjectHelper<IfcElectricalCircuit,0> { IfcElectricalCircuit() : Object("IfcElectricalCircuit") {}
+
+    };
+
+    // C++ wrapper for IfcElectricalElement
+    struct IfcElectricalElement : IfcElement, ObjectHelper<IfcElectricalElement,0> { IfcElectricalElement() : Object("IfcElectricalElement") {}
+
+    };
+
+    // C++ wrapper for IfcElementAssembly
+    struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {}
+        Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace;
+        IfcElementAssemblyTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcElementQuantity
+    struct IfcElementQuantity : IfcPropertySetDefinition, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {}
+        Maybe< IfcLabel::Out > MethodOfMeasurement;
+        ListOf< Lazy< NotImplemented >, 1, 0 > Quantities;
+    };
+
+    // C++ wrapper for IfcElementarySurface
+    struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {}
+        Lazy< IfcAxis2Placement3D > Position;
+    };
+
+    // 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 IfcEnergyConversionDevice
+    struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {}
+
+    };
+
+    // C++ wrapper for IfcEquipmentElement
+    struct IfcEquipmentElement : IfcElement, ObjectHelper<IfcEquipmentElement,0> { IfcEquipmentElement() : Object("IfcEquipmentElement") {}
+
+    };
+
+    // C++ wrapper for IfcEquipmentStandard
+    struct IfcEquipmentStandard : IfcControl, ObjectHelper<IfcEquipmentStandard,0> { IfcEquipmentStandard() : Object("IfcEquipmentStandard") {}
+
+    };
+
+    // C++ wrapper for IfcEvaporativeCoolerType
+    struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {}
+        IfcEvaporativeCoolerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcEvaporatorType
+    struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {}
+        IfcEvaporatorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSweptAreaSolid
+    struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {}
+        Lazy< IfcProfileDef > SweptArea;
+        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 IfcFace
+    struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {}
+        ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds;
+    };
+
+    // 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;
+        BOOLEAN::Out Orientation;
+    };
+
+    // C++ wrapper for IfcFaceOuterBound
+    struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {}
+
+    };
+
+    // C++ wrapper for IfcFaceSurface
+    struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {}
+        Lazy< IfcSurface > FaceSurface;
+        BOOLEAN::Out SameSense;
+    };
+
+    // C++ wrapper for IfcManifoldSolidBrep
+    struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {}
+        Lazy< IfcClosedShell > Outer;
+    };
+
+    // C++ wrapper for IfcFacetedBrep
+    struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {}
+
+    };
+
+    // C++ wrapper for IfcFacetedBrepWithVoids
+    struct IfcFacetedBrepWithVoids : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {}
+        ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
+    };
+
+    // 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,0> { IfcFastener() : Object("IfcFastener") {}
+
+    };
+
+    // C++ wrapper for IfcFastenerType
+    struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,0> { IfcFastenerType() : Object("IfcFastenerType") {}
+
+    };
+
+    // C++ wrapper for IfcFeatureElementAddition
+    struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {}
+
+    };
+
+    // 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 IfcFillAreaStyleTileSymbolWithStyle
+    struct IfcFillAreaStyleTileSymbolWithStyle : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTileSymbolWithStyle,1> { IfcFillAreaStyleTileSymbolWithStyle() : Object("IfcFillAreaStyleTileSymbolWithStyle") {}
+        Lazy< IfcAnnotationSymbolOccurrence > Symbol;
+    };
+
+    // C++ wrapper for IfcFillAreaStyleTiles
+    struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {}
+        Lazy< IfcOneDirectionRepeatFactor > TilingPattern;
+        ListOf< IfcFillAreaStyleTileShapeSelect, 1, 0 >::Out Tiles;
+        IfcPositiveRatioMeasure::Out TilingScale;
+    };
+
+    // C++ wrapper for IfcFilterType
+    struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {}
+        IfcFilterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFireSuppressionTerminalType
+    struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {}
+        IfcFireSuppressionTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowFitting
+    struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {}
+
+    };
+
+    // C++ wrapper for IfcFlowInstrumentType
+    struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {}
+        IfcFlowInstrumentTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowMeterType
+    struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {}
+        IfcFlowMeterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcFlowMovingDevice
+    struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {}
+
+    };
+
+    // C++ wrapper for IfcFlowSegment
+    struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {}
+
+    };
+
+    // C++ wrapper for IfcFlowStorageDevice
+    struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {}
+
+    };
+
+    // C++ wrapper for IfcFlowTerminal
+    struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {}
+
+    };
+
+    // C++ wrapper for IfcFlowTreatmentDevice
+    struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {}
+
+    };
+
+    // C++ wrapper for IfcFooting
+    struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {}
+        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 IfcFurnitureStandard
+    struct IfcFurnitureStandard : IfcControl, ObjectHelper<IfcFurnitureStandard,0> { IfcFurnitureStandard() : Object("IfcFurnitureStandard") {}
+
+    };
+
+    // C++ wrapper for IfcFurnitureType
+    struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,1> { IfcFurnitureType() : Object("IfcFurnitureType") {}
+        IfcAssemblyPlaceEnum::Out AssemblyPlace;
+    };
+
+    // C++ wrapper for IfcGasTerminalType
+    struct IfcGasTerminalType : IfcFlowTerminalType, ObjectHelper<IfcGasTerminalType,1> { IfcGasTerminalType() : Object("IfcGasTerminalType") {}
+        IfcGasTerminalTypeEnum::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< REAL::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,3> { IfcGrid() : Object("IfcGrid") {}
+        ListOf< Lazy< NotImplemented >, 1, 0 > UAxes;
+        ListOf< Lazy< NotImplemented >, 1, 0 > VAxes;
+        Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes;
+    };
+
+    // 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< Lazy< NotImplemented > > PlacementRefDirection;
+    };
+
+    // C++ wrapper for IfcHeatExchangerType
+    struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {}
+        IfcHeatExchangerTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcHumidifierType
+    struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {}
+        IfcHumidifierTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcInventory
+    struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {}
+        IfcInventoryTypeEnum::Out InventoryType;
+        IfcActorSelect::Out Jurisdiction;
+        ListOf< Lazy< NotImplemented >, 1, 0 > ResponsiblePersons;
+        Lazy< NotImplemented > LastUpdateDate;
+        Maybe< Lazy< NotImplemented > > CurrentValue;
+        Maybe< Lazy< NotImplemented > > OriginalValue;
+    };
+
+    // 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,8> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out Depth;
+        Maybe< IfcPositiveLengthMeasure::Out > Width;
+        IfcPositiveLengthMeasure::Out Thickness;
+        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
+        Maybe< IfcPlaneAngleMeasure::Out > LegSlope;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
+    };
+
+    // C++ wrapper for IfcLaborResource
+    struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {}
+        Maybe< IfcText::Out > SkillSet;
+    };
+
+    // C++ wrapper for IfcLampType
+    struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {}
+        IfcLampTypeEnum::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 IfcLinearDimension
+    struct IfcLinearDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcLinearDimension,0> { IfcLinearDimension() : Object("IfcLinearDimension") {}
+
+    };
+
+    // 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 : IfcFastener, ObjectHelper<IfcMechanicalFastener,2> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {}
+        Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
+        Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
+    };
+
+    // C++ wrapper for IfcMechanicalFastenerType
+    struct IfcMechanicalFastenerType : IfcFastenerType, ObjectHelper<IfcMechanicalFastenerType,0> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {}
+
+    };
+
+    // C++ wrapper for IfcMember
+    struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,0> { IfcMember() : Object("IfcMember") {}
+
+    };
+
+    // C++ wrapper for IfcMemberType
+    struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {}
+        IfcMemberTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcMotorConnectionType
+    struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {}
+        IfcMotorConnectionTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProcess
+    struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,0> { IfcProcess() : Object("IfcProcess") {}
+
+    };
+
+    // C++ wrapper for IfcTask
+    struct IfcTask : IfcProcess, ObjectHelper<IfcTask,5> { IfcTask() : Object("IfcTask") {}
+        IfcIdentifier::Out TaskId;
+        Maybe< IfcLabel::Out > Status;
+        Maybe< IfcLabel::Out > WorkMethod;
+        BOOLEAN::Out IsMilestone;
+        Maybe< INTEGER::Out > Priority;
+    };
+
+    // C++ wrapper for IfcMove
+    struct IfcMove : IfcTask, ObjectHelper<IfcMove,3> { IfcMove() : Object("IfcMove") {}
+        Lazy< IfcSpatialStructureElement > MoveFrom;
+        Lazy< IfcSpatialStructureElement > MoveTo;
+        Maybe< ListOf< IfcText, 1, 0 >::Out > PunchList;
+    };
+
+    // C++ wrapper for IfcOccupant
+    struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {}
+        IfcOccupantTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcOffsetCurve2D
+    struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {}
+        Lazy< IfcCurve > BasisCurve;
+        IfcLengthMeasure::Out Distance;
+        LOGICAL::Out SelfIntersect;
+    };
+
+    // C++ wrapper for IfcOffsetCurve3D
+    struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {}
+        Lazy< IfcCurve > BasisCurve;
+        IfcLengthMeasure::Out Distance;
+        LOGICAL::Out SelfIntersect;
+        Lazy< IfcDirection > RefDirection;
+    };
+
+    // C++ wrapper for IfcOneDirectionRepeatFactor
+    struct IfcOneDirectionRepeatFactor : IfcGeometricRepresentationItem, ObjectHelper<IfcOneDirectionRepeatFactor,1> { IfcOneDirectionRepeatFactor() : Object("IfcOneDirectionRepeatFactor") {}
+        Lazy< IfcVector > RepeatFactor;
+    };
+
+    // C++ wrapper for IfcOpenShell
+    struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {}
+
+    };
+
+    // C++ wrapper for IfcOpeningElement
+    struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,0> { IfcOpeningElement() : Object("IfcOpeningElement") {}
+
+    };
+
+    // C++ wrapper for IfcOrderAction
+    struct IfcOrderAction : IfcTask, ObjectHelper<IfcOrderAction,1> { IfcOrderAction() : Object("IfcOrderAction") {}
+        IfcIdentifier::Out ActionID;
+    };
+
+    // C++ wrapper for IfcOrientedEdge
+    struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {}
+        Lazy< IfcEdge > EdgeElement;
+        BOOLEAN::Out Orientation;
+    };
+
+    // 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 IfcPerformanceHistory
+    struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,1> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {}
+        IfcLabel::Out LifeCyclePhase;
+    };
+
+    // C++ wrapper for IfcPermit
+    struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,1> { IfcPermit() : Object("IfcPermit") {}
+        IfcIdentifier::Out PermitID;
+    };
+
+    // C++ wrapper for IfcPile
+    struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {}
+        IfcPileTypeEnum::Out PredefinedType;
+        Maybe< IfcPileConstructionEnum::Out > ConstructionType;
+    };
+
+    // C++ wrapper for IfcPipeFittingType
+    struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {}
+        IfcPipeFittingTypeEnum::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,0> { IfcPlate() : Object("IfcPlate") {}
+
+    };
+
+    // 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 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,3> { IfcProcedure() : Object("IfcProcedure") {}
+        IfcIdentifier::Out ProcedureID;
+        IfcProcedureTypeEnum::Out ProcedureType;
+        Maybe< IfcLabel::Out > UserDefinedProcedureType;
+    };
+
+    // C++ wrapper for IfcProductDefinitionShape
+    struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {}
+
+    };
+
+    // C++ wrapper for IfcProject
+    struct IfcProject : IfcObject, ObjectHelper<IfcProject,4> { IfcProject() : Object("IfcProject") {}
+        Maybe< IfcLabel::Out > LongName;
+        Maybe< IfcLabel::Out > Phase;
+        ListOf< Lazy< IfcRepresentationContext >, 1, 0 > RepresentationContexts;
+        Lazy< IfcUnitAssignment > UnitsInContext;
+    };
+
+    // C++ wrapper for IfcProjectOrder
+    struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {}
+        IfcIdentifier::Out ID;
+        IfcProjectOrderTypeEnum::Out PredefinedType;
+        Maybe< IfcLabel::Out > Status;
+    };
+
+    // C++ wrapper for IfcProjectOrderRecord
+    struct IfcProjectOrderRecord : IfcControl, ObjectHelper<IfcProjectOrderRecord,2> { IfcProjectOrderRecord() : Object("IfcProjectOrderRecord") {}
+        ListOf< Lazy< NotImplemented >, 1, 0 > Records;
+        IfcProjectOrderRecordTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcProjectionCurve
+    struct IfcProjectionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcProjectionCurve,0> { IfcProjectionCurve() : Object("IfcProjectionCurve") {}
+
+    };
+
+    // C++ wrapper for IfcProjectionElement
+    struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,0> { IfcProjectionElement() : Object("IfcProjectionElement") {}
+
+    };
+
+    // C++ wrapper for IfcSimpleProperty
+    struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {}
+
+    };
+
+    // C++ wrapper for IfcPropertyBoundedValue
+    struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,3> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {}
+        Maybe< IfcValue::Out > UpperBoundValue;
+        Maybe< IfcValue::Out > LowerBoundValue;
+        Maybe< IfcUnit::Out > Unit;
+    };
+
+    // C++ wrapper for IfcPropertyEnumeratedValue
+    struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {}
+        ListOf< IfcValue, 1, 0 >::Out EnumerationValues;
+        Maybe< Lazy< NotImplemented > > EnumerationReference;
+    };
+
+    // C++ wrapper for IfcPropertyListValue
+    struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {}
+        ListOf< IfcValue, 1, 0 >::Out ListValues;
+        Maybe< IfcUnit::Out > Unit;
+    };
+
+    // C++ wrapper for IfcPropertyReferenceValue
+    struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {}
+        Maybe< IfcLabel::Out > UsageName;
+        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,5> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {}
+        ListOf< IfcValue, 1, 0 >::Out DefiningValues;
+        ListOf< IfcValue, 1, 0 >::Out DefinedValues;
+        Maybe< IfcText::Out > Expression;
+        Maybe< IfcUnit::Out > DefiningUnit;
+        Maybe< IfcUnit::Out > DefinedUnit;
+    };
+
+    // 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 IfcPumpType
+    struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {}
+        IfcPumpTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRadiusDimension
+    struct IfcRadiusDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcRadiusDimension,0> { IfcRadiusDimension() : Object("IfcRadiusDimension") {}
+
+    };
+
+    // 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") {}
+        IfcRampTypeEnum::Out ShapeType;
+    };
+
+    // C++ wrapper for IfcRampFlight
+    struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,0> { IfcRampFlight() : Object("IfcRampFlight") {}
+
+    };
+
+    // C++ wrapper for IfcRampFlightType
+    struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {}
+        IfcRampFlightTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcRationalBezierCurve
+    struct IfcRationalBezierCurve : IfcBezierCurve, ObjectHelper<IfcRationalBezierCurve,1> { IfcRationalBezierCurve() : Object("IfcRationalBezierCurve") {}
+        ListOf< REAL, 2, 0 >::Out WeightsData;
+    };
+
+    // 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< IfcPositiveLengthMeasure::Out > InnerFilletRadius;
+        Maybe< IfcPositiveLengthMeasure::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;
+        BOOLEAN::Out Usense;
+        BOOLEAN::Out Vsense;
+    };
+
+    // C++ wrapper for IfcReinforcingElement
+    struct IfcReinforcingElement : IfcBuildingElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {}
+        Maybe< IfcLabel::Out > SteelGrade;
+    };
+
+    // C++ wrapper for IfcReinforcingBar
+    struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {}
+        IfcPositiveLengthMeasure::Out NominalDiameter;
+        IfcAreaMeasure::Out CrossSectionArea;
+        Maybe< IfcPositiveLengthMeasure::Out > BarLength;
+        IfcReinforcingBarRoleEnum::Out BarRole;
+        Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
+    };
+
+    // C++ wrapper for IfcReinforcingMesh
+    struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,8> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {}
+        Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
+        Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
+        IfcPositiveLengthMeasure::Out LongitudinalBarNominalDiameter;
+        IfcPositiveLengthMeasure::Out TransverseBarNominalDiameter;
+        IfcAreaMeasure::Out LongitudinalBarCrossSectionArea;
+        IfcAreaMeasure::Out TransverseBarCrossSectionArea;
+        IfcPositiveLengthMeasure::Out LongitudinalBarSpacing;
+        IfcPositiveLengthMeasure::Out TransverseBarSpacing;
+    };
+
+    // C++ wrapper for IfcRelationship
+    struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {}
+
+    };
+
+    // C++ wrapper for IfcRelDecomposes
+    struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,2> { IfcRelDecomposes() : Object("IfcRelDecomposes") {}
+        Lazy< IfcObjectDefinition > RelatingObject;
+        ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
+    };
+
+    // C++ wrapper for IfcRelAggregates
+    struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,0> { IfcRelAggregates() : Object("IfcRelAggregates") {}
+
+    };
+
+    // 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< IfcSpatialStructureElement > RelatingStructure;
+    };
+
+    // C++ wrapper for IfcRelDefines
+    struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,1> { IfcRelDefines() : Object("IfcRelDefines") {}
+        ListOf< Lazy< IfcObject >, 1, 0 > RelatedObjects;
+    };
+
+    // C++ wrapper for IfcRelDefinesByProperties
+    struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,1> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {}
+        Lazy< IfcPropertySetDefinition > RelatingPropertyDefinition;
+    };
+
+    // C++ wrapper for IfcRelFillsElement
+    struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {}
+        Lazy< IfcOpeningElement > RelatingOpeningElement;
+        Lazy< IfcElement > RelatedBuildingElement;
+    };
+
+    // C++ wrapper for IfcRelOverridesProperties
+    struct IfcRelOverridesProperties : IfcRelDefinesByProperties, ObjectHelper<IfcRelOverridesProperties,1> { IfcRelOverridesProperties() : Object("IfcRelOverridesProperties") {}
+        ListOf< Lazy< IfcProperty >, 1, 0 > OverridingProperties;
+    };
+
+    // C++ wrapper for IfcRelVoidsElement
+    struct IfcRelVoidsElement : IfcRelConnects, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {}
+        Lazy< IfcElement > RelatingBuildingElement;
+        Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement;
+    };
+
+    // 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 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") {}
+        IfcRoofTypeEnum::Out ShapeType;
+    };
+
+    // C++ wrapper for IfcRoundedEdgeFeature
+    struct IfcRoundedEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcRoundedEdgeFeature,1> { IfcRoundedEdgeFeature() : Object("IfcRoundedEdgeFeature") {}
+        Maybe< IfcPositiveLengthMeasure::Out > Radius;
+    };
+
+    // 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 IfcSanitaryTerminalType
+    struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {}
+        IfcSanitaryTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcScheduleTimeControl
+    struct IfcScheduleTimeControl : IfcControl, ObjectHelper<IfcScheduleTimeControl,18> { IfcScheduleTimeControl() : Object("IfcScheduleTimeControl") {}
+        Maybe< IfcDateTimeSelect::Out > ActualStart;
+        Maybe< IfcDateTimeSelect::Out > EarlyStart;
+        Maybe< IfcDateTimeSelect::Out > LateStart;
+        Maybe< IfcDateTimeSelect::Out > ScheduleStart;
+        Maybe< IfcDateTimeSelect::Out > ActualFinish;
+        Maybe< IfcDateTimeSelect::Out > EarlyFinish;
+        Maybe< IfcDateTimeSelect::Out > LateFinish;
+        Maybe< IfcDateTimeSelect::Out > ScheduleFinish;
+        Maybe< IfcTimeMeasure::Out > ScheduleDuration;
+        Maybe< IfcTimeMeasure::Out > ActualDuration;
+        Maybe< IfcTimeMeasure::Out > RemainingTime;
+        Maybe< IfcTimeMeasure::Out > FreeFloat;
+        Maybe< IfcTimeMeasure::Out > TotalFloat;
+        Maybe< BOOLEAN::Out > IsCritical;
+        Maybe< IfcDateTimeSelect::Out > StatusTime;
+        Maybe< IfcTimeMeasure::Out > StartFloat;
+        Maybe< IfcTimeMeasure::Out > FinishFloat;
+        Maybe< IfcPositiveRatioMeasure::Out > Completion;
+    };
+
+    // 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 IfcSensorType
+    struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {}
+        IfcSensorTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcServiceLife
+    struct IfcServiceLife : IfcControl, ObjectHelper<IfcServiceLife,2> { IfcServiceLife() : Object("IfcServiceLife") {}
+        IfcServiceLifeTypeEnum::Out ServiceLifeType;
+        IfcTimeMeasure::Out ServiceLifeDuration;
+    };
+
+    // 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 IfcSlabType
+    struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {}
+        IfcSlabTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSpace
+    struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {}
+        IfcInternalOrExternalEnum::Out InteriorOrExteriorSpace;
+        Maybe< IfcLengthMeasure::Out > ElevationWithFlooring;
+    };
+
+    // C++ wrapper for IfcSpaceHeaterType
+    struct IfcSpaceHeaterType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {}
+        IfcSpaceHeaterTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSpaceProgram
+    struct IfcSpaceProgram : IfcControl, ObjectHelper<IfcSpaceProgram,5> { IfcSpaceProgram() : Object("IfcSpaceProgram") {}
+        IfcIdentifier::Out SpaceProgramIdentifier;
+        Maybe< IfcAreaMeasure::Out > MaxRequiredArea;
+        Maybe< IfcAreaMeasure::Out > MinRequiredArea;
+        Maybe< Lazy< IfcSpatialStructureElement > > RequestedLocation;
+        IfcAreaMeasure::Out StandardRequiredArea;
+    };
+
+    // C++ wrapper for IfcSpatialStructureElementType
+    struct IfcSpatialStructureElementType : IfcElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {}
+
+    };
+
+    // C++ wrapper for IfcSpaceType
+    struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,1> { IfcSpaceType() : Object("IfcSpaceType") {}
+        IfcSpaceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSphere
+    struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {}
+        IfcPositiveLengthMeasure::Out Radius;
+    };
+
+    // 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") {}
+        IfcStairTypeEnum::Out ShapeType;
+    };
+
+    // C++ wrapper for IfcStairFlight
+    struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,4> { IfcStairFlight() : Object("IfcStairFlight") {}
+        Maybe< INTEGER::Out > NumberOfRiser;
+        Maybe< INTEGER::Out > NumberOfTreads;
+        Maybe< IfcPositiveLengthMeasure::Out > RiserHeight;
+        Maybe< IfcPositiveLengthMeasure::Out > TreadLength;
+    };
+
+    // C++ wrapper for IfcStairFlightType
+    struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {}
+        IfcStairFlightTypeEnum::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,2> { IfcStructuralAction() : Object("IfcStructuralAction") {}
+        BOOLEAN::Out DestabilizingLoad;
+        Maybe< Lazy< IfcStructuralReaction > > CausedBy;
+    };
+
+    // C++ wrapper for IfcStructuralAnalysisModel
+    struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,4> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {}
+        IfcAnalysisModelTypeEnum::Out PredefinedType;
+        Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane;
+        Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy;
+        Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults;
+    };
+
+    // 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 IfcStructuralCurveConnection
+    struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,0> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralMember
+    struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralCurveMember
+    struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,1> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {}
+        IfcStructuralCurveTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcStructuralCurveMemberVarying
+    struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralLinearAction
+    struct IfcStructuralLinearAction : IfcStructuralAction, ObjectHelper<IfcStructuralLinearAction,1> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {}
+        IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue;
+    };
+
+    // C++ wrapper for IfcStructuralLinearActionVarying
+    struct IfcStructuralLinearActionVarying : IfcStructuralLinearAction, ObjectHelper<IfcStructuralLinearActionVarying,2> { IfcStructuralLinearActionVarying() : Object("IfcStructuralLinearActionVarying") {}
+        Lazy< NotImplemented > VaryingAppliedLoadLocation;
+        ListOf< Lazy< NotImplemented >, 1, 0 > SubsequentAppliedLoads;
+    };
+
+    // C++ wrapper for IfcStructuralLoadGroup
+    struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {}
+        IfcLoadGroupTypeEnum::Out PredefinedType;
+        IfcActionTypeEnum::Out ActionType;
+        IfcActionSourceTypeEnum::Out ActionSource;
+        Maybe< IfcPositiveRatioMeasure::Out > Coefficient;
+        Maybe< IfcLabel::Out > Purpose;
+    };
+
+    // C++ wrapper for IfcStructuralPlanarAction
+    struct IfcStructuralPlanarAction : IfcStructuralAction, ObjectHelper<IfcStructuralPlanarAction,1> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {}
+        IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue;
+    };
+
+    // C++ wrapper for IfcStructuralPlanarActionVarying
+    struct IfcStructuralPlanarActionVarying : IfcStructuralPlanarAction, ObjectHelper<IfcStructuralPlanarActionVarying,2> { IfcStructuralPlanarActionVarying() : Object("IfcStructuralPlanarActionVarying") {}
+        Lazy< NotImplemented > VaryingAppliedLoadLocation;
+        ListOf< Lazy< NotImplemented >, 2, 0 > SubsequentAppliedLoads;
+    };
+
+    // C++ wrapper for IfcStructuralPointAction
+    struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralPointConnection
+    struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,0> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {}
+
+    };
+
+    // C++ wrapper for IfcStructuralReaction
+    struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {}
+
+    };
+
+    // 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;
+        BOOLEAN::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") {}
+        IfcStructuralSurfaceTypeEnum::Out PredefinedType;
+        Maybe< IfcPositiveLengthMeasure::Out > Thickness;
+    };
+
+    // C++ wrapper for IfcStructuralSurfaceMemberVarying
+    struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,2> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {}
+        ListOf< IfcPositiveLengthMeasure, 2, 0 >::Out SubsequentThickness;
+        Lazy< NotImplemented > VaryingThicknessLocation;
+    };
+
+    // C++ wrapper for IfcStructuredDimensionCallout
+    struct IfcStructuredDimensionCallout : IfcDraughtingCallout, ObjectHelper<IfcStructuredDimensionCallout,0> { IfcStructuredDimensionCallout() : Object("IfcStructuredDimensionCallout") {}
+
+    };
+
+    // C++ wrapper for IfcStyleModel
+    struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {}
+
+    };
+
+    // C++ wrapper for IfcStyledRepresentation
+    struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {}
+
+    };
+
+    // C++ wrapper for IfcSubContractResource
+    struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,2> { IfcSubContractResource() : Object("IfcSubContractResource") {}
+        Maybe< IfcActorSelect::Out > SubContractor;
+        Maybe< IfcText::Out > JobDescription;
+    };
+
+    // 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;
+        IfcParameterValue::Out StartParam;
+        IfcParameterValue::Out EndParam;
+        Lazy< IfcSurface > ReferenceSurface;
+    };
+
+    // C++ wrapper for IfcSweptSurface
+    struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {}
+        Lazy< IfcProfileDef > SweptCurve;
+        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 :  ObjectHelper<IfcSurfaceStyleShading,1> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {}
+        Lazy< IfcColourRgb > SurfaceColour;
+    };
+
+    // C++ wrapper for IfcSurfaceStyleRendering
+    struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,8> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {}
+        Maybe< IfcNormalisedRatioMeasure::Out > Transparency;
+        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 :  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;
+        IfcParameterValue::Out StartParam;
+        IfcParameterValue::Out EndParam;
+    };
+
+    // C++ wrapper for IfcSwitchingDeviceType
+    struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {}
+        IfcSwitchingDeviceTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcSystemFurnitureElementType
+    struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,0> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {}
+
+    };
+
+    // C++ wrapper for IfcTShapeProfileDef
+    struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,10> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out Depth;
+        IfcPositiveLengthMeasure::Out FlangeWidth;
+        IfcPositiveLengthMeasure::Out WebThickness;
+        IfcPositiveLengthMeasure::Out FlangeThickness;
+        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > FlangeEdgeRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > WebEdgeRadius;
+        Maybe< IfcPlaneAngleMeasure::Out > WebSlope;
+        Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
+    };
+
+    // C++ wrapper for IfcTankType
+    struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {}
+        IfcTankTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcTendon
+    struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {}
+        IfcTendonTypeEnum::Out PredefinedType;
+        IfcPositiveLengthMeasure::Out NominalDiameter;
+        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,0> { IfcTendonAnchor() : Object("IfcTendonAnchor") {}
+
+    };
+
+    // 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 IfcTimeSeriesSchedule
+    struct IfcTimeSeriesSchedule : IfcControl, ObjectHelper<IfcTimeSeriesSchedule,3> { IfcTimeSeriesSchedule() : Object("IfcTimeSeriesSchedule") {}
+        Maybe< ListOf< IfcDateTimeSelect, 1, 0 >::Out > ApplicableDates;
+        IfcTimeSeriesScheduleTypeEnum::Out TimeSeriesScheduleType;
+        Lazy< NotImplemented > TimeSeries;
+    };
+
+    // C++ wrapper for IfcTopologyRepresentation
+    struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {}
+
+    };
+
+    // 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,3> { IfcTransportElement() : Object("IfcTransportElement") {}
+        Maybe< IfcTransportElementTypeEnum::Out > OperationType;
+        Maybe< IfcMassMeasure::Out > CapacityByWeight;
+        Maybe< IfcCountMeasure::Out > CapacityByNumber;
+    };
+
+    // 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 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;
+        BOOLEAN::Out SenseAgreement;
+        IfcTrimmingPreference::Out MasterRepresentation;
+    };
+
+    // C++ wrapper for IfcTubeBundleType
+    struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {}
+        IfcTubeBundleTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcTwoDirectionRepeatFactor
+    struct IfcTwoDirectionRepeatFactor : IfcOneDirectionRepeatFactor, ObjectHelper<IfcTwoDirectionRepeatFactor,1> { IfcTwoDirectionRepeatFactor() : Object("IfcTwoDirectionRepeatFactor") {}
+        Lazy< IfcVector > SecondRepeatFactor;
+    };
+
+    // C++ wrapper for IfcUShapeProfileDef
+    struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,8> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {}
+        IfcPositiveLengthMeasure::Out Depth;
+        IfcPositiveLengthMeasure::Out FlangeWidth;
+        IfcPositiveLengthMeasure::Out WebThickness;
+        IfcPositiveLengthMeasure::Out FlangeThickness;
+        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
+        Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
+        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
+    };
+
+    // C++ wrapper for IfcUnitAssignment
+    struct IfcUnitAssignment :  ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {}
+        ListOf< IfcUnit, 1, 0 >::Out Units;
+    };
+
+    // C++ wrapper for IfcUnitaryEquipmentType
+    struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {}
+        IfcUnitaryEquipmentTypeEnum::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 IfcVibrationIsolatorType
+    struct IfcVibrationIsolatorType : IfcDiscreteAccessoryType, 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 IfcWall
+    struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,0> { IfcWall() : Object("IfcWall") {}
+
+    };
+
+    // 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 IfcWasteTerminalType
+    struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {}
+        IfcWasteTerminalTypeEnum::Out PredefinedType;
+    };
+
+    // C++ wrapper for IfcWindow
+    struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,2> { IfcWindow() : Object("IfcWindow") {}
+        Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
+        Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
+    };
+
+    // C++ wrapper for IfcWindowStyle
+    struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {}
+        IfcWindowStyleConstructionEnum::Out ConstructionType;
+        IfcWindowStyleOperationEnum::Out OperationType;
+        BOOLEAN::Out ParameterTakesPrecedence;
+        BOOLEAN::Out Sizeable;
+    };
+
+    // C++ wrapper for IfcWorkControl
+    struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,10> { IfcWorkControl() : Object("IfcWorkControl") {}
+        IfcIdentifier::Out Identifier;
+        IfcDateTimeSelect::Out CreationDate;
+        Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators;
+        Maybe< IfcLabel::Out > Purpose;
+        Maybe< IfcTimeMeasure::Out > Duration;
+        Maybe< IfcTimeMeasure::Out > TotalFloat;
+        IfcDateTimeSelect::Out StartTime;
+        Maybe< IfcDateTimeSelect::Out > FinishTime;
+        Maybe< IfcWorkControlTypeEnum::Out > WorkControlType;
+        Maybe< IfcLabel::Out > UserDefinedControlType;
+    };
+
+    // C++ wrapper for IfcWorkPlan
+    struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,0> { IfcWorkPlan() : Object("IfcWorkPlan") {}
+
+    };
+
+    // C++ wrapper for IfcWorkSchedule
+    struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,0> { IfcWorkSchedule() : Object("IfcWorkSchedule") {}
+
+    };
+
+    // 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< IfcPositiveLengthMeasure::Out > FilletRadius;
+        Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
+    };
+
+    // C++ wrapper for IfcZone
+    struct IfcZone : IfcGroup, ObjectHelper<IfcZone,0> { IfcZone() : Object("IfcZone") {}
+
+    };
+
+    void GetSchema(EXPRESS::ConversionSchema& out);
+    } //! Schema_2x3
+} //! IFC
+
+namespace STEP {
+
+    // ******************************************************************************
+    // Converter stubs
+    // ******************************************************************************
+
+#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);
+    DECL_CONV_STUB(IfcCurve);
+    DECL_CONV_STUB(IfcBoundedCurve);
+    DECL_CONV_STUB(IfcCompositeCurve);
+    DECL_CONV_STUB(Ifc2DCompositeCurve);
+    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(IfcTypeObject);
+    DECL_CONV_STUB(IfcTypeProduct);
+    DECL_CONV_STUB(IfcElementType);
+    DECL_CONV_STUB(IfcDistributionElementType);
+    DECL_CONV_STUB(IfcDistributionControlElementType);
+    DECL_CONV_STUB(IfcActuatorType);
+    DECL_CONV_STUB(IfcDistributionFlowElementType);
+    DECL_CONV_STUB(IfcFlowControllerType);
+    DECL_CONV_STUB(IfcAirTerminalBoxType);
+    DECL_CONV_STUB(IfcFlowTerminalType);
+    DECL_CONV_STUB(IfcAirTerminalType);
+    DECL_CONV_STUB(IfcEnergyConversionDeviceType);
+    DECL_CONV_STUB(IfcAirToAirHeatRecoveryType);
+    DECL_CONV_STUB(IfcAlarmType);
+    DECL_CONV_STUB(IfcDraughtingCallout);
+    DECL_CONV_STUB(IfcDimensionCurveDirectedCallout);
+    DECL_CONV_STUB(IfcAngularDimension);
+    DECL_CONV_STUB(IfcProduct);
+    DECL_CONV_STUB(IfcAnnotation);
+    DECL_CONV_STUB(IfcStyledItem);
+    DECL_CONV_STUB(IfcAnnotationOccurrence);
+    DECL_CONV_STUB(IfcAnnotationCurveOccurrence);
+    DECL_CONV_STUB(IfcAnnotationFillArea);
+    DECL_CONV_STUB(IfcAnnotationFillAreaOccurrence);
+    DECL_CONV_STUB(IfcAnnotationSurface);
+    DECL_CONV_STUB(IfcAnnotationSurfaceOccurrence);
+    DECL_CONV_STUB(IfcAnnotationSymbolOccurrence);
+    DECL_CONV_STUB(IfcAnnotationTextOccurrence);
+    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(IfcIShapeProfileDef);
+    DECL_CONV_STUB(IfcAsymmetricIShapeProfileDef);
+    DECL_CONV_STUB(IfcPlacement);
+    DECL_CONV_STUB(IfcAxis1Placement);
+    DECL_CONV_STUB(IfcAxis2Placement2D);
+    DECL_CONV_STUB(IfcAxis2Placement3D);
+    DECL_CONV_STUB(IfcBSplineCurve);
+    DECL_CONV_STUB(IfcElement);
+    DECL_CONV_STUB(IfcBuildingElement);
+    DECL_CONV_STUB(IfcBeam);
+    DECL_CONV_STUB(IfcBuildingElementType);
+    DECL_CONV_STUB(IfcBeamType);
+    DECL_CONV_STUB(IfcBezierCurve);
+    DECL_CONV_STUB(IfcCsgPrimitive3D);
+    DECL_CONV_STUB(IfcBlock);
+    DECL_CONV_STUB(IfcBoilerType);
+    DECL_CONV_STUB(IfcBooleanResult);
+    DECL_CONV_STUB(IfcBooleanClippingResult);
+    DECL_CONV_STUB(IfcSurface);
+    DECL_CONV_STUB(IfcBoundedSurface);
+    DECL_CONV_STUB(IfcBoundingBox);
+    DECL_CONV_STUB(IfcHalfSpaceSolid);
+    DECL_CONV_STUB(IfcBoxedHalfSpace);
+    DECL_CONV_STUB(IfcSpatialStructureElement);
+    DECL_CONV_STUB(IfcBuilding);
+    DECL_CONV_STUB(IfcBuildingElementComponent);
+    DECL_CONV_STUB(IfcBuildingElementPart);
+    DECL_CONV_STUB(IfcBuildingElementProxy);
+    DECL_CONV_STUB(IfcBuildingElementProxyType);
+    DECL_CONV_STUB(IfcBuildingStorey);
+    DECL_CONV_STUB(IfcCShapeProfileDef);
+    DECL_CONV_STUB(IfcFlowFittingType);
+    DECL_CONV_STUB(IfcCableCarrierFittingType);
+    DECL_CONV_STUB(IfcFlowSegmentType);
+    DECL_CONV_STUB(IfcCableCarrierSegmentType);
+    DECL_CONV_STUB(IfcCableSegmentType);
+    DECL_CONV_STUB(IfcPoint);
+    DECL_CONV_STUB(IfcCartesianPoint);
+    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(IfcFeatureElement);
+    DECL_CONV_STUB(IfcFeatureElementSubtraction);
+    DECL_CONV_STUB(IfcEdgeFeature);
+    DECL_CONV_STUB(IfcChamferEdgeFeature);
+    DECL_CONV_STUB(IfcChillerType);
+    DECL_CONV_STUB(IfcConic);
+    DECL_CONV_STUB(IfcCircle);
+    DECL_CONV_STUB(IfcCircleProfileDef);
+    DECL_CONV_STUB(IfcCircleHollowProfileDef);
+    DECL_CONV_STUB(IfcTopologicalRepresentationItem);
+    DECL_CONV_STUB(IfcConnectedFaceSet);
+    DECL_CONV_STUB(IfcClosedShell);
+    DECL_CONV_STUB(IfcCoilType);
+    DECL_CONV_STUB(IfcColourSpecification);
+    DECL_CONV_STUB(IfcColourRgb);
+    DECL_CONV_STUB(IfcColumn);
+    DECL_CONV_STUB(IfcColumnType);
+    DECL_CONV_STUB(IfcProperty);
+    DECL_CONV_STUB(IfcComplexProperty);
+    DECL_CONV_STUB(IfcCompositeCurveSegment);
+    DECL_CONV_STUB(IfcCompositeProfileDef);
+    DECL_CONV_STUB(IfcFlowMovingDeviceType);
+    DECL_CONV_STUB(IfcCompressorType);
+    DECL_CONV_STUB(IfcCondenserType);
+    DECL_CONV_STUB(IfcCondition);
+    DECL_CONV_STUB(IfcConditionCriterion);
+    DECL_CONV_STUB(IfcResource);
+    DECL_CONV_STUB(IfcConstructionResource);
+    DECL_CONV_STUB(IfcConstructionEquipmentResource);
+    DECL_CONV_STUB(IfcConstructionMaterialResource);
+    DECL_CONV_STUB(IfcConstructionProductResource);
+    DECL_CONV_STUB(IfcNamedUnit);
+    DECL_CONV_STUB(IfcContextDependentUnit);
+    DECL_CONV_STUB(IfcControllerType);
+    DECL_CONV_STUB(IfcConversionBasedUnit);
+    DECL_CONV_STUB(IfcCooledBeamType);
+    DECL_CONV_STUB(IfcCoolingTowerType);
+    DECL_CONV_STUB(IfcCostItem);
+    DECL_CONV_STUB(IfcCostSchedule);
+    DECL_CONV_STUB(IfcCovering);
+    DECL_CONV_STUB(IfcCoveringType);
+    DECL_CONV_STUB(IfcCraneRailAShapeProfileDef);
+    DECL_CONV_STUB(IfcCraneRailFShapeProfileDef);
+    DECL_CONV_STUB(IfcCrewResource);
+    DECL_CONV_STUB(IfcSolidModel);
+    DECL_CONV_STUB(IfcCsgSolid);
+    DECL_CONV_STUB(IfcCurtainWall);
+    DECL_CONV_STUB(IfcCurtainWallType);
+    DECL_CONV_STUB(IfcCurveBoundedPlane);
+    DECL_CONV_STUB(IfcPresentationStyle);
+    DECL_CONV_STUB(IfcDamperType);
+    DECL_CONV_STUB(IfcDefinedSymbol);
+    DECL_CONV_STUB(IfcDerivedProfileDef);
+    DECL_CONV_STUB(IfcDiameterDimension);
+    DECL_CONV_STUB(IfcDimensionCurve);
+    DECL_CONV_STUB(IfcTerminatorSymbol);
+    DECL_CONV_STUB(IfcDimensionCurveTerminator);
+    DECL_CONV_STUB(IfcDirection);
+    DECL_CONV_STUB(IfcElementComponent);
+    DECL_CONV_STUB(IfcDiscreteAccessory);
+    DECL_CONV_STUB(IfcElementComponentType);
+    DECL_CONV_STUB(IfcDiscreteAccessoryType);
+    DECL_CONV_STUB(IfcDistributionElement);
+    DECL_CONV_STUB(IfcDistributionFlowElement);
+    DECL_CONV_STUB(IfcDistributionChamberElement);
+    DECL_CONV_STUB(IfcDistributionChamberElementType);
+    DECL_CONV_STUB(IfcDistributionControlElement);
+    DECL_CONV_STUB(IfcPort);
+    DECL_CONV_STUB(IfcDistributionPort);
+    DECL_CONV_STUB(IfcDoor);
+    DECL_CONV_STUB(IfcPropertyDefinition);
+    DECL_CONV_STUB(IfcPropertySetDefinition);
+    DECL_CONV_STUB(IfcDoorStyle);
+    DECL_CONV_STUB(IfcDuctFittingType);
+    DECL_CONV_STUB(IfcDuctSegmentType);
+    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(IfcElectricApplianceType);
+    DECL_CONV_STUB(IfcFlowController);
+    DECL_CONV_STUB(IfcElectricDistributionPoint);
+    DECL_CONV_STUB(IfcFlowStorageDeviceType);
+    DECL_CONV_STUB(IfcElectricFlowStorageDeviceType);
+    DECL_CONV_STUB(IfcElectricGeneratorType);
+    DECL_CONV_STUB(IfcElectricHeaterType);
+    DECL_CONV_STUB(IfcElectricMotorType);
+    DECL_CONV_STUB(IfcElectricTimeControlType);
+    DECL_CONV_STUB(IfcSystem);
+    DECL_CONV_STUB(IfcElectricalCircuit);
+    DECL_CONV_STUB(IfcElectricalElement);
+    DECL_CONV_STUB(IfcElementAssembly);
+    DECL_CONV_STUB(IfcElementQuantity);
+    DECL_CONV_STUB(IfcElementarySurface);
+    DECL_CONV_STUB(IfcEllipse);
+    DECL_CONV_STUB(IfcEllipseProfileDef);
+    DECL_CONV_STUB(IfcEnergyConversionDevice);
+    DECL_CONV_STUB(IfcEquipmentElement);
+    DECL_CONV_STUB(IfcEquipmentStandard);
+    DECL_CONV_STUB(IfcEvaporativeCoolerType);
+    DECL_CONV_STUB(IfcEvaporatorType);
+    DECL_CONV_STUB(IfcSweptAreaSolid);
+    DECL_CONV_STUB(IfcExtrudedAreaSolid);
+    DECL_CONV_STUB(IfcFace);
+    DECL_CONV_STUB(IfcFaceBasedSurfaceModel);
+    DECL_CONV_STUB(IfcFaceBound);
+    DECL_CONV_STUB(IfcFaceOuterBound);
+    DECL_CONV_STUB(IfcFaceSurface);
+    DECL_CONV_STUB(IfcManifoldSolidBrep);
+    DECL_CONV_STUB(IfcFacetedBrep);
+    DECL_CONV_STUB(IfcFacetedBrepWithVoids);
+    DECL_CONV_STUB(IfcFanType);
+    DECL_CONV_STUB(IfcFastener);
+    DECL_CONV_STUB(IfcFastenerType);
+    DECL_CONV_STUB(IfcFeatureElementAddition);
+    DECL_CONV_STUB(IfcFillAreaStyleHatching);
+    DECL_CONV_STUB(IfcFillAreaStyleTileSymbolWithStyle);
+    DECL_CONV_STUB(IfcFillAreaStyleTiles);
+    DECL_CONV_STUB(IfcFilterType);
+    DECL_CONV_STUB(IfcFireSuppressionTerminalType);
+    DECL_CONV_STUB(IfcFlowFitting);
+    DECL_CONV_STUB(IfcFlowInstrumentType);
+    DECL_CONV_STUB(IfcFlowMeterType);
+    DECL_CONV_STUB(IfcFlowMovingDevice);
+    DECL_CONV_STUB(IfcFlowSegment);
+    DECL_CONV_STUB(IfcFlowStorageDevice);
+    DECL_CONV_STUB(IfcFlowTerminal);
+    DECL_CONV_STUB(IfcFlowTreatmentDevice);
+    DECL_CONV_STUB(IfcFooting);
+    DECL_CONV_STUB(IfcFurnishingElement);
+    DECL_CONV_STUB(IfcFurnishingElementType);
+    DECL_CONV_STUB(IfcFurnitureStandard);
+    DECL_CONV_STUB(IfcFurnitureType);
+    DECL_CONV_STUB(IfcGasTerminalType);
+    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(IfcHeatExchangerType);
+    DECL_CONV_STUB(IfcHumidifierType);
+    DECL_CONV_STUB(IfcInventory);
+    DECL_CONV_STUB(IfcJunctionBoxType);
+    DECL_CONV_STUB(IfcLShapeProfileDef);
+    DECL_CONV_STUB(IfcLaborResource);
+    DECL_CONV_STUB(IfcLampType);
+    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(IfcLinearDimension);
+    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(IfcMember);
+    DECL_CONV_STUB(IfcMemberType);
+    DECL_CONV_STUB(IfcMotorConnectionType);
+    DECL_CONV_STUB(IfcProcess);
+    DECL_CONV_STUB(IfcTask);
+    DECL_CONV_STUB(IfcMove);
+    DECL_CONV_STUB(IfcOccupant);
+    DECL_CONV_STUB(IfcOffsetCurve2D);
+    DECL_CONV_STUB(IfcOffsetCurve3D);
+    DECL_CONV_STUB(IfcOneDirectionRepeatFactor);
+    DECL_CONV_STUB(IfcOpenShell);
+    DECL_CONV_STUB(IfcOpeningElement);
+    DECL_CONV_STUB(IfcOrderAction);
+    DECL_CONV_STUB(IfcOrientedEdge);
+    DECL_CONV_STUB(IfcOutletType);
+    DECL_CONV_STUB(IfcPath);
+    DECL_CONV_STUB(IfcPerformanceHistory);
+    DECL_CONV_STUB(IfcPermit);
+    DECL_CONV_STUB(IfcPile);
+    DECL_CONV_STUB(IfcPipeFittingType);
+    DECL_CONV_STUB(IfcPipeSegmentType);
+    DECL_CONV_STUB(IfcPlanarExtent);
+    DECL_CONV_STUB(IfcPlanarBox);
+    DECL_CONV_STUB(IfcPlane);
+    DECL_CONV_STUB(IfcPlate);
+    DECL_CONV_STUB(IfcPlateType);
+    DECL_CONV_STUB(IfcPointOnCurve);
+    DECL_CONV_STUB(IfcPointOnSurface);
+    DECL_CONV_STUB(IfcPolyLoop);
+    DECL_CONV_STUB(IfcPolygonalBoundedHalfSpace);
+    DECL_CONV_STUB(IfcPolyline);
+    DECL_CONV_STUB(IfcPresentationStyleAssignment);
+    DECL_CONV_STUB(IfcProcedure);
+    DECL_CONV_STUB(IfcProductDefinitionShape);
+    DECL_CONV_STUB(IfcProject);
+    DECL_CONV_STUB(IfcProjectOrder);
+    DECL_CONV_STUB(IfcProjectOrderRecord);
+    DECL_CONV_STUB(IfcProjectionCurve);
+    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(IfcProtectiveDeviceType);
+    DECL_CONV_STUB(IfcProxy);
+    DECL_CONV_STUB(IfcPumpType);
+    DECL_CONV_STUB(IfcRadiusDimension);
+    DECL_CONV_STUB(IfcRailing);
+    DECL_CONV_STUB(IfcRailingType);
+    DECL_CONV_STUB(IfcRamp);
+    DECL_CONV_STUB(IfcRampFlight);
+    DECL_CONV_STUB(IfcRampFlightType);
+    DECL_CONV_STUB(IfcRationalBezierCurve);
+    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(IfcReinforcingMesh);
+    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(IfcRelOverridesProperties);
+    DECL_CONV_STUB(IfcRelVoidsElement);
+    DECL_CONV_STUB(IfcRepresentation);
+    DECL_CONV_STUB(IfcRepresentationMap);
+    DECL_CONV_STUB(IfcRevolvedAreaSolid);
+    DECL_CONV_STUB(IfcRightCircularCone);
+    DECL_CONV_STUB(IfcRightCircularCylinder);
+    DECL_CONV_STUB(IfcRoof);
+    DECL_CONV_STUB(IfcRoundedEdgeFeature);
+    DECL_CONV_STUB(IfcRoundedRectangleProfileDef);
+    DECL_CONV_STUB(IfcSIUnit);
+    DECL_CONV_STUB(IfcSanitaryTerminalType);
+    DECL_CONV_STUB(IfcScheduleTimeControl);
+    DECL_CONV_STUB(IfcSectionedSpine);
+    DECL_CONV_STUB(IfcSensorType);
+    DECL_CONV_STUB(IfcServiceLife);
+    DECL_CONV_STUB(IfcShapeModel);
+    DECL_CONV_STUB(IfcShapeRepresentation);
+    DECL_CONV_STUB(IfcShellBasedSurfaceModel);
+    DECL_CONV_STUB(IfcSite);
+    DECL_CONV_STUB(IfcSlab);
+    DECL_CONV_STUB(IfcSlabType);
+    DECL_CONV_STUB(IfcSpace);
+    DECL_CONV_STUB(IfcSpaceHeaterType);
+    DECL_CONV_STUB(IfcSpaceProgram);
+    DECL_CONV_STUB(IfcSpatialStructureElementType);
+    DECL_CONV_STUB(IfcSpaceType);
+    DECL_CONV_STUB(IfcSphere);
+    DECL_CONV_STUB(IfcStackTerminalType);
+    DECL_CONV_STUB(IfcStair);
+    DECL_CONV_STUB(IfcStairFlight);
+    DECL_CONV_STUB(IfcStairFlightType);
+    DECL_CONV_STUB(IfcStructuralActivity);
+    DECL_CONV_STUB(IfcStructuralAction);
+    DECL_CONV_STUB(IfcStructuralAnalysisModel);
+    DECL_CONV_STUB(IfcStructuralItem);
+    DECL_CONV_STUB(IfcStructuralConnection);
+    DECL_CONV_STUB(IfcStructuralCurveConnection);
+    DECL_CONV_STUB(IfcStructuralMember);
+    DECL_CONV_STUB(IfcStructuralCurveMember);
+    DECL_CONV_STUB(IfcStructuralCurveMemberVarying);
+    DECL_CONV_STUB(IfcStructuralLinearAction);
+    DECL_CONV_STUB(IfcStructuralLinearActionVarying);
+    DECL_CONV_STUB(IfcStructuralLoadGroup);
+    DECL_CONV_STUB(IfcStructuralPlanarAction);
+    DECL_CONV_STUB(IfcStructuralPlanarActionVarying);
+    DECL_CONV_STUB(IfcStructuralPointAction);
+    DECL_CONV_STUB(IfcStructuralPointConnection);
+    DECL_CONV_STUB(IfcStructuralReaction);
+    DECL_CONV_STUB(IfcStructuralPointReaction);
+    DECL_CONV_STUB(IfcStructuralResultGroup);
+    DECL_CONV_STUB(IfcStructuralSurfaceConnection);
+    DECL_CONV_STUB(IfcStructuralSurfaceMember);
+    DECL_CONV_STUB(IfcStructuralSurfaceMemberVarying);
+    DECL_CONV_STUB(IfcStructuredDimensionCallout);
+    DECL_CONV_STUB(IfcStyleModel);
+    DECL_CONV_STUB(IfcStyledRepresentation);
+    DECL_CONV_STUB(IfcSubContractResource);
+    DECL_CONV_STUB(IfcSubedge);
+    DECL_CONV_STUB(IfcSurfaceCurveSweptAreaSolid);
+    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(IfcSwitchingDeviceType);
+    DECL_CONV_STUB(IfcSystemFurnitureElementType);
+    DECL_CONV_STUB(IfcTShapeProfileDef);
+    DECL_CONV_STUB(IfcTankType);
+    DECL_CONV_STUB(IfcTendon);
+    DECL_CONV_STUB(IfcTendonAnchor);
+    DECL_CONV_STUB(IfcTextLiteral);
+    DECL_CONV_STUB(IfcTextLiteralWithExtent);
+    DECL_CONV_STUB(IfcTimeSeriesSchedule);
+    DECL_CONV_STUB(IfcTopologyRepresentation);
+    DECL_CONV_STUB(IfcTransformerType);
+    DECL_CONV_STUB(IfcTransportElement);
+    DECL_CONV_STUB(IfcTransportElementType);
+    DECL_CONV_STUB(IfcTrapeziumProfileDef);
+    DECL_CONV_STUB(IfcTrimmedCurve);
+    DECL_CONV_STUB(IfcTubeBundleType);
+    DECL_CONV_STUB(IfcTwoDirectionRepeatFactor);
+    DECL_CONV_STUB(IfcUShapeProfileDef);
+    DECL_CONV_STUB(IfcUnitAssignment);
+    DECL_CONV_STUB(IfcUnitaryEquipmentType);
+    DECL_CONV_STUB(IfcValveType);
+    DECL_CONV_STUB(IfcVector);
+    DECL_CONV_STUB(IfcVertex);
+    DECL_CONV_STUB(IfcVertexLoop);
+    DECL_CONV_STUB(IfcVertexPoint);
+    DECL_CONV_STUB(IfcVibrationIsolatorType);
+    DECL_CONV_STUB(IfcVirtualElement);
+    DECL_CONV_STUB(IfcWall);
+    DECL_CONV_STUB(IfcWallStandardCase);
+    DECL_CONV_STUB(IfcWallType);
+    DECL_CONV_STUB(IfcWasteTerminalType);
+    DECL_CONV_STUB(IfcWindow);
+    DECL_CONV_STUB(IfcWindowStyle);
+    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
+
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // INCLUDED_IFC_READER_GEN_H
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.cpp
new file mode 100644
index 0000000..1793229
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.cpp
@@ -0,0 +1,6207 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "AssimpPCH.h"
+#include "IFCReaderGen_4.h"
+
+namespace Assimp {
+using namespace IFC;
+using namespace ::Assimp::IFC::Schema_4;
+
+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
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.h
new file mode 100644
index 0000000..abf0219
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.h
@@ -0,0 +1,5452 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 {
+namespace Schema_4 {
+
+	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
+
+} //! Schema_4
+} //! STEP
+} //! Assimp
+
+#endif // INCLUDED_IFC_READER_GEN_H
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.cpp
new file mode 100644
index 0000000..6b378c1
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.cpp
@@ -0,0 +1,701 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFCUtil.cpp
+ *  @brief Implementation of conversion routines for some common Ifc helper entities.
+ */
+
+#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
+
+#include "AssetLib/IFC/IFCUtil.h"
+#include "Common/PolyTools.h"
+#include "PostProcessing/ProcessHelper.h"
+
+namespace Assimp {
+namespace IFC {
+
+// ------------------------------------------------------------------------------------------------
+void TempOpening::Transform(const IfcMatrix4& mat) {
+    if(profileMesh) {
+        profileMesh->Transform(mat);
+    }
+    if(profileMesh2D) {
+        profileMesh2D->Transform(mat);
+    }
+    extrusionDir *= IfcMatrix3(mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMesh* TempMesh::ToMesh()
+{
+    ai_assert(mVerts.size() == std::accumulate(mVertcnt.begin(),mVertcnt.end(),size_t(0)));
+
+    if (mVerts.empty()) {
+        return nullptr;
+    }
+
+    std::unique_ptr<aiMesh> mesh(new aiMesh());
+
+    // copy vertices
+    mesh->mNumVertices = static_cast<unsigned int>(mVerts.size());
+    mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+    std::copy(mVerts.begin(),mVerts.end(),mesh->mVertices);
+
+    // and build up faces
+    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 (!mVertcnt[n]) {
+            --mesh->mNumFaces;
+            continue;
+        }
+
+        f.mNumIndices = mVertcnt[n];
+        f.mIndices = new unsigned int[f.mNumIndices];
+        for(unsigned int a = 0; a < f.mNumIndices; ++a) {
+            f.mIndices[a] = acc++;
+        }
+
+        ++i;
+    }
+
+    return mesh.release();
+}
+
+// ------------------------------------------------------------------------------------------------
+void TempMesh::Clear()
+{
+    mVerts.clear();
+    mVertcnt.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+void TempMesh::Transform(const IfcMatrix4& mat)
+{
+    for(IfcVector3& v : mVerts) {
+        v *= mat;
+    }
+}
+
+// ------------------------------------------------------------------------------
+IfcVector3 TempMesh::Center() const
+{
+    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)
+{
+    mVerts.insert(mVerts.end(),other.mVerts.begin(),other.mVerts.end());
+    mVertcnt.insert(mVertcnt.end(),other.mVertcnt.begin(),other.mVertcnt.end());
+}
+
+// ------------------------------------------------------------------------------------------------
+void TempMesh::RemoveDegenerates()
+{
+    // The strategy is simple: walk the mesh and compute normals using
+    // Newell's algorithm. The length of the normals gives the area
+    // of the polygons, which is close to zero for lines.
+
+    std::vector<IfcVector3> normals;
+    ComputePolygonNormals(normals, false);
+
+    bool drop = false;
+    size_t inor = 0;
+
+    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 = mVertcnt.erase(it);
+            vit = mVerts.erase(vit, vit + pcount);
+
+            drop = true;
+            continue;
+        }
+
+        vit += pcount;
+        ++it;
+    }
+
+    if(drop) {
+        IFCImporter::LogVerboseDebug("removing degenerate faces");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+IfcVector3 TempMesh::ComputePolygonNormal(const IfcVector3* vtcs, size_t cnt, bool normalize)
+{
+    std::vector<IfcFloat> temp((cnt+2)*3);
+    for( size_t vofs = 0, i = 0; vofs < cnt; ++vofs )
+    {
+        const IfcVector3& v = vtcs[vofs];
+        temp[i++] = v.x;
+        temp[i++] = v.y;
+        temp[i++] = v.z;
+    }
+
+    IfcVector3 nor;
+    NewellNormal<3, 3, 3>(nor, static_cast<int>(cnt), &temp[0], &temp[1], &temp[2]);
+    return normalize ? nor.Normalize() : nor;
+}
+
+// ------------------------------------------------------------------------------------------------
+void TempMesh::ComputePolygonNormals(std::vector<IfcVector3>& normals,
+    bool normalize,
+    size_t ofs) const
+{
+    size_t max_vcount = 0;
+    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() + 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(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 = mVerts[vidx+vofs];
+            temp[cnt++] = v.x;
+            temp[cnt++] = v.y;
+            temp[cnt++] = v.z;
+#ifdef ASSIMP_BUILD_DEBUG
+            temp[cnt] = std::numeric_limits<IfcFloat>::quiet_NaN();
+#endif
+            ++cnt;
+        }
+
+        normals.push_back(IfcVector3());
+        NewellNormal<4,4,4>(normals.back(),*iit,&temp[0],&temp[1],&temp[2]);
+    }
+
+    if(normalize) {
+        for(IfcVector3& n : normals) {
+            n.Normalize();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Compute the normal of the last polygon in the given mesh
+IfcVector3 TempMesh::ComputeLastPolygonNormal(bool normalize) const {
+    return ComputePolygonNormal(&mVerts[mVerts.size() - mVertcnt.back()], mVertcnt.back(), normalize);
+}
+
+struct CompareVector {
+    bool operator () (const IfcVector3& a, const IfcVector3& b) const {
+        IfcVector3 d = a - b;
+        IfcFloat eps = ai_epsilon;
+        return d.x < -eps || (std::abs(d.x) < eps && d.y < -eps) || (std::abs(d.x) < eps && std::abs(d.y) < eps && d.z < -eps);
+    }
+};
+
+struct FindVector {
+    IfcVector3 v;
+    FindVector(const IfcVector3& p) : v(p) { }
+    bool operator()(const IfcVector3 &p) {
+        return FuzzyVectorCompare(ai_epsilon)(p, v);
+    }
+};
+
+// ------------------------------------------------------------------------------------------------
+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(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 < mVertcnt.size(); ++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(mVerts.size(), SIZE_MAX);
+    std::vector<size_t> tempIntersect(10);
+    for( size_t a = 0; a < mVertcnt.size(); ++a )
+    {
+        for( size_t b = 0; b < mVertcnt[a]; ++b )
+        {
+            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(
+                facesOnB.begin(), facesOnB.end(), facesOnNB.begin(), facesOnNB.end(), sectstart);
+
+            if( std::distance(sectstart, sectend) != 2 )
+                continue;
+            if( *sectstart == a )
+                ++sectstart;
+            neighbour[ib] = *sectstart;
+        }
+    }
+
+    // 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(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 < mVertcnt.size(); ++a )
+        {
+            if( faceDone[a] )
+                continue;
+            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(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 accept 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 = 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.
+            // Before: points A - B - C - D with edge neighbour p - q - r - s
+            // After: points D - C - B - A, reversed neighbours are s - r - q - p, but the should be
+            //                r   q   p   s
+            for( size_t a = 0; a < fvc - 1; ++a )
+                std::swap(neighbour[fsi + a], neighbour[fsi + a + 1]);
+        }
+        faceDone[farthestIndex] = true;
+        std::vector<size_t> todo;
+        todo.push_back(farthestIndex);
+
+        // go over its neighbour faces recursively and adapt their winding order to match the farthest face
+        while( !todo.empty() )
+        {
+            size_t tdf = todo.back();
+            size_t vsi = faceStartIndices[tdf], vc = mVertcnt[tdf];
+            todo.pop_back();
+
+            // check its neighbours
+            for( size_t a = 0; a < vc; ++a )
+            {
+                // ignore neighbours if we already checked them
+                size_t nbi = neighbour[vsi + a];
+                if( nbi == SIZE_MAX || faceDone[nbi] )
+                    continue;
+
+                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(ai_epsilon)(mVerts[vsi + oursideidx], mVerts[nbvsi + nb_vidx])) {
+                    std::reverse(mVerts.begin() + nbvsi, mVerts.begin() + nbvsi + nbvc);
+                    std::reverse(neighbour.begin() + nbvsi, neighbour.begin() + nbvsi + nbvc);
+                    for (size_t aa = 0; aa < nbvc - 1; ++aa) {
+                        std::swap(neighbour[nbvsi + aa], neighbour[nbvsi + aa + 1]);
+                    }
+                }
+
+                // either way we're done with the neighbour. Mark it as done and continue checking from there recursively
+                faceDone[nbi] = true;
+                todo.push_back(nbi);
+            }
+        }
+
+        // no more faces reachable from this part of the surface, start over with a disjunct part and its farthest face
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void TempMesh::RemoveAdjacentDuplicates() {
+    bool drop = false;
+    std::vector<IfcVector3>::iterator base = mVerts.begin();
+    for(unsigned int& cnt : mVertcnt) {
+        if (cnt < 2){
+            base += cnt;
+            continue;
+        }
+
+        IfcVector3 vmin,vmax;
+        ArrayBounds(&*base, cnt ,vmin,vmax);
+
+
+        const IfcFloat epsilon = (vmax-vmin).SquareLength() / static_cast<IfcFloat>(1e9);
+        //const IfcFloat dotepsilon = 1e-9;
+
+        //// look for vertices that lie directly on the line between their predecessor and their
+        //// successor and replace them with either of them.
+
+        //for(size_t i = 0; i < cnt; ++i) {
+        //  IfcVector3& v1 = *(base+i), &v0 = *(base+(i?i-1:cnt-1)), &v2 = *(base+(i+1)%cnt);
+        //  const IfcVector3& d0 = (v1-v0), &d1 = (v2-v1);
+        //  const IfcFloat l0 = d0.SquareLength(), l1 = d1.SquareLength();
+        //  if (!l0 || !l1) {
+        //      continue;
+        //  }
+
+        //  const IfcFloat d = (d0/std::sqrt(l0))*(d1/std::sqrt(l1));
+
+        //  if ( d >= 1.f-dotepsilon ) {
+        //      v1 = v0;
+        //  }
+        //  else if ( d < -1.f+dotepsilon ) {
+        //      v2 = v1;
+        //      continue;
+        //  }
+        //}
+
+        // drop any identical, adjacent vertices. this pass will collect the dropouts
+        // of the previous pass as a side-effect.
+        FuzzyVectorCompare fz(epsilon);
+        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));
+            mVerts.erase(e,end);
+            drop  = true;
+        }
+
+        // check front and back vertices for this polygon
+        if (cnt > 1 && fz(*base,*(base+cnt-1))) {
+            mVerts.erase(base+ --cnt);
+            drop  = true;
+        }
+
+        // removing adjacent duplicates shouldn't erase everything :-)
+        ai_assert(cnt>0);
+        base += cnt;
+    }
+    if(drop) {
+        IFCImporter::LogVerboseDebug("removing duplicate vertices");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void TempMesh::Swap(TempMesh& other)
+{
+    mVertcnt.swap(other.mVertcnt);
+    mVerts.swap(other.mVerts);
+}
+
+// ------------------------------------------------------------------------------------------------
+bool IsTrue(const ::Assimp::STEP::EXPRESS::BOOLEAN& in)
+{
+    return (std::string)in == "TRUE" || (std::string)in == "T";
+}
+
+// ------------------------------------------------------------------------------------------------
+IfcFloat ConvertSIPrefix(const std::string& prefix)
+{
+    if (prefix == "EXA") {
+        return 1e18f;
+    }
+    else if (prefix == "PETA") {
+        return 1e15f;
+    }
+    else if (prefix == "TERA") {
+        return 1e12f;
+    }
+    else if (prefix == "GIGA") {
+        return 1e9f;
+    }
+    else if (prefix == "MEGA") {
+        return 1e6f;
+    }
+    else if (prefix == "KILO") {
+        return 1e3f;
+    }
+    else if (prefix == "HECTO") {
+        return 1e2f;
+    }
+    else if (prefix == "DECA") {
+        return 1e-0f;
+    }
+    else if (prefix == "DECI") {
+        return 1e-1f;
+    }
+    else if (prefix == "CENTI") {
+        return 1e-2f;
+    }
+    else if (prefix == "MILLI") {
+        return 1e-3f;
+    }
+    else if (prefix == "MICRO") {
+        return 1e-6f;
+    }
+    else if (prefix == "NANO") {
+        return 1e-9f;
+    }
+    else if (prefix == "PICO") {
+        return 1e-12f;
+    }
+    else if (prefix == "FEMTO") {
+        return 1e-15f;
+    }
+    else if (prefix == "ATTO") {
+        return 1e-18f;
+    }
+    else {
+        IFCImporter::LogError("Unrecognized SI prefix: ", prefix);
+        return 1;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourRgb& in)
+{
+    out.r = static_cast<float>( in.Red );
+    out.g = static_cast<float>( in.Green );
+    out.b = static_cast<float>( in.Blue );
+    out.a = static_cast<float>( 1.f );
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base)
+{
+    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 );
+            out.g *= static_cast<float>( base->g );
+            out.b *= static_cast<float>( base->b );
+            out.a = static_cast<float>( base->a );
+        }
+        else out.a = 1.0;
+    }
+    else if (const Schema_2x3::IfcColourRgb* const rgb = in.ResolveSelectPtr<Schema_2x3::IfcColourRgb>(conv.db)) {
+        ConvertColor(out,*rgb);
+    }
+    else {
+        IFCImporter::LogWarn("skipping unknown IfcColourOrFactor entity");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertCartesianPoint(IfcVector3& out, const Schema_2x3::IfcCartesianPoint& in)
+{
+    out = IfcVector3();
+    for(size_t i = 0; i < in.Coordinates.size(); ++i) {
+        out[static_cast<unsigned int>(i)] = in.Coordinates[i];
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertVector(IfcVector3& out, const Schema_2x3::IfcVector& in)
+{
+    ConvertDirection(out,in.Orientation);
+    out *= in.Magnitude;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertDirection(IfcVector3& out, const Schema_2x3::IfcDirection& in)
+{
+    out = IfcVector3();
+    for(size_t i = 0; i < in.DirectionRatios.size(); ++i) {
+        out[static_cast<unsigned int>(i)] = in.DirectionRatios[i];
+    }
+    const IfcFloat len = out.Length();
+    if (len < ai_epsilon) {
+        IFCImporter::LogWarn("direction vector magnitude too small, normalization would result in a division by zero");
+        return;
+    }
+    out /= len;
+}
+
+// ------------------------------------------------------------------------------------------------
+void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y, const IfcVector3& z)
+{
+    out.a1 = x.x;
+    out.b1 = x.y;
+    out.c1 = x.z;
+
+    out.a2 = y.x;
+    out.b2 = y.y;
+    out.c2 = y.z;
+
+    out.a3 = z.x;
+    out.b3 = z.y;
+    out.c3 = z.z;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement3D& in)
+{
+    IfcVector3 loc;
+    ConvertCartesianPoint(loc,in.Location);
+
+    IfcVector3 z(0.f,0.f,1.f),r(1.f,0.f,0.f),x;
+
+    if (in.Axis) {
+        ConvertDirection(z,*in.Axis.Get());
+    }
+    if (in.RefDirection) {
+        ConvertDirection(r,*in.RefDirection.Get());
+    }
+
+    IfcVector3 v = r.Normalize();
+    IfcVector3 tmpx = z * (v*z);
+
+    x = (v-tmpx).Normalize();
+    IfcVector3 y = (z^x);
+
+    IfcMatrix4::Translation(loc,out);
+    AssignMatrixAxes(out,x,y,z);
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement2D& in)
+{
+    IfcVector3 loc;
+    ConvertCartesianPoint(loc,in.Location);
+
+    IfcVector3 x(1.f,0.f,0.f);
+    if (in.RefDirection) {
+        ConvertDirection(x,*in.RefDirection.Get());
+    }
+
+    const IfcVector3 y = IfcVector3(x.y,-x.x,0.f);
+
+    IfcMatrix4::Translation(loc,out);
+    AssignMatrixAxes(out,x,y,IfcVector3(0.f,0.f,1.f));
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const Schema_2x3::IfcAxis1Placement& in)
+{
+    ConvertCartesianPoint(pos,in.Location);
+    if (in.Axis) {
+        ConvertDirection(axis,in.Axis.Get());
+    }
+    else {
+        axis = IfcVector3(0.f,0.f,1.f);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement& in, ConversionData& conv)
+{
+    if(const Schema_2x3::IfcAxis2Placement3D* pl3 = in.ResolveSelectPtr<Schema_2x3::IfcAxis2Placement3D>(conv.db)) {
+        ConvertAxisPlacement(out,*pl3);
+    }
+    else if(const Schema_2x3::IfcAxis2Placement2D* pl2 = in.ResolveSelectPtr<Schema_2x3::IfcAxis2Placement2D>(conv.db)) {
+        ConvertAxisPlacement(out,*pl2);
+    }
+    else {
+        IFCImporter::LogWarn("skipping unknown IfcAxis2Placement entity");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertTransformOperator(IfcMatrix4& out, const Schema_2x3::IfcCartesianTransformationOperator& op)
+{
+    IfcVector3 loc;
+    ConvertCartesianPoint(loc,op.LocalOrigin);
+
+    IfcVector3 x(1.f,0.f,0.f),y(0.f,1.f,0.f),z(0.f,0.f,1.f);
+    if (op.Axis1) {
+        ConvertDirection(x,*op.Axis1.Get());
+    }
+    if (op.Axis2) {
+        ConvertDirection(y,*op.Axis2.Get());
+    }
+    if (const Schema_2x3::IfcCartesianTransformationOperator3D* op2 = op.ToPtr<Schema_2x3::IfcCartesianTransformationOperator3D>()) {
+        if(op2->Axis3) {
+            ConvertDirection(z,*op2->Axis3.Get());
+        }
+    }
+
+    IfcMatrix4 locm;
+    IfcMatrix4::Translation(loc,locm);
+    AssignMatrixAxes(out,x,y,z);
+
+
+    IfcVector3 vscale;
+    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;
+    }
+    else {
+        const IfcFloat sc = op.Scale?op.Scale.Get():1.f;
+        vscale = IfcVector3(sc,sc,sc);
+    }
+
+    IfcMatrix4 s;
+    IfcMatrix4::Scaling(vscale,s);
+
+    out = locm * out * s;
+}
+
+
+} // ! IFC
+} // ! Assimp
+
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.h
new file mode 100644
index 0000000..b5f72a5
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.h
@@ -0,0 +1,411 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp 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 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.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  IFC.cpp
+ *  @brief Implementation of the Industry Foundation Classes loader.
+ */
+
+#ifndef INCLUDED_IFCUTIL_H
+#define INCLUDED_IFCUTIL_H
+
+#include "AssetLib/IFC/IFCReaderGen_2x3.h"
+#include "AssetLib/IFC/IFCLoader.h"
+#include "AssetLib/Step/STEPFile.h"
+
+#include <assimp/mesh.h>
+#include <assimp/material.h>
+
+#include <utility>
+
+struct aiNode;
+
+namespace Assimp {
+namespace IFC {
+
+    typedef double IfcFloat;
+
+    // IfcFloat-precision math data types
+    typedef aiVector2t<IfcFloat> IfcVector2;
+    typedef aiVector3t<IfcFloat> IfcVector3;
+    typedef aiMatrix4x4t<IfcFloat> IfcMatrix4;
+    typedef aiMatrix3x3t<IfcFloat> IfcMatrix3;
+    typedef aiColor4t<IfcFloat> IfcColor4;
+
+
+// ------------------------------------------------------------------------------------------------
+// Helper for std::for_each to delete all heap-allocated items in a container
+// ------------------------------------------------------------------------------------------------
+template<typename T>
+struct delete_fun {
+    void operator()(T* del) {
+        delete del;
+    }
+};
+
+
+
+// ------------------------------------------------------------------------------------------------
+// Helper used during mesh construction. Aids at creating aiMesh'es out of relatively few polygons.
+// ------------------------------------------------------------------------------------------------
+struct TempMesh {
+    std::vector<IfcVector3> mVerts;
+    std::vector<unsigned int> mVertcnt;
+
+    // utilities
+    aiMesh* ToMesh();
+    void Clear();
+    void Transform(const IfcMatrix4& mat);
+    IfcVector3 Center() const;
+    void Append(const TempMesh& other);
+    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::Schema_2x3::IfcSolidModel *solid;
+    IfcVector3 extrusionDir;
+
+    std::shared_ptr<TempMesh> profileMesh;
+    std::shared_ptr<TempMesh> profileMesh2D;
+
+    // list of points generated for this opening. This is used to
+    // create connections between two opposing holes created
+    // from a single opening instance (two because walls tend to
+    // have two sides). If !empty(), the other side of the wall
+    // has already been processed.
+    std::vector<IfcVector3> wallPoints;
+
+    // ------------------------------------------------------------------------------
+    TempOpening()
+        : solid()
+        , extrusionDir()
+        , profileMesh()
+    {
+    }
+
+    // ------------------------------------------------------------------------------
+    TempOpening(const IFC::Schema_2x3::IfcSolidModel *solid, IfcVector3 extrusionDir,
+            std::shared_ptr<TempMesh> profileMesh,
+            std::shared_ptr<TempMesh> profileMesh2D) :
+            solid(solid), extrusionDir(extrusionDir), profileMesh(std::move(profileMesh)), profileMesh2D(std::move(profileMesh2D)) {
+    }
+
+    // ------------------------------------------------------------------------------
+    void Transform(const IfcMatrix4& mat); // defined later since TempMesh is not complete yet
+
+
+
+    // ------------------------------------------------------------------------------
+    // Helper to sort openings by distance from a given base point
+    struct DistanceSorter {
+
+        DistanceSorter(const IfcVector3& base) : base(base) {}
+
+        bool operator () (const TempOpening& a, const TempOpening& b) const {
+            return (a.profileMesh->Center()-base).SquareLength() < (b.profileMesh->Center()-base).SquareLength();
+        }
+
+        IfcVector3 base;
+    };
+};
+
+
+// ------------------------------------------------------------------------------------------------
+// Intermediate data storage during conversion. Keeps everything and a bit more.
+// ------------------------------------------------------------------------------------------------
+struct ConversionData
+{
+    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)
+        , proj(proj)
+        , out(out)
+        , settings(settings)
+        , apply_openings()
+        , collect_openings()
+    {}
+
+    ~ConversionData() {
+        std::for_each(meshes.begin(),meshes.end(),delete_fun<aiMesh>());
+        std::for_each(materials.begin(),materials.end(),delete_fun<aiMaterial>());
+    }
+
+    IfcFloat len_scale, angle_scale;
+    bool plane_angle_in_radians;
+
+    const STEP::DB& db;
+    const IFC::Schema_2x3::IfcProject& proj;
+    aiScene* out;
+
+    IfcMatrix4 wcs;
+    std::vector<aiMesh*> meshes;
+    std::vector<aiMaterial*> materials;
+
+    struct MeshCacheIndex {
+        const IFC::Schema_2x3::IfcRepresentationItem* item; unsigned int matindex;
+        MeshCacheIndex() : item(nullptr), matindex(0) { }
+        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::set<unsigned int> > MeshCache;
+    MeshCache cached_meshes;
+
+    typedef std::map<const IFC::Schema_2x3::IfcSurfaceStyle*, unsigned int> MaterialCache;
+    MaterialCache cached_materials;
+
+    const IFCImporter::Settings& settings;
+
+    // Intermediate arrays used to resolve openings in walls: only one of them
+    // can be given at a time. apply_openings if present if the current element
+    // is a wall and needs its openings to be poured into its geometry while
+    // collect_openings is present only if the current element is an
+    // IfcOpeningElement, for which all the geometry needs to be preserved
+    // for later processing by a parent, which is a wall.
+    std::vector<TempOpening>* apply_openings;
+    std::vector<TempOpening>* collect_openings;
+
+    std::set<uint64_t> already_processed;
+};
+
+
+// ------------------------------------------------------------------------------------------------
+// Binary predicate to compare vectors with a given, quadratic epsilon.
+// ------------------------------------------------------------------------------------------------
+struct FuzzyVectorCompare {
+
+    FuzzyVectorCompare(IfcFloat epsilon) : epsilon(epsilon) {}
+    bool operator()(const IfcVector3& a, const IfcVector3& b) {
+        return std::abs((a-b).SquareLength()) < epsilon;
+    }
+
+    const IfcFloat epsilon;
+};
+
+
+// ------------------------------------------------------------------------------------------------
+// Ordering predicate to totally order R^2 vectors first by x and then by y
+// ------------------------------------------------------------------------------------------------
+struct XYSorter {
+
+    // sort first by X coordinates, then by Y coordinates
+    bool operator () (const IfcVector2&a, const IfcVector2& b) const {
+        if (a.x == b.x) {
+            return a.y < b.y;
+        }
+        return a.x < b.x;
+    }
+};
+
+
+
+// conversion routines for common IFC entities, implemented in IFCUtil.cpp
+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 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 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 Schema_2x3::IfcRepresentationItem& item, unsigned int matid, std::set<unsigned int>& mesh_indices, ConversionData& conv);
+void AssignAddedMeshes(std::set<unsigned int>& mesh_indices,aiNode* nd,ConversionData& /*conv*/);
+
+void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh& meshout,
+                           ConversionData& conv);
+
+void ProcessExtrudedAreaSolid(const Schema_2x3::IfcExtrudedAreaSolid& solid, TempMesh& result,
+                              ConversionData& conv, bool collect_openings);
+
+// IFCBoolean.cpp
+
+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 Schema_2x3::IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
+                                                       const TempMesh& first_operand,
+                                                       ConversionData& conv);
+void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid* as, TempMesh& result,
+                                               const TempMesh& first_operand,
+                                               ConversionData& conv);
+
+
+// IFCOpenings.cpp
+
+bool GenerateOpenings(std::vector<TempOpening>& openings,
+                      TempMesh& curmesh,
+                      bool check_intersection,
+                      bool generate_connection_geometry,
+                      const IfcVector3& wall_extrusion_axis = IfcVector3(0,1,0));
+
+
+
+// IFCCurve.cpp
+
+// ------------------------------------------------------------------------------------------------
+// Custom exception for use by members of the Curve class
+// ------------------------------------------------------------------------------------------------
+class CurveError {
+public:
+    CurveError(const std::string& s)
+    : mStr(s) {
+        // empty
+    }
+
+    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 {
+protected:
+    Curve(const Schema_2x3::IfcCurve& base_entity, ConversionData& conv)
+    : base_entity(base_entity)
+    , conv(conv) {
+        // empty
+    }
+
+public:
+    typedef std::pair<IfcFloat, IfcFloat> ParamRange;
+
+    virtual ~Curve() {}
+
+
+    // check if a curve is closed
+    virtual bool IsClosed() const = 0;
+
+    // evaluate the curve at the given parametric position
+    virtual IfcVector3 Eval(IfcFloat p) const = 0;
+
+    // try to match a point on the curve to a given parameter
+    // for self-intersecting curves, the result is not ambiguous and
+    // it is undefined which parameter is returned.
+    virtual bool ReverseEval(const IfcVector3& val, IfcFloat& paramOut) const;
+
+    // get the range of the curve (both inclusive).
+    // +inf and -inf are valid return values, the curve is not bounded in such a case.
+    virtual std::pair<IfcFloat,IfcFloat> GetParametricRange() const = 0;
+    IfcFloat GetParametricRangeDelta() const;
+
+    // estimate the number of sample points that this curve will require
+    virtual size_t EstimateSampleCount(IfcFloat start,IfcFloat end) const;
+
+    // intelligently sample the curve based on the current settings
+    // and append the result to the mesh
+    virtual void SampleDiscrete(TempMesh& out,IfcFloat start,IfcFloat end) const;
+
+#ifdef ASSIMP_BUILD_DEBUG
+    // check if a particular parameter value lies within the well-defined range
+    bool InRange(IfcFloat) const;
+#endif
+    static Curve* Convert(const IFC::Schema_2x3::IfcCurve&,ConversionData& conv);
+
+protected:
+    const Schema_2x3::IfcCurve& base_entity;
+    ConversionData& conv;
+};
+
+
+// --------------------------------------------------------------------------------
+// A BoundedCurve always holds the invariant that GetParametricRange()
+// never returns infinite values.
+// --------------------------------------------------------------------------------
+class BoundedCurve : public Curve {
+public:
+    BoundedCurve(const Schema_2x3::IfcBoundedCurve& entity, ConversionData& conv)
+        : Curve(entity,conv)
+    {}
+
+public:
+
+    bool IsClosed() const;
+
+public:
+
+    // sample the entire curve
+    void SampleDiscrete(TempMesh& out) const;
+    using Curve::SampleDiscrete;
+};
+
+// IfcProfile.cpp
+bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
+}
+}
+
+#endif