diff --git a/.gitignore b/.gitignore
index e975976bf..fe59f9a70 100644
--- a/.gitignore
+++ b/.gitignore
@@ -79,6 +79,12 @@ test/gtest/src/gtest-stamp/Debug/
 tools/assimp_view/assimp_viewer.vcxproj.user
 *.pyc
 
+### Rust ###
+# Generated by Cargo; will have compiled files and executables
+port/assimp_rs/target/
+# Backup files generated by rustfmt
+port/assimp_rs/**/*.rs.bk
+
 # Unix editor backups
 *~
 test/gtest/src/gtest-stamp/gtest-gitinfo.txt
diff --git a/INSTALL b/INSTALL
index 350a5f109..ecec2585b 100644
--- a/INSTALL
+++ b/INSTALL
@@ -1,50 +1,50 @@
-	
-========================================================================
-Open Asset Import Library (assimp) INSTALL 
-========================================================================
-
-------------------------------
-Getting the documentation
-------------------------------
-
-A regularly-updated copy is available at 
-http://assimp.sourceforge.net/lib_html/index.html
-
-A CHM file is included in the SVN repos: ./doc/AssimpDoc_Html/AssimpDoc.chm.
-To build the doxygen documentation on your own, follow these steps:
-
-a) download & install latest doxygen 
-b) make sure doxygen is in the executable search path
-c) navigate to ./doc
-d) and run 'doxygen'
-
-Open the generated HTML (AssimpDoc_Html/index.html) in the browser of your choice.
-Windows only: To generate the CHM doc, install 'Microsoft HTML Workshop'
-and configure the path to it in the DOXYFILE first. 
-
-------------------------------
-Building Assimp 
-------------------------------
-
-More detailed build instructions can be found in the documentation,
-this section is just for the inpatient among you.
-
-CMake is the preferred build system for Assimp. The minimum required version 
-is 2.6. If you don't have it yet, downloads for CMake can be found on
-http://www.cmake.org/. 
-
-For Unix:
-
-1. mkdir build && cd build
-2. cmake .. -G 'Unix Makefiles'
-3. make -j4
-
-For Windows:
-1. Open a command prompt
-2. mkdir build
-3. cd build
-4. cmake ..
-5. cmake --build .
-
-For iOS:
-Just check the following project, which deploys a compiler toolchain for different iOS-versions: https://github.com/assimp/assimp/tree/master/port/iOS
+	
+========================================================================
+Open Asset Import Library (assimp) INSTALL 
+========================================================================
+
+------------------------------
+Getting the documentation
+------------------------------
+
+A regularly-updated copy is available at 
+http://assimp.sourceforge.net/lib_html/index.html
+
+A CHM file is included in the SVN repos: ./doc/AssimpDoc_Html/AssimpDoc.chm.
+To build the doxygen documentation on your own, follow these steps:
+
+a) download & install latest doxygen 
+b) make sure doxygen is in the executable search path
+c) navigate to ./doc
+d) and run 'doxygen'
+
+Open the generated HTML (AssimpDoc_Html/index.html) in the browser of your choice.
+Windows only: To generate the CHM doc, install 'Microsoft HTML Workshop'
+and configure the path to it in the DOXYFILE first. 
+
+------------------------------
+Building Assimp 
+------------------------------
+
+More detailed build instructions can be found in the documentation,
+this section is just for the inpatient among you.
+
+CMake is the preferred build system for Assimp. The minimum required version 
+is 2.6. If you don't have it yet, downloads for CMake can be found on
+http://www.cmake.org/. 
+
+For Unix:
+
+1. mkdir build && cd build
+2. cmake .. -G 'Unix Makefiles'
+3. make -j4
+
+For Windows:
+1. Open a command prompt
+2. mkdir build
+3. cd build
+4. cmake ..
+5. cmake --build .
+
+For iOS:
+Just check the following project, which deploys a compiler toolchain for different iOS-versions: https://github.com/assimp/assimp/tree/master/port/iOS
diff --git a/code/AssetLib/AMF/AMFImporter_Geometry.cpp b/code/AssetLib/AMF/AMFImporter_Geometry.cpp
index e9a50b656..45be05df1 100644
--- a/code/AssetLib/AMF/AMFImporter_Geometry.cpp
+++ b/code/AssetLib/AMF/AMFImporter_Geometry.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/code/AssetLib/AMF/AMFImporter_Macro.hpp b/code/AssetLib/AMF/AMFImporter_Macro.hpp
index ec06cb999..5877a62d2 100644
--- a/code/AssetLib/AMF/AMFImporter_Macro.hpp
+++ b/code/AssetLib/AMF/AMFImporter_Macro.hpp
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/code/AssetLib/AMF/AMFImporter_Material.cpp b/code/AssetLib/AMF/AMFImporter_Material.cpp
index 64da12dda..7ab5710da 100644
--- a/code/AssetLib/AMF/AMFImporter_Material.cpp
+++ b/code/AssetLib/AMF/AMFImporter_Material.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/code/AssetLib/AMF/AMFImporter_Node.hpp b/code/AssetLib/AMF/AMFImporter_Node.hpp
index b7b7836f3..ea65e106b 100644
--- a/code/AssetLib/AMF/AMFImporter_Node.hpp
+++ b/code/AssetLib/AMF/AMFImporter_Node.hpp
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/code/AssetLib/Collada/ColladaLoader.cpp b/code/AssetLib/Collada/ColladaLoader.cpp
index 8ca0b130e..4e7434fe3 100644
--- a/code/AssetLib/Collada/ColladaLoader.cpp
+++ b/code/AssetLib/Collada/ColladaLoader.cpp
@@ -83,6 +83,18 @@ static const aiImporterDesc desc = {
     "dae zae"
 };
 
+static const float kMillisecondsFromSeconds = 1000.f;
+
+// Add an item of metadata to a node
+// Assumes the key is not already in the list
+template <typename T>
+inline void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) {
+    if (nullptr == node->mMetaData) {
+        node->mMetaData = new aiMetadata();
+    }
+    node->mMetaData->Add(key, value);
+}
+
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 ColladaLoader::ColladaLoader() :
@@ -230,27 +242,15 @@ void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IO
         }
     }
 
-    // store all meshes
     StoreSceneMeshes(pScene);
-
-    // store all materials
     StoreSceneMaterials(pScene);
-
-    // store all textures
     StoreSceneTextures(pScene);
-
-    // store all lights
     StoreSceneLights(pScene);
-
-    // store all cameras
     StoreSceneCameras(pScene);
-
-    // store all animations
     StoreAnimations(pScene, parser);
 
     // If no meshes have been loaded, it's probably just an animated skeleton.
     if (0u == pScene->mNumMeshes) {
-
         if (!noSkeletonMesh) {
             SkeletonMeshBuilder hero(pScene);
         }
@@ -258,15 +258,6 @@ void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IO
     }
 }
 
-// Add an item of metadata to a node
-// Assumes the key is not already in the list
-template <typename T>
-inline void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) {
-    if (nullptr == node->mMetaData)
-        node->mMetaData = new aiMetadata();
-    node->mMetaData->Add(key, value);
-}
-
 // ------------------------------------------------------------------------------------------------
 // Recursively constructs a scene node for the given parser node and returns it.
 aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode) {
@@ -277,10 +268,12 @@ aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collad
     node->mName.Set(FindNameForNode(pNode));
     // if we're not using the unique IDs, hold onto them for reference and export
     if (useColladaName) {
-        if (!pNode->mID.empty())
+        if (!pNode->mID.empty()) {
             AddNodeMetaData(node, AI_METADATA_COLLADA_ID, aiString(pNode->mID));
-        if (!pNode->mSID.empty())
+        }
+        if (!pNode->mSID.empty()) {
             AddNodeMetaData(node, AI_METADATA_COLLADA_SID, aiString(pNode->mSID));
+        }
     }
 
     // calculate the transformation matrix for it
@@ -305,13 +298,8 @@ aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collad
         node->mChildren[pNode->mChildren.size() + a]->mParent = node;
     }
 
-    // construct meshes
     BuildMeshesForNode(pParser, pNode, node);
-
-    // construct cameras
     BuildCamerasForNode(pParser, pNode, node);
-
-    // construct lights
     BuildLightsForNode(pParser, pNode, node);
 
     return node;
@@ -347,9 +335,7 @@ void ColladaLoader::ResolveNodeInstances(const ColladaParser &pParser, const Col
 
 // ------------------------------------------------------------------------------------------------
 // Resolve UV channels
-void ColladaLoader::ApplyVertexToEffectSemanticMapping(Collada::Sampler &sampler,
-
-        const Collada::SemanticMappingTable &table) {
+void ColladaLoader::ApplyVertexToEffectSemanticMapping(Collada::Sampler &sampler, const Collada::SemanticMappingTable &table) {
     std::map<std::string, Collada::InputSemanticMapEntry>::const_iterator it = table.mMap.find(sampler.mUVChannel);
     if (it != table.mMap.end()) {
         if (it->second.mType != Collada::IT_Texcoord) {
@@ -599,6 +585,10 @@ void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Colla
 // ------------------------------------------------------------------------------------------------
 // Find mesh from either meshes or morph target meshes
 aiMesh *ColladaLoader::findMesh(const std::string &meshid) {
+    if ( meshid.empty()) {
+        return nullptr;
+    }
+    
     for (unsigned int i = 0; i < mMeshes.size(); ++i) {
         if (std::string(mMeshes[i]->mName.data) == meshid) {
             return mMeshes[i];
@@ -1386,9 +1376,9 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
                 double time = double(mat.d4); // remember? time is stored in mat.d4
                 mat.d4 = 1.0f;
 
-                dstAnim->mPositionKeys[a].mTime = time;
-                dstAnim->mRotationKeys[a].mTime = time;
-                dstAnim->mScalingKeys[a].mTime = time;
+                dstAnim->mPositionKeys[a].mTime = time * kMillisecondsFromSeconds ;
+                dstAnim->mRotationKeys[a].mTime = time * kMillisecondsFromSeconds ;
+                dstAnim->mScalingKeys[a].mTime = time * kMillisecondsFromSeconds ;
                 mat.Decompose(dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue);
             }
 
@@ -1409,7 +1399,7 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
                 if (e.mTargetId.find("morph-weights") != std::string::npos)
                     morphChannels.push_back(e);
             }
-            if (morphChannels.size() > 0) {
+            if (!morphChannels.empty() ) {
                 // either 1) morph weight animation count should contain morph target count channels
                 // or     2) one channel with morph target count arrays
                 // assume first
@@ -1418,7 +1408,6 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
                 morphAnim->mName.Set(nodeName);
 
                 std::vector<MorphTimeValues> morphTimeValues;
-
                 int morphAnimChannelIndex = 0;
                 for (std::vector<Collada::ChannelEntry>::iterator it = morphChannels.begin(); it != morphChannels.end(); ++it) {
                     Collada::ChannelEntry &e = *it;
@@ -1430,8 +1419,9 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
 
                     // weight target can be in format Weight_M_N, Weight_N, WeightN, or some other way
                     // we ignore the name and just assume the channels are in the right order
-                    for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++)
-                        insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues.at(i), e.mValueData->mValues.at(i), morphAnimChannelIndex);
+                    for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++) {
+                        insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues[i], e.mValueData->mValues[i], morphAnimChannelIndex);
+                    }
 
                     ++morphAnimChannelIndex;
                 }
@@ -1443,8 +1433,8 @@ void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParse
                     morphAnim->mKeys[key].mValues = new unsigned int[morphChannels.size()];
                     morphAnim->mKeys[key].mWeights = new double[morphChannels.size()];
 
-                    morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime;
-                    for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); valueIndex++) {
+                    morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime * kMillisecondsFromSeconds ;
+                    for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); ++valueIndex ) {
                         morphAnim->mKeys[key].mValues[valueIndex] = valueIndex;
                         morphAnim->mKeys[key].mWeights[valueIndex] = getWeightAtKey(morphTimeValues, key, valueIndex);
                     }
@@ -1494,18 +1484,22 @@ void ColladaLoader::AddTexture(aiMaterial &mat, const ColladaParser &pParser,
 
     // mapping mode
     int map = aiTextureMapMode_Clamp;
-    if (sampler.mWrapU)
+    if (sampler.mWrapU) {
         map = aiTextureMapMode_Wrap;
-    if (sampler.mWrapU && sampler.mMirrorU)
+    }
+    if (sampler.mWrapU && sampler.mMirrorU) {
         map = aiTextureMapMode_Mirror;
+    }
 
     mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_U_BASE, type, idx);
 
     map = aiTextureMapMode_Clamp;
-    if (sampler.mWrapV)
+    if (sampler.mWrapV) {
         map = aiTextureMapMode_Wrap;
-    if (sampler.mWrapV && sampler.mMirrorV)
+    }
+    if (sampler.mWrapV && sampler.mMirrorV) {
         map = aiTextureMapMode_Mirror;
+    }
 
     mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_V_BASE, type, idx);
 
@@ -1526,9 +1520,9 @@ void ColladaLoader::AddTexture(aiMaterial &mat, const ColladaParser &pParser,
     // number in the channel name. We assume it is the zero-based index into the
     // UV channel array of all corresponding meshes. It could also be one-based
     // for some exporters, but we won't care of it unless someone complains about.
-    if (sampler.mUVId != UINT_MAX)
+    if (sampler.mUVId != UINT_MAX) {
         map = sampler.mUVId;
-    else {
+    } else {
         map = -1;
         for (std::string::const_iterator it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) {
             if (IsNumeric(*it)) {
@@ -1553,27 +1547,27 @@ void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pSce
 
         // resolve shading mode
         int shadeMode;
-        if (effect.mFaceted) /* fixme */
+        if (effect.mFaceted) {
             shadeMode = aiShadingMode_Flat;
-        else {
+        } else {
             switch (effect.mShadeType) {
-            case Collada::Shade_Constant:
-                shadeMode = aiShadingMode_NoShading;
-                break;
-            case Collada::Shade_Lambert:
-                shadeMode = aiShadingMode_Gouraud;
-                break;
-            case Collada::Shade_Blinn:
-                shadeMode = aiShadingMode_Blinn;
-                break;
-            case Collada::Shade_Phong:
-                shadeMode = aiShadingMode_Phong;
-                break;
+                case Collada::Shade_Constant:
+                    shadeMode = aiShadingMode_NoShading;
+                    break;
+                case Collada::Shade_Lambert:
+                    shadeMode = aiShadingMode_Gouraud;
+                    break;
+                case Collada::Shade_Blinn:
+                    shadeMode = aiShadingMode_Blinn;
+                    break;
+                case Collada::Shade_Phong:
+                    shadeMode = aiShadingMode_Phong;
+                    break;
 
-            default:
-                ASSIMP_LOG_WARN("Collada: Unrecognized shading mode, using gouraud shading");
-                shadeMode = aiShadingMode_Gouraud;
-                break;
+                default:
+                    ASSIMP_LOG_WARN("Collada: Unrecognized shading mode, using gouraud shading");
+                    shadeMode = aiShadingMode_Gouraud;
+                    break;
             }
         }
         mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
@@ -1679,23 +1673,6 @@ void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/)
     // ScenePreprocessor generates a default material automatically if none is there.
     // All further code here in this loader works well without a valid material so
     // we can safely let it to ScenePreprocessor.
-#if 0
-    if (newMats.size() == 0)
-    {
-        aiMaterial* mat = new aiMaterial;
-        aiString name(AI_DEFAULT_MATERIAL_NAME);
-        mat->AddProperty(&name, AI_MATKEY_NAME);
-
-        const int shadeMode = aiShadingMode_Phong;
-        mat->AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
-        aiColor4D colAmbient(0.2, 0.2, 0.2, 1.0), colDiffuse(0.8, 0.8, 0.8, 1.0), colSpecular(0.5, 0.5, 0.5, 0.5);
-        mat->AddProperty(&colAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
-        mat->AddProperty(&colDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-        mat->AddProperty(&colSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
-        const ai_real specExp = 5.0;
-        mat->AddProperty(&specExp, 1, AI_MATKEY_SHININESS);
-}
-#endif
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1755,20 +1732,21 @@ aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParse
 
         // and add this texture to the list
         mTextures.push_back(tex);
-    } else {
-        if (imIt->second.mFileName.empty()) {
-            throw DeadlyImportError("Collada: Invalid texture, no data or file reference given");
-        }
+        return result;
+    } 
 
-        result.Set(imIt->second.mFileName);
+    if (imIt->second.mFileName.empty()) {
+        throw DeadlyImportError("Collada: Invalid texture, no data or file reference given");
     }
+
+    result.Set(imIt->second.mFileName);
+
     return result;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reads a float value from an accessor and its data array.
 ai_real ColladaLoader::ReadFloat(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex, size_t pOffset) const {
-    // FIXME: (thom) Test for data type here in every access? For the moment, I leave this to the caller
     size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset;
     ai_assert(pos < pData.mValues.size());
     return pData.mValues[pos];
diff --git a/code/AssetLib/FBX/FBXConverter.cpp b/code/AssetLib/FBX/FBXConverter.cpp
index 1bf977189..cf50c715b 100644
--- a/code/AssetLib/FBX/FBXConverter.cpp
+++ b/code/AssetLib/FBX/FBXConverter.cpp
@@ -3315,6 +3315,7 @@ void FBXConverter::InterpolateKeys(aiQuatKey *valOut, const KeyTimeList &keys, c
         // http://www.3dkingdoms.com/weekly/weekly.php?a=36
         if (quat.x * lastq.x + quat.y * lastq.y + quat.z * lastq.z + quat.w * lastq.w < 0) {
             quat.Conjugate();
+            quat.w = -quat.w;
         }
         lastq = quat;
 
diff --git a/code/AssetLib/MMD/MMDImporter.h b/code/AssetLib/MMD/MMDImporter.h
index 1cc91c782..b1fdb9f6a 100644
--- a/code/AssetLib/MMD/MMDImporter.h
+++ b/code/AssetLib/MMD/MMDImporter.h
@@ -93,4 +93,4 @@ private:
 
 } // Namespace Assimp
 
-#endif
\ No newline at end of file
+#endif
diff --git a/code/AssetLib/StepFile/StepFileGen1.cpp b/code/AssetLib/StepFile/StepFileGen1.cpp
deleted file mode 100644
index 077b2d4c5..000000000
--- a/code/AssetLib/StepFile/StepFileGen1.cpp
+++ /dev/null
@@ -1,2194 +0,0 @@
-/*
-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_STEP_IMPORTER
-
-#include "code/Importer/StepFile/StepReaderGen.h"
-
-namespace Assimp {
-using namespace StepFile;
-
-namespace {
-
-	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
-
-	const SchemaEntry schema_raw[] =  {
-		SchemaEntry("absorbed_dose_measure",NULL )
-,		SchemaEntry("acceleration_measure",NULL )
-,		SchemaEntry("action_items",NULL )
-,		SchemaEntry("action_method_items",NULL )
-,		SchemaEntry("action_request_item",NULL )
-,		SchemaEntry("ahead_or_behind",NULL )
-,		SchemaEntry("amount_of_substance_measure",NULL )
-,		SchemaEntry("angle_direction_reference_select",NULL )
-,		SchemaEntry("angle_direction_reference_with_a2p3d_select",NULL )
-,		SchemaEntry("angle_relator",NULL )
-,		SchemaEntry("annotation_plane_element",NULL )
-,		SchemaEntry("annotation_representation_select",NULL )
-,		SchemaEntry("annotation_symbol_occurrence_item",NULL )
-,		SchemaEntry("annotation_text_occurrence_item",NULL )
-,		SchemaEntry("approval_item",NULL )
-,		SchemaEntry("approved_item",NULL )
-,		SchemaEntry("area_measure",NULL )
-,		SchemaEntry("area_or_view",NULL )
-,		SchemaEntry("attribute_classification_item",NULL )
-,		SchemaEntry("attribute_language_item",NULL )
-,		SchemaEntry("attribute_type",NULL )
-,		SchemaEntry("axis2_placement",NULL )
-,		SchemaEntry("b_spline_curve_form",NULL )
-,		SchemaEntry("b_spline_surface_form",NULL )
-,		SchemaEntry("base_solid_select",NULL )
-,		SchemaEntry("blend_end_condition_select",NULL )
-,		SchemaEntry("blend_radius_variation_type",NULL )
-,		SchemaEntry("boolean_operand",NULL )
-,		SchemaEntry("boolean_operator",NULL )
-,		SchemaEntry("box_characteristic_select",NULL )
-,		SchemaEntry("box_height",NULL )
-,		SchemaEntry("box_rotate_angle",NULL )
-,		SchemaEntry("box_slant_angle",NULL )
-,		SchemaEntry("box_width",NULL )
-,		SchemaEntry("camera_model_d3_multi_clipping_interection_select",NULL )
-,		SchemaEntry("camera_model_d3_multi_clipping_union_select",NULL )
-,		SchemaEntry("capacitance_measure",NULL )
-,		SchemaEntry("category_usage_item",NULL )
-,		SchemaEntry("cc_classified_item",NULL )
-,		SchemaEntry("cc_person_organization_item",NULL )
-,		SchemaEntry("cc_specified_item",NULL )
-,		SchemaEntry("celsius_temperature_measure",NULL )
-,		SchemaEntry("central_or_parallel",NULL )
-,		SchemaEntry("certification_item",NULL )
-,		SchemaEntry("certified_item",NULL )
-,		SchemaEntry("change_request_item",NULL )
-,		SchemaEntry("character_spacing_select",NULL )
-,		SchemaEntry("character_style_select",NULL )
-,		SchemaEntry("characterized_action_definition",NULL )
-,		SchemaEntry("characterized_definition",NULL )
-,		SchemaEntry("characterized_material_property",NULL )
-,		SchemaEntry("characterized_product_composition_value",NULL )
-,		SchemaEntry("characterized_product_definition",NULL )
-,		SchemaEntry("class_usage_effectivity_context_item",NULL )
-,		SchemaEntry("classification_item",NULL )
-,		SchemaEntry("classified_item",NULL )
-,		SchemaEntry("compound_item_definition",NULL )
-,		SchemaEntry("conductance_measure",NULL )
-,		SchemaEntry("configuration_design_item",NULL )
-,		SchemaEntry("configured_effectivity_context_item",NULL )
-,		SchemaEntry("configured_effectivity_item",NULL )
-,		SchemaEntry("constructive_geometry_representation_or_shape_represenation",NULL )
-,		SchemaEntry("context_dependent_measure",NULL )
-,		SchemaEntry("contract_item",NULL )
-,		SchemaEntry("contracted_item",NULL )
-,		SchemaEntry("count_measure",NULL )
-,		SchemaEntry("csg_primitive",NULL )
-,		SchemaEntry("csg_select",NULL )
-,		SchemaEntry("curve_font_or_scaled_curve_font_select",NULL )
-,		SchemaEntry("curve_on_surface",NULL )
-,		SchemaEntry("curve_or_annotation_curve_occurrence",NULL )
-,		SchemaEntry("curve_or_render",NULL )
-,		SchemaEntry("curve_style_font_select",NULL )
-,		SchemaEntry("date_and_time_item",NULL )
-,		SchemaEntry("date_item",NULL )
-,		SchemaEntry("date_time_item",NULL )
-,		SchemaEntry("date_time_or_event_occurrence",NULL )
-,		SchemaEntry("date_time_select",NULL )
-,		SchemaEntry("day_in_month_number",NULL )
-,		SchemaEntry("day_in_week_number",NULL )
-,		SchemaEntry("day_in_year_number",NULL )
-,		SchemaEntry("defined_symbol_select",NULL )
-,		SchemaEntry("derived_property_select",NULL )
-,		SchemaEntry("description_attribute_select",NULL )
-,		SchemaEntry("descriptive_measure",NULL )
-,		SchemaEntry("dimension_count",NULL )
-,		SchemaEntry("dimension_extent_usage",NULL )
-,		SchemaEntry("dimensional_characteristic",NULL )
-,		SchemaEntry("direction_count_select",NULL )
-,		SchemaEntry("document_identifier_assigned_item",NULL )
-,		SchemaEntry("document_reference_item",NULL )
-,		SchemaEntry("dose_equivalent_measure",NULL )
-,		SchemaEntry("draughting_callout_element",NULL )
-,		SchemaEntry("draughting_model_item_association_select",NULL )
-,		SchemaEntry("draughting_model_item_select",NULL )
-,		SchemaEntry("draughting_titled_item",NULL )
-,		SchemaEntry("effectivity_item",NULL )
-,		SchemaEntry("electric_charge_measure",NULL )
-,		SchemaEntry("electric_current_measure",NULL )
-,		SchemaEntry("electric_potential_measure",NULL )
-,		SchemaEntry("energy_measure",NULL )
-,		SchemaEntry("event_occurrence_item",NULL )
-,		SchemaEntry("external_identification_item",NULL )
-,		SchemaEntry("fill_area_style_tile_shape_select",NULL )
-,		SchemaEntry("fill_style_select",NULL )
-,		SchemaEntry("font_select",NULL )
-,		SchemaEntry("force_measure",NULL )
-,		SchemaEntry("founded_item_select",NULL )
-,		SchemaEntry("frequency_measure",NULL )
-,		SchemaEntry("generalized_surface_select",NULL )
-,		SchemaEntry("geometric_item_specific_usage_select",NULL )
-,		SchemaEntry("geometric_set_select",NULL )
-,		SchemaEntry("groupable_item",NULL )
-,		SchemaEntry("hour_in_day",NULL )
-,		SchemaEntry("id_attribute_select",NULL )
-,		SchemaEntry("identification_item",NULL )
-,		SchemaEntry("identifier",NULL )
-,		SchemaEntry("illuminance_measure",NULL )
-,		SchemaEntry("inductance_measure",NULL )
-,		SchemaEntry("instance_usage_context_select",NULL )
-,		SchemaEntry("invisibility_context",NULL )
-,		SchemaEntry("invisible_item",NULL )
-,		SchemaEntry("ir_usage_item",NULL )
-,		SchemaEntry("knot_type",NULL )
-,		SchemaEntry("label",NULL )
-,		SchemaEntry("layered_item",NULL )
-,		SchemaEntry("length_measure",NULL )
-,		SchemaEntry("limit_condition",NULL )
-,		SchemaEntry("list_of_reversible_topology_item",NULL )
-,		SchemaEntry("list_representation_item",NULL )
-,		SchemaEntry("luminous_flux_measure",NULL )
-,		SchemaEntry("luminous_intensity_measure",NULL )
-,		SchemaEntry("magnetic_flux_density_measure",NULL )
-,		SchemaEntry("magnetic_flux_measure",NULL )
-,		SchemaEntry("marker_select",NULL )
-,		SchemaEntry("marker_type",NULL )
-,		SchemaEntry("mass_measure",NULL )
-,		SchemaEntry("measure_value",NULL )
-,		SchemaEntry("mechanical_design_and_draughting_relationship_select",NULL )
-,		SchemaEntry("mechanical_design_geometric_presentation_area_items",NULL )
-,		SchemaEntry("mechanical_design_geometric_presentation_representation_items",NULL )
-,		SchemaEntry("message",NULL )
-,		SchemaEntry("minute_in_hour",NULL )
-,		SchemaEntry("month_in_year_number",NULL )
-,		SchemaEntry("multi_language_attribute_item",NULL )
-,		SchemaEntry("name_attribute_select",NULL )
-,		SchemaEntry("name_item",NULL )
-,		SchemaEntry("non_negative_length_measure",NULL )
-,		SchemaEntry("nonnegative_integer",NULL )
-,		SchemaEntry("null_style",NULL )
-,		SchemaEntry("numeric_measure",NULL )
-,		SchemaEntry("organization_item",NULL )
-,		SchemaEntry("orientation_basis_select",NULL )
-,		SchemaEntry("parameter_value",NULL )
-,		SchemaEntry("pcurve_or_surface",NULL )
-,		SchemaEntry("person_and_organization_item",NULL )
-,		SchemaEntry("person_organization_select",NULL )
-,		SchemaEntry("picture_representation_item_select",NULL )
-,		SchemaEntry("plane_angle_measure",NULL )
-,		SchemaEntry("plane_or_planar_box",NULL )
-,		SchemaEntry("point_and_vector_member",NULL )
-,		SchemaEntry("point_and_vector_members",NULL )
-,		SchemaEntry("point_path_members",NULL )
-,		SchemaEntry("positive_integer",NULL )
-,		SchemaEntry("positive_length_measure",NULL )
-,		SchemaEntry("positive_plane_angle_measure",NULL )
-,		SchemaEntry("positive_ratio_measure",NULL )
-,		SchemaEntry("power_measure",NULL )
-,		SchemaEntry("preferred_surface_curve_representation",NULL )
-,		SchemaEntry("presentable_text",NULL )
-,		SchemaEntry("presentation_representation_select",NULL )
-,		SchemaEntry("presentation_size_assignment_select",NULL )
-,		SchemaEntry("presentation_style_select",NULL )
-//,		SchemaEntry("presented_item_select",NULL )
-,		SchemaEntry("pressure_measure",NULL )
-,		SchemaEntry("product_definition_or_assembly_relationship",NULL )
-,		SchemaEntry("product_definition_or_breakdown_element_usage",NULL )
-,		SchemaEntry("product_definition_or_product_definition_relationship",NULL )
-,		SchemaEntry("product_or_formation_or_definition",NULL )
-,		SchemaEntry("project_item",NULL )
-,		SchemaEntry("radioactivity_measure",NULL )
-,		SchemaEntry("ratio_measure",NULL )
-,		SchemaEntry("rendering_properties_select",NULL )
-,		SchemaEntry("represented_definition",NULL )
-,		SchemaEntry("requirement_assigned_item",NULL )
-,		SchemaEntry("requirement_satisfaction_item",NULL )
-,		SchemaEntry("requirement_source_item",NULL )
-,		SchemaEntry("resistance_measure",NULL )
-,		SchemaEntry("reversible_topology",NULL )
-,		SchemaEntry("reversible_topology_item",NULL )
-,		SchemaEntry("role_select",NULL )
-,		SchemaEntry("rule_superseded_item",NULL )
-,		SchemaEntry("second_in_minute",NULL )
-,		SchemaEntry("security_classification_item",NULL )
-,		SchemaEntry("set_of_reversible_topology_item",NULL )
-,		SchemaEntry("set_representation_item",NULL )
-,		SchemaEntry("shading_curve_method",NULL )
-,		SchemaEntry("shading_surface_method",NULL )
-,		SchemaEntry("shape_definition",NULL )
-,		SchemaEntry("shell",NULL )
-,		SchemaEntry("si_prefix",NULL )
-,		SchemaEntry("si_unit_name",NULL )
-,		SchemaEntry("size_select",NULL )
-,		SchemaEntry("sketch_basis_select",NULL )
-,		SchemaEntry("solid_angle_measure",NULL )
-,		SchemaEntry("source",NULL )
-,		SchemaEntry("source_item",NULL )
-,		SchemaEntry("start_request_item",NULL )
-,		SchemaEntry("string_representation_item_select",NULL )
-,		SchemaEntry("style_context_select",NULL )
-,		SchemaEntry("surface_side",NULL )
-,		SchemaEntry("surface_side_style_select",NULL )
-,		SchemaEntry("surface_style_element_select",NULL )
-,		SchemaEntry("symbol_style_select",NULL )
-,		SchemaEntry("text",NULL )
-,		SchemaEntry("text_alignment",NULL )
-,		SchemaEntry("text_delineation",NULL )
-,		SchemaEntry("text_or_character",NULL )
-,		SchemaEntry("text_path",NULL )
-,		SchemaEntry("text_string_representation_item",NULL )
-,		SchemaEntry("thermodynamic_temperature_measure",NULL )
-,		SchemaEntry("time_interval_item",NULL )
-,		SchemaEntry("time_measure",NULL )
-,		SchemaEntry("tolerance_method_definition",NULL )
-,		SchemaEntry("transformation",NULL )
-,		SchemaEntry("transition_code",NULL )
-,		SchemaEntry("trim_condition_select",NULL )
-,		SchemaEntry("trim_intent",NULL )
-,		SchemaEntry("trimming_preference",NULL )
-,		SchemaEntry("trimming_select",NULL )
-,		SchemaEntry("u_direction_count",NULL )
-,		SchemaEntry("unit",NULL )
-,		SchemaEntry("v_direction_count",NULL )
-,		SchemaEntry("value_qualifier",NULL )
-,		SchemaEntry("vector_or_direction",NULL )
-,		SchemaEntry("velocity_measure",NULL )
-,		SchemaEntry("volume_measure",NULL )
-,		SchemaEntry("week_in_year_number",NULL )
-,		SchemaEntry("work_item",NULL )
-,		SchemaEntry("year_number",NULL )
-,		SchemaEntry("measure_with_unit",&STEP::ObjectHelper<measure_with_unit,2>::Construct )
-,		SchemaEntry("absorbed_dose_measure_with_unit",&STEP::ObjectHelper<absorbed_dose_measure_with_unit,0>::Construct )
-,		SchemaEntry("derived_unit",&STEP::ObjectHelper<derived_unit,1>::Construct )
-,		SchemaEntry("absorbed_dose_unit",&STEP::ObjectHelper<absorbed_dose_unit,0>::Construct )
-,		SchemaEntry("abstract_variable",&STEP::ObjectHelper<abstract_variable,0>::Construct )
-,		SchemaEntry("acceleration_measure_with_unit",&STEP::ObjectHelper<acceleration_measure_with_unit,0>::Construct )
-,		SchemaEntry("acceleration_unit",&STEP::ObjectHelper<acceleration_unit,0>::Construct )
-,		SchemaEntry("action",&STEP::ObjectHelper<action,3>::Construct )
-,		SchemaEntry("action_assignment",&STEP::ObjectHelper<action_assignment,1>::Construct )
-,		SchemaEntry("action_directive",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_method",&STEP::ObjectHelper<action_method,4>::Construct )
-,		SchemaEntry("action_method_assignment",&STEP::ObjectHelper<action_method_assignment,2>::Construct )
-,		SchemaEntry("action_method_relationship",&STEP::ObjectHelper<action_method_relationship,4>::Construct )
-,		SchemaEntry("action_method_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_property",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_property_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_request_assignment",&STEP::ObjectHelper<action_request_assignment,1>::Construct )
-,		SchemaEntry("action_request_solution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_request_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("action_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("address",&STEP::ObjectHelper<address,12>::Construct )
-,		SchemaEntry("representation",&STEP::ObjectHelper<representation,3>::Construct )
-,		SchemaEntry("shape_representation",&STEP::ObjectHelper<shape_representation,0>::Construct )
-,		SchemaEntry("advanced_brep_shape_representation",&STEP::ObjectHelper<advanced_brep_shape_representation,0>::Construct )
-,		SchemaEntry("face_surface",&STEP::ObjectHelper<face_surface,2>::Construct )
-,		SchemaEntry("advanced_face",&STEP::ObjectHelper<advanced_face,0>::Construct )
-,		SchemaEntry("alternate_product_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("amount_of_substance_measure_with_unit",&STEP::ObjectHelper<amount_of_substance_measure_with_unit,0>::Construct )
-,		SchemaEntry("named_unit",&STEP::ObjectHelper<named_unit,1>::Construct )
-,		SchemaEntry("amount_of_substance_unit",&STEP::ObjectHelper<amount_of_substance_unit,0>::Construct )
-,		SchemaEntry("angle_direction_reference",&STEP::ObjectHelper<angle_direction_reference,0>::Construct )
-,		SchemaEntry("representation_item",&STEP::ObjectHelper<representation_item,1>::Construct )
-,		SchemaEntry("geometric_representation_item",&STEP::ObjectHelper<geometric_representation_item,0>::Construct )
-,		SchemaEntry("draughting_callout",&STEP::ObjectHelper<draughting_callout,1>::Construct )
-,		SchemaEntry("dimension_curve_directed_callout",&STEP::ObjectHelper<dimension_curve_directed_callout,0>::Construct )
-,		SchemaEntry("angular_dimension",&STEP::ObjectHelper<angular_dimension,0>::Construct )
-,		SchemaEntry("shape_aspect_relationship",&STEP::ObjectHelper<shape_aspect_relationship,4>::Construct )
-,		SchemaEntry("dimensional_location",&STEP::ObjectHelper<dimensional_location,0>::Construct )
-,		SchemaEntry("angular_location",&STEP::ObjectHelper<angular_location,1>::Construct )
-,		SchemaEntry("dimensional_size",&STEP::ObjectHelper<dimensional_size,2>::Construct )
-,		SchemaEntry("angular_size",&STEP::ObjectHelper<angular_size,1>::Construct )
-,		SchemaEntry("geometric_tolerance",&STEP::ObjectHelper<geometric_tolerance,4>::Construct )
-,		SchemaEntry("geometric_tolerance_with_datum_reference",&STEP::ObjectHelper<geometric_tolerance_with_datum_reference,1>::Construct )
-,		SchemaEntry("angularity_tolerance",&STEP::ObjectHelper<angularity_tolerance,0>::Construct )
-,		SchemaEntry("styled_item",&STEP::ObjectHelper<styled_item,2>::Construct )
-,		SchemaEntry("annotation_occurrence",&STEP::ObjectHelper<annotation_occurrence,0>::Construct )
-,		SchemaEntry("annotation_curve_occurrence",&STEP::ObjectHelper<annotation_curve_occurrence,0>::Construct )
-,		SchemaEntry("annotation_fill_area",&STEP::ObjectHelper<annotation_fill_area,1>::Construct )
-,		SchemaEntry("annotation_fill_area_occurrence",&STEP::ObjectHelper<annotation_fill_area_occurrence,1>::Construct )
-,		SchemaEntry("annotation_occurrence_relationship",&STEP::ObjectHelper<annotation_occurrence_relationship,4>::Construct )
-,		SchemaEntry("annotation_occurrence_associativity",&STEP::ObjectHelper<annotation_occurrence_associativity,0>::Construct )
-,		SchemaEntry("annotation_plane",&STEP::ObjectHelper<annotation_plane,1>::Construct )
-,		SchemaEntry("annotation_symbol_occurrence",&STEP::ObjectHelper<annotation_symbol_occurrence,0>::Construct )
-,		SchemaEntry("annotation_subfigure_occurrence",&STEP::ObjectHelper<annotation_subfigure_occurrence,0>::Construct )
-,		SchemaEntry("mapped_item",&STEP::ObjectHelper<mapped_item,2>::Construct )
-,		SchemaEntry("annotation_symbol",&STEP::ObjectHelper<annotation_symbol,0>::Construct )
-,		SchemaEntry("annotation_text",&STEP::ObjectHelper<annotation_text,0>::Construct )
-,		SchemaEntry("annotation_text_character",&STEP::ObjectHelper<annotation_text_character,1>::Construct )
-,		SchemaEntry("annotation_text_occurrence",&STEP::ObjectHelper<annotation_text_occurrence,0>::Construct )
-,		SchemaEntry("shape_aspect",&STEP::ObjectHelper<shape_aspect,4>::Construct )
-,		SchemaEntry("derived_shape_aspect",&STEP::ObjectHelper<derived_shape_aspect,0>::Construct )
-,		SchemaEntry("apex",&STEP::ObjectHelper<apex,0>::Construct )
-,		SchemaEntry("application_context",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("application_context_element",&STEP::ObjectHelper<application_context_element,2>::Construct )
-,		SchemaEntry("application_protocol_definition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("applied_action_assignment",&STEP::ObjectHelper<applied_action_assignment,1>::Construct )
-,		SchemaEntry("applied_action_method_assignment",&STEP::ObjectHelper<applied_action_method_assignment,1>::Construct )
-,		SchemaEntry("applied_action_request_assignment",&STEP::ObjectHelper<applied_action_request_assignment,1>::Construct )
-,		SchemaEntry("approval_assignment",&STEP::ObjectHelper<approval_assignment,1>::Construct )
-,		SchemaEntry("applied_approval_assignment",&STEP::ObjectHelper<applied_approval_assignment,1>::Construct )
-,		SchemaEntry("attribute_classification_assignment",&STEP::ObjectHelper<attribute_classification_assignment,3>::Construct )
-,		SchemaEntry("applied_attribute_classification_assignment",&STEP::ObjectHelper<applied_attribute_classification_assignment,1>::Construct )
-,		SchemaEntry("certification_assignment",&STEP::ObjectHelper<certification_assignment,1>::Construct )
-,		SchemaEntry("applied_certification_assignment",&STEP::ObjectHelper<applied_certification_assignment,1>::Construct )
-,		SchemaEntry("classification_assignment",&STEP::ObjectHelper<classification_assignment,2>::Construct )
-,		SchemaEntry("applied_classification_assignment",&STEP::ObjectHelper<applied_classification_assignment,1>::Construct )
-,		SchemaEntry("contract_assignment",&STEP::ObjectHelper<contract_assignment,1>::Construct )
-,		SchemaEntry("applied_contract_assignment",&STEP::ObjectHelper<applied_contract_assignment,1>::Construct )
-,		SchemaEntry("date_and_time_assignment",&STEP::ObjectHelper<date_and_time_assignment,2>::Construct )
-,		SchemaEntry("applied_date_and_time_assignment",&STEP::ObjectHelper<applied_date_and_time_assignment,1>::Construct )
-,		SchemaEntry("date_assignment",&STEP::ObjectHelper<date_assignment,2>::Construct )
-,		SchemaEntry("applied_date_assignment",&STEP::ObjectHelper<applied_date_assignment,1>::Construct )
-,		SchemaEntry("document_reference",&STEP::ObjectHelper<document_reference,2>::Construct )
-,		SchemaEntry("applied_document_reference",&STEP::ObjectHelper<applied_document_reference,1>::Construct )
-,		SchemaEntry("document_usage_constraint_assignment",&STEP::ObjectHelper<document_usage_constraint_assignment,2>::Construct )
-,		SchemaEntry("applied_document_usage_constraint_assignment",&STEP::ObjectHelper<applied_document_usage_constraint_assignment,1>::Construct )
-,		SchemaEntry("effectivity_assignment",&STEP::ObjectHelper<effectivity_assignment,1>::Construct )
-,		SchemaEntry("applied_effectivity_assignment",&STEP::ObjectHelper<applied_effectivity_assignment,1>::Construct )
-,		SchemaEntry("event_occurrence_assignment",&STEP::ObjectHelper<event_occurrence_assignment,2>::Construct )
-,		SchemaEntry("applied_event_occurrence_assignment",&STEP::ObjectHelper<applied_event_occurrence_assignment,1>::Construct )
-,		SchemaEntry("identification_assignment",&STEP::ObjectHelper<identification_assignment,2>::Construct )
-,		SchemaEntry("external_identification_assignment",&STEP::ObjectHelper<external_identification_assignment,1>::Construct )
-,		SchemaEntry("applied_external_identification_assignment",&STEP::ObjectHelper<applied_external_identification_assignment,1>::Construct )
-,		SchemaEntry("group_assignment",&STEP::ObjectHelper<group_assignment,1>::Construct )
-,		SchemaEntry("applied_group_assignment",&STEP::ObjectHelper<applied_group_assignment,1>::Construct )
-,		SchemaEntry("applied_identification_assignment",&STEP::ObjectHelper<applied_identification_assignment,1>::Construct )
-,		SchemaEntry("name_assignment",&STEP::ObjectHelper<name_assignment,1>::Construct )
-,		SchemaEntry("applied_name_assignment",&STEP::ObjectHelper<applied_name_assignment,1>::Construct )
-,		SchemaEntry("organization_assignment",&STEP::ObjectHelper<organization_assignment,2>::Construct )
-,		SchemaEntry("applied_organization_assignment",&STEP::ObjectHelper<applied_organization_assignment,1>::Construct )
-,		SchemaEntry("organizational_project_assignment",&STEP::ObjectHelper<organizational_project_assignment,2>::Construct )
-,		SchemaEntry("applied_organizational_project_assignment",&STEP::ObjectHelper<applied_organizational_project_assignment,1>::Construct )
-,		SchemaEntry("person_and_organization_assignment",&STEP::ObjectHelper<person_and_organization_assignment,2>::Construct )
-,		SchemaEntry("applied_person_and_organization_assignment",&STEP::ObjectHelper<applied_person_and_organization_assignment,1>::Construct )
-//,		SchemaEntry("presented_item",&STEP::ObjectHelper<presented_item,0>::Construct )
-,		SchemaEntry("applied_presented_item",&STEP::ObjectHelper<applied_presented_item,1>::Construct )
-,		SchemaEntry("security_classification_assignment",&STEP::ObjectHelper<security_classification_assignment,1>::Construct )
-,		SchemaEntry("applied_security_classification_assignment",&STEP::ObjectHelper<applied_security_classification_assignment,1>::Construct )
-,		SchemaEntry("time_interval_assignment",&STEP::ObjectHelper<time_interval_assignment,2>::Construct )
-,		SchemaEntry("applied_time_interval_assignment",&STEP::ObjectHelper<applied_time_interval_assignment,1>::Construct )
-,		SchemaEntry("applied_usage_right",&STEP::ObjectHelper<applied_usage_right,0>::Construct )
-,		SchemaEntry("approval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_date_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_person_organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("approval_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("area_in_set",&STEP::ObjectHelper<area_in_set,2>::Construct )
-,		SchemaEntry("area_measure_with_unit",&STEP::ObjectHelper<area_measure_with_unit,0>::Construct )
-,		SchemaEntry("area_unit",&STEP::ObjectHelper<area_unit,0>::Construct )
-,		SchemaEntry("product_definition_relationship",&STEP::ObjectHelper<product_definition_relationship,5>::Construct )
-,		SchemaEntry("product_definition_usage",&STEP::ObjectHelper<product_definition_usage,0>::Construct )
-,		SchemaEntry("assembly_component_usage",&STEP::ObjectHelper<assembly_component_usage,1>::Construct )
-,		SchemaEntry("assembly_component_usage_substitute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("assigned_requirement",&STEP::ObjectHelper<assigned_requirement,1>::Construct )
-,		SchemaEntry("compound_representation_item",&STEP::ObjectHelper<compound_representation_item,1>::Construct )
-,		SchemaEntry("atomic_formula",&STEP::ObjectHelper<atomic_formula,0>::Construct )
-,		SchemaEntry("attribute_assertion",&STEP::ObjectHelper<attribute_assertion,0>::Construct )
-,		SchemaEntry("attribute_language_assignment",&STEP::ObjectHelper<attribute_language_assignment,1>::Construct )
-,		SchemaEntry("attribute_value_assignment",&STEP::ObjectHelper<attribute_value_assignment,3>::Construct )
-,		SchemaEntry("attribute_value_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("auxiliary_geometric_representation_item",&STEP::ObjectHelper<auxiliary_geometric_representation_item,0>::Construct )
-,		SchemaEntry("placement",&STEP::ObjectHelper<placement,1>::Construct )
-,		SchemaEntry("axis1_placement",&STEP::ObjectHelper<axis1_placement,1>::Construct )
-,		SchemaEntry("axis2_placement_2d",&STEP::ObjectHelper<axis2_placement_2d,1>::Construct )
-,		SchemaEntry("axis2_placement_3d",&STEP::ObjectHelper<axis2_placement_3d,2>::Construct )
-,		SchemaEntry("curve",&STEP::ObjectHelper<curve,0>::Construct )
-,		SchemaEntry("bounded_curve",&STEP::ObjectHelper<bounded_curve,0>::Construct )
-,		SchemaEntry("b_spline_curve",&STEP::ObjectHelper<b_spline_curve,5>::Construct )
-,		SchemaEntry("b_spline_curve_with_knots",&STEP::ObjectHelper<b_spline_curve_with_knots,3>::Construct )
-,		SchemaEntry("surface",&STEP::ObjectHelper<surface,0>::Construct )
-,		SchemaEntry("bounded_surface",&STEP::ObjectHelper<bounded_surface,0>::Construct )
-,		SchemaEntry("b_spline_surface",&STEP::ObjectHelper<b_spline_surface,6>::Construct )
-,		SchemaEntry("b_spline_surface_with_knots",&STEP::ObjectHelper<b_spline_surface_with_knots,5>::Construct )
-,		SchemaEntry("product_definition",&STEP::ObjectHelper<product_definition,4>::Construct )
-,		SchemaEntry("rule_software_definition",&STEP::ObjectHelper<rule_software_definition,0>::Construct )
-,		SchemaEntry("rule_definition",&STEP::ObjectHelper<rule_definition,0>::Construct )
-,		SchemaEntry("back_chaining_rule",&STEP::ObjectHelper<back_chaining_rule,0>::Construct )
-,		SchemaEntry("back_chaining_rule_body",&STEP::ObjectHelper<back_chaining_rule_body,0>::Construct )
-,		SchemaEntry("colour",&STEP::ObjectHelper<colour,0>::Construct )
-,		SchemaEntry("background_colour",&STEP::ObjectHelper<background_colour,1>::Construct )
-,		SchemaEntry("beveled_sheet_representation",&STEP::ObjectHelper<beveled_sheet_representation,0>::Construct )
-,		SchemaEntry("bezier_curve",&STEP::ObjectHelper<bezier_curve,0>::Construct )
-,		SchemaEntry("bezier_surface",&STEP::ObjectHelper<bezier_surface,0>::Construct )
-,		SchemaEntry("generic_expression",&STEP::ObjectHelper<generic_expression,0>::Construct )
-,		SchemaEntry("binary_generic_expression",&STEP::ObjectHelper<binary_generic_expression,1>::Construct )
-,		SchemaEntry("binary_numeric_expression",&STEP::ObjectHelper<binary_numeric_expression,0>::Construct )
-,		SchemaEntry("binary_representation_item",&STEP::ObjectHelper<binary_representation_item,1>::Construct )
-,		SchemaEntry("block",&STEP::ObjectHelper<block,4>::Construct )
-,		SchemaEntry("expression",&STEP::ObjectHelper<expression,0>::Construct )
-,		SchemaEntry("boolean_expression",&STEP::ObjectHelper<boolean_expression,0>::Construct )
-,		SchemaEntry("boolean_literal",&STEP::ObjectHelper<boolean_literal,1>::Construct )
-,		SchemaEntry("boolean_representation_item",&STEP::ObjectHelper<boolean_representation_item,0>::Construct )
-,		SchemaEntry("boolean_result",&STEP::ObjectHelper<boolean_result,3>::Construct )
-,		SchemaEntry("composite_curve",&STEP::ObjectHelper<composite_curve,2>::Construct )
-,		SchemaEntry("composite_curve_on_surface",&STEP::ObjectHelper<composite_curve_on_surface,0>::Construct )
-,		SchemaEntry("boundary_curve",&STEP::ObjectHelper<boundary_curve,0>::Construct )
-,		SchemaEntry("bounded_pcurve",&STEP::ObjectHelper<bounded_pcurve,0>::Construct )
-,		SchemaEntry("bounded_surface_curve",&STEP::ObjectHelper<bounded_surface_curve,0>::Construct )
-,		SchemaEntry("founded_item",&STEP::ObjectHelper<founded_item,0>::Construct )
-,		SchemaEntry("box_domain",&STEP::ObjectHelper<box_domain,4>::Construct )
-,		SchemaEntry("half_space_solid",&STEP::ObjectHelper<half_space_solid,2>::Construct )
-,		SchemaEntry("boxed_half_space",&STEP::ObjectHelper<boxed_half_space,1>::Construct )
-,		SchemaEntry("breakdown_context",&STEP::ObjectHelper<breakdown_context,0>::Construct )
-,		SchemaEntry("breakdown_element_group_assignment",&STEP::ObjectHelper<breakdown_element_group_assignment,1>::Construct )
-,		SchemaEntry("breakdown_element_realization",&STEP::ObjectHelper<breakdown_element_realization,0>::Construct )
-,		SchemaEntry("breakdown_element_usage",&STEP::ObjectHelper<breakdown_element_usage,0>::Construct )
-,		SchemaEntry("breakdown_of",&STEP::ObjectHelper<breakdown_of,0>::Construct )
-,		SchemaEntry("solid_model",&STEP::ObjectHelper<solid_model,0>::Construct )
-,		SchemaEntry("manifold_solid_brep",&STEP::ObjectHelper<manifold_solid_brep,1>::Construct )
-,		SchemaEntry("brep_with_voids",&STEP::ObjectHelper<brep_with_voids,1>::Construct )
-,		SchemaEntry("bytes_representation_item",&STEP::ObjectHelper<bytes_representation_item,0>::Construct )
-,		SchemaEntry("date",&STEP::ObjectHelper<date,1>::Construct )
-,		SchemaEntry("calendar_date",&STEP::ObjectHelper<calendar_date,2>::Construct )
-,		SchemaEntry("camera_image",&STEP::ObjectHelper<camera_image,0>::Construct )
-,		SchemaEntry("camera_image_3d_with_scale",&STEP::ObjectHelper<camera_image_3d_with_scale,0>::Construct )
-,		SchemaEntry("camera_model",&STEP::ObjectHelper<camera_model,0>::Construct )
-,		SchemaEntry("camera_model_d3",&STEP::ObjectHelper<camera_model_d3,2>::Construct )
-,		SchemaEntry("camera_model_d3_multi_clipping",&STEP::ObjectHelper<camera_model_d3_multi_clipping,1>::Construct )
-,		SchemaEntry("camera_model_d3_multi_clipping_intersection",&STEP::ObjectHelper<camera_model_d3_multi_clipping_intersection,1>::Construct )
-,		SchemaEntry("camera_model_d3_multi_clipping_union",&STEP::ObjectHelper<camera_model_d3_multi_clipping_union,1>::Construct )
-,		SchemaEntry("camera_model_d3_with_hlhsr",&STEP::ObjectHelper<camera_model_d3_with_hlhsr,1>::Construct )
-,		SchemaEntry("camera_model_with_light_sources",&STEP::ObjectHelper<camera_model_with_light_sources,1>::Construct )
-,		SchemaEntry("representation_map",&STEP::ObjectHelper<representation_map,2>::Construct )
-,		SchemaEntry("camera_usage",&STEP::ObjectHelper<camera_usage,0>::Construct )
-,		SchemaEntry("capacitance_measure_with_unit",&STEP::ObjectHelper<capacitance_measure_with_unit,0>::Construct )
-,		SchemaEntry("capacitance_unit",&STEP::ObjectHelper<capacitance_unit,0>::Construct )
-,		SchemaEntry("point",&STEP::ObjectHelper<point,0>::Construct )
-,		SchemaEntry("cartesian_point",&STEP::ObjectHelper<cartesian_point,1>::Construct )
-,		SchemaEntry("cartesian_transformation_operator",&STEP::ObjectHelper<cartesian_transformation_operator,4>::Construct )
-,		SchemaEntry("cartesian_transformation_operator_2d",&STEP::ObjectHelper<cartesian_transformation_operator_2d,0>::Construct )
-,		SchemaEntry("cartesian_transformation_operator_3d",&STEP::ObjectHelper<cartesian_transformation_operator_3d,1>::Construct )
-,		SchemaEntry("cc_design_approval",&STEP::ObjectHelper<cc_design_approval,1>::Construct )
-,		SchemaEntry("cc_design_certification",&STEP::ObjectHelper<cc_design_certification,1>::Construct )
-,		SchemaEntry("cc_design_contract",&STEP::ObjectHelper<cc_design_contract,1>::Construct )
-,		SchemaEntry("cc_design_date_and_time_assignment",&STEP::ObjectHelper<cc_design_date_and_time_assignment,1>::Construct )
-,		SchemaEntry("cc_design_person_and_organization_assignment",&STEP::ObjectHelper<cc_design_person_and_organization_assignment,1>::Construct )
-,		SchemaEntry("cc_design_security_classification",&STEP::ObjectHelper<cc_design_security_classification,1>::Construct )
-,		SchemaEntry("cc_design_specification_reference",&STEP::ObjectHelper<cc_design_specification_reference,1>::Construct )
-,		SchemaEntry("celsius_temperature_measure_with_unit",&STEP::ObjectHelper<celsius_temperature_measure_with_unit,0>::Construct )
-,		SchemaEntry("centre_of_symmetry",&STEP::ObjectHelper<centre_of_symmetry,0>::Construct )
-,		SchemaEntry("certification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("certification_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("change",&STEP::ObjectHelper<change,1>::Construct )
-,		SchemaEntry("change_request",&STEP::ObjectHelper<change_request,1>::Construct )
-,		SchemaEntry("character_glyph_font_usage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("character_glyph_style_outline",&STEP::ObjectHelper<character_glyph_style_outline,1>::Construct )
-,		SchemaEntry("character_glyph_style_stroke",&STEP::ObjectHelper<character_glyph_style_stroke,1>::Construct )
-,		SchemaEntry("symbol_representation",&STEP::ObjectHelper<symbol_representation,0>::Construct )
-,		SchemaEntry("generic_character_glyph_symbol",&STEP::ObjectHelper<generic_character_glyph_symbol,0>::Construct )
-,		SchemaEntry("character_glyph_symbol",&STEP::ObjectHelper<character_glyph_symbol,2>::Construct )
-,		SchemaEntry("character_glyph_symbol_outline",&STEP::ObjectHelper<character_glyph_symbol_outline,1>::Construct )
-,		SchemaEntry("character_glyph_symbol_stroke",&STEP::ObjectHelper<character_glyph_symbol_stroke,1>::Construct )
-,		SchemaEntry("general_property",&STEP::ObjectHelper<general_property,3>::Construct )
-,		SchemaEntry("characteristic_data_column_header",&STEP::ObjectHelper<characteristic_data_column_header,0>::Construct )
-,		SchemaEntry("general_property_relationship",&STEP::ObjectHelper<general_property_relationship,4>::Construct )
-,		SchemaEntry("characteristic_data_column_header_link",&STEP::ObjectHelper<characteristic_data_column_header_link,0>::Construct )
-,		SchemaEntry("characteristic_data_table_header",&STEP::ObjectHelper<characteristic_data_table_header,0>::Construct )
-,		SchemaEntry("characteristic_data_table_header_decomposition",&STEP::ObjectHelper<characteristic_data_table_header_decomposition,0>::Construct )
-,		SchemaEntry("group",&STEP::ObjectHelper<group,2>::Construct )
-,		SchemaEntry("characteristic_type",&STEP::ObjectHelper<characteristic_type,0>::Construct )
-,		SchemaEntry("characterized_class",&STEP::ObjectHelper<characterized_class,0>::Construct )
-,		SchemaEntry("characterized_object",&STEP::ObjectHelper<characterized_object,2>::Construct )
-,		SchemaEntry("conic",&STEP::ObjectHelper<conic,1>::Construct )
-,		SchemaEntry("circle",&STEP::ObjectHelper<circle,1>::Construct )
-,		SchemaEntry("circular_runout_tolerance",&STEP::ObjectHelper<circular_runout_tolerance,0>::Construct )
-,		SchemaEntry("class_t",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("class_by_extension",&STEP::ObjectHelper<class_by_extension,0>::Construct )
-,		SchemaEntry("class_by_intension",&STEP::ObjectHelper<class_by_intension,0>::Construct )
-,		SchemaEntry("class_system",&STEP::ObjectHelper<class_system,0>::Construct )
-,		SchemaEntry("effectivity_context_assignment",&STEP::ObjectHelper<effectivity_context_assignment,2>::Construct )
-,		SchemaEntry("class_usage_effectivity_context_assignment",&STEP::ObjectHelper<class_usage_effectivity_context_assignment,1>::Construct )
-,		SchemaEntry("classification_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("topological_representation_item",&STEP::ObjectHelper<topological_representation_item,0>::Construct )
-,		SchemaEntry("connected_face_set",&STEP::ObjectHelper<connected_face_set,1>::Construct )
-,		SchemaEntry("closed_shell",&STEP::ObjectHelper<closed_shell,0>::Construct )
-,		SchemaEntry("coaxiality_tolerance",&STEP::ObjectHelper<coaxiality_tolerance,0>::Construct )
-,		SchemaEntry("colour_specification",&STEP::ObjectHelper<colour_specification,1>::Construct )
-,		SchemaEntry("colour_rgb",&STEP::ObjectHelper<colour_rgb,3>::Construct )
-,		SchemaEntry("common_datum",&STEP::ObjectHelper<common_datum,0>::Construct )
-,		SchemaEntry("comparison_expression",&STEP::ObjectHelper<comparison_expression,0>::Construct )
-,		SchemaEntry("complex_clause",&STEP::ObjectHelper<complex_clause,0>::Construct )
-,		SchemaEntry("complex_conjunctive_clause",&STEP::ObjectHelper<complex_conjunctive_clause,0>::Construct )
-,		SchemaEntry("complex_disjunctive_clause",&STEP::ObjectHelper<complex_disjunctive_clause,0>::Construct )
-,		SchemaEntry("modified_solid",&STEP::ObjectHelper<modified_solid,2>::Construct )
-,		SchemaEntry("shelled_solid",&STEP::ObjectHelper<shelled_solid,2>::Construct )
-,		SchemaEntry("complex_shelled_solid",&STEP::ObjectHelper<complex_shelled_solid,1>::Construct )
-,		SchemaEntry("composite_assembly_definition",&STEP::ObjectHelper<composite_assembly_definition,0>::Construct )
-,		SchemaEntry("composite_assembly_sequence_definition",&STEP::ObjectHelper<composite_assembly_sequence_definition,0>::Construct )
-,		SchemaEntry("laminate_table",&STEP::ObjectHelper<laminate_table,0>::Construct )
-,		SchemaEntry("part_laminate_table",&STEP::ObjectHelper<part_laminate_table,0>::Construct )
-,		SchemaEntry("composite_assembly_table",&STEP::ObjectHelper<composite_assembly_table,0>::Construct )
-,		SchemaEntry("composite_curve_segment",&STEP::ObjectHelper<composite_curve_segment,3>::Construct )
-,		SchemaEntry("material_designation",&STEP::ObjectHelper<material_designation,2>::Construct )
-,		SchemaEntry("composite_material_designation",&STEP::ObjectHelper<composite_material_designation,0>::Construct )
-,		SchemaEntry("composite_shape_aspect",&STEP::ObjectHelper<composite_shape_aspect,0>::Construct )
-,		SchemaEntry("composite_sheet_representation",&STEP::ObjectHelper<composite_sheet_representation,0>::Construct )
-,		SchemaEntry("composite_text",&STEP::ObjectHelper<composite_text,1>::Construct )
-,		SchemaEntry("composite_text_with_associated_curves",&STEP::ObjectHelper<composite_text_with_associated_curves,1>::Construct )
-,		SchemaEntry("composite_text_with_blanking_box",&STEP::ObjectHelper<composite_text_with_blanking_box,1>::Construct )
-,		SchemaEntry("composite_text_with_delineation",&STEP::ObjectHelper<composite_text_with_delineation,1>::Construct )
-,		SchemaEntry("composite_text_with_extent",&STEP::ObjectHelper<composite_text_with_extent,1>::Construct )
-,		SchemaEntry("compound_shape_representation",&STEP::ObjectHelper<compound_shape_representation,0>::Construct )
-,		SchemaEntry("concentricity_tolerance",&STEP::ObjectHelper<concentricity_tolerance,0>::Construct )
-,		SchemaEntry("concept_feature_operator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("concept_feature_relationship",&STEP::ObjectHelper<concept_feature_relationship,4>::Construct )
-,		SchemaEntry("concept_feature_relationship_with_condition",&STEP::ObjectHelper<concept_feature_relationship_with_condition,1>::Construct )
-,		SchemaEntry("product_concept_feature",&STEP::ObjectHelper<product_concept_feature,3>::Construct )
-,		SchemaEntry("conditional_concept_feature",&STEP::ObjectHelper<conditional_concept_feature,1>::Construct )
-,		SchemaEntry("conductance_measure_with_unit",&STEP::ObjectHelper<conductance_measure_with_unit,0>::Construct )
-,		SchemaEntry("conductance_unit",&STEP::ObjectHelper<conductance_unit,0>::Construct )
-,		SchemaEntry("configuration_item",&STEP::ObjectHelper<configuration_item,5>::Construct )
-,		SchemaEntry("configurable_item",&STEP::ObjectHelper<configurable_item,1>::Construct )
-,		SchemaEntry("configuration_design",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("effectivity",&STEP::ObjectHelper<effectivity,1>::Construct )
-,		SchemaEntry("product_definition_effectivity",&STEP::ObjectHelper<product_definition_effectivity,1>::Construct )
-,		SchemaEntry("configuration_effectivity",&STEP::ObjectHelper<configuration_effectivity,1>::Construct )
-,		SchemaEntry("configuration_item_relationship",&STEP::ObjectHelper<configuration_item_relationship,4>::Construct )
-,		SchemaEntry("configuration_item_hierarchical_relationship",&STEP::ObjectHelper<configuration_item_hierarchical_relationship,0>::Construct )
-,		SchemaEntry("configuration_item_revision_sequence",&STEP::ObjectHelper<configuration_item_revision_sequence,0>::Construct )
-,		SchemaEntry("configured_effectivity_assignment",&STEP::ObjectHelper<configured_effectivity_assignment,1>::Construct )
-,		SchemaEntry("configured_effectivity_context_assignment",&STEP::ObjectHelper<configured_effectivity_context_assignment,1>::Construct )
-,		SchemaEntry("conical_stepped_hole_transition",&STEP::ObjectHelper<conical_stepped_hole_transition,3>::Construct )
-,		SchemaEntry("elementary_surface",&STEP::ObjectHelper<elementary_surface,1>::Construct )
-,		SchemaEntry("conical_surface",&STEP::ObjectHelper<conical_surface,2>::Construct )
-,		SchemaEntry("connected_edge_set",&STEP::ObjectHelper<connected_edge_set,1>::Construct )
-,		SchemaEntry("connected_face_sub_set",&STEP::ObjectHelper<connected_face_sub_set,1>::Construct )
-,		SchemaEntry("constructive_geometry_representation",&STEP::ObjectHelper<constructive_geometry_representation,0>::Construct )
-,		SchemaEntry("representation_relationship",&STEP::ObjectHelper<representation_relationship,4>::Construct )
-,		SchemaEntry("constructive_geometry_representation_relationship",&STEP::ObjectHelper<constructive_geometry_representation_relationship,0>::Construct )
-,		SchemaEntry("contact_ratio_representation",&STEP::ObjectHelper<contact_ratio_representation,0>::Construct )
-,		SchemaEntry("invisibility",&STEP::ObjectHelper<invisibility,1>::Construct )
-,		SchemaEntry("context_dependent_invisibility",&STEP::ObjectHelper<context_dependent_invisibility,1>::Construct )
-,		SchemaEntry("over_riding_styled_item",&STEP::ObjectHelper<over_riding_styled_item,1>::Construct )
-,		SchemaEntry("context_dependent_over_riding_styled_item",&STEP::ObjectHelper<context_dependent_over_riding_styled_item,1>::Construct )
-,		SchemaEntry("context_dependent_shape_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("context_dependent_unit",&STEP::ObjectHelper<context_dependent_unit,1>::Construct )
-,		SchemaEntry("contract",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("contract_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("contract_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("conversion_based_unit",&STEP::ObjectHelper<conversion_based_unit,2>::Construct )
-,		SchemaEntry("coordinated_universal_time_offset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("csg_shape_representation",&STEP::ObjectHelper<csg_shape_representation,0>::Construct )
-,		SchemaEntry("csg_solid",&STEP::ObjectHelper<csg_solid,1>::Construct )
-,		SchemaEntry("currency",&STEP::ObjectHelper<currency,0>::Construct )
-,		SchemaEntry("currency_measure_with_unit",&STEP::ObjectHelper<currency_measure_with_unit,0>::Construct )
-,		SchemaEntry("curve_bounded_surface",&STEP::ObjectHelper<curve_bounded_surface,3>::Construct )
-,		SchemaEntry("curve_dimension",&STEP::ObjectHelper<curve_dimension,0>::Construct )
-,		SchemaEntry("curve_replica",&STEP::ObjectHelper<curve_replica,2>::Construct )
-,		SchemaEntry("curve_style",&STEP::ObjectHelper<curve_style,4>::Construct )
-,		SchemaEntry("curve_style_font",&STEP::ObjectHelper<curve_style_font,2>::Construct )
-,		SchemaEntry("curve_style_font_and_scaling",&STEP::ObjectHelper<curve_style_font_and_scaling,3>::Construct )
-,		SchemaEntry("curve_style_font_pattern",&STEP::ObjectHelper<curve_style_font_pattern,2>::Construct )
-,		SchemaEntry("curve_style_rendering",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("curve_swept_solid_shape_representation",&STEP::ObjectHelper<curve_swept_solid_shape_representation,0>::Construct )
-,		SchemaEntry("cylindrical_surface",&STEP::ObjectHelper<cylindrical_surface,1>::Construct )
-,		SchemaEntry("cylindricity_tolerance",&STEP::ObjectHelper<cylindricity_tolerance,0>::Construct )
-,		SchemaEntry("data_environment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("date_and_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("date_representation_item",&STEP::ObjectHelper<date_representation_item,0>::Construct )
-,		SchemaEntry("date_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("date_time_representation_item",&STEP::ObjectHelper<date_time_representation_item,0>::Construct )
-,		SchemaEntry("date_time_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dated_effectivity",&STEP::ObjectHelper<dated_effectivity,2>::Construct )
-,		SchemaEntry("datum",&STEP::ObjectHelper<datum,1>::Construct )
-,		SchemaEntry("datum_feature",&STEP::ObjectHelper<datum_feature,0>::Construct )
-,		SchemaEntry("datum_feature_callout",&STEP::ObjectHelper<datum_feature_callout,0>::Construct )
-,		SchemaEntry("datum_reference",&STEP::ObjectHelper<datum_reference,2>::Construct )
-,		SchemaEntry("datum_target",&STEP::ObjectHelper<datum_target,1>::Construct )
-,		SchemaEntry("datum_target_callout",&STEP::ObjectHelper<datum_target_callout,0>::Construct )
-,		SchemaEntry("default_tolerance_table",&STEP::ObjectHelper<default_tolerance_table,0>::Construct )
-,		SchemaEntry("default_tolerance_table_cell",&STEP::ObjectHelper<default_tolerance_table_cell,0>::Construct )
-,		SchemaEntry("defined_symbol",&STEP::ObjectHelper<defined_symbol,2>::Construct )
-,		SchemaEntry("definitional_representation",&STEP::ObjectHelper<definitional_representation,0>::Construct )
-,		SchemaEntry("definitional_representation_relationship",&STEP::ObjectHelper<definitional_representation_relationship,0>::Construct )
-,		SchemaEntry("definitional_representation_relationship_with_same_context",&STEP::ObjectHelper<definitional_representation_relationship_with_same_context,0>::Construct )
-,		SchemaEntry("degenerate_pcurve",&STEP::ObjectHelper<degenerate_pcurve,2>::Construct )
-,		SchemaEntry("toroidal_surface",&STEP::ObjectHelper<toroidal_surface,2>::Construct )
-,		SchemaEntry("degenerate_toroidal_surface",&STEP::ObjectHelper<degenerate_toroidal_surface,1>::Construct )
-,		SchemaEntry("derived_unit_element",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("description_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("descriptive_representation_item",&STEP::ObjectHelper<descriptive_representation_item,1>::Construct )
-,		SchemaEntry("product_definition_context",&STEP::ObjectHelper<product_definition_context,1>::Construct )
-,		SchemaEntry("design_context",&STEP::ObjectHelper<design_context,0>::Construct )
-,		SchemaEntry("design_make_from_relationship",&STEP::ObjectHelper<design_make_from_relationship,0>::Construct )
-,		SchemaEntry("diameter_dimension",&STEP::ObjectHelper<diameter_dimension,0>::Construct )
-,		SchemaEntry("ratio_measure_with_unit",&STEP::ObjectHelper<ratio_measure_with_unit,0>::Construct )
-,		SchemaEntry("dielectric_constant_measure_with_unit",&STEP::ObjectHelper<dielectric_constant_measure_with_unit,0>::Construct )
-,		SchemaEntry("dimension_callout",&STEP::ObjectHelper<dimension_callout,0>::Construct )
-,		SchemaEntry("draughting_callout_relationship",&STEP::ObjectHelper<draughting_callout_relationship,4>::Construct )
-,		SchemaEntry("dimension_callout_component_relationship",&STEP::ObjectHelper<dimension_callout_component_relationship,0>::Construct )
-,		SchemaEntry("dimension_callout_relationship",&STEP::ObjectHelper<dimension_callout_relationship,0>::Construct )
-,		SchemaEntry("dimension_curve",&STEP::ObjectHelper<dimension_curve,0>::Construct )
-,		SchemaEntry("terminator_symbol",&STEP::ObjectHelper<terminator_symbol,1>::Construct )
-,		SchemaEntry("dimension_curve_terminator",&STEP::ObjectHelper<dimension_curve_terminator,1>::Construct )
-,		SchemaEntry("dimension_curve_terminator_to_projection_curve_associativity",&STEP::ObjectHelper<dimension_curve_terminator_to_projection_curve_associativity,0>::Construct )
-,		SchemaEntry("dimension_pair",&STEP::ObjectHelper<dimension_pair,0>::Construct )
-,		SchemaEntry("dimension_related_tolerance_zone_element",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dimension_text_associativity",&STEP::ObjectHelper<dimension_text_associativity,0>::Construct )
-,		SchemaEntry("dimensional_characteristic_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dimensional_exponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dimensional_location_with_path",&STEP::ObjectHelper<dimensional_location_with_path,1>::Construct )
-,		SchemaEntry("dimensional_size_with_path",&STEP::ObjectHelper<dimensional_size_with_path,1>::Construct )
-,		SchemaEntry("executed_action",&STEP::ObjectHelper<executed_action,0>::Construct )
-,		SchemaEntry("directed_action",&STEP::ObjectHelper<directed_action,1>::Construct )
-,		SchemaEntry("directed_dimensional_location",&STEP::ObjectHelper<directed_dimensional_location,0>::Construct )
-,		SchemaEntry("direction",&STEP::ObjectHelper<direction,1>::Construct )
-,		SchemaEntry("document",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_file",&STEP::ObjectHelper<document_file,0>::Construct )
-,		SchemaEntry("document_identifier",&STEP::ObjectHelper<document_identifier,0>::Construct )
-,		SchemaEntry("document_identifier_assignment",&STEP::ObjectHelper<document_identifier_assignment,1>::Construct )
-,		SchemaEntry("document_product_association",&STEP::ObjectHelper<document_product_association,4>::Construct )
-,		SchemaEntry("document_product_equivalence",&STEP::ObjectHelper<document_product_equivalence,0>::Construct )
-,		SchemaEntry("document_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_representation_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_usage_constraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("document_usage_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("dose_equivalent_measure_with_unit",&STEP::ObjectHelper<dose_equivalent_measure_with_unit,0>::Construct )
-,		SchemaEntry("dose_equivalent_unit",&STEP::ObjectHelper<dose_equivalent_unit,0>::Construct )
-,		SchemaEntry("double_offset_shelled_solid",&STEP::ObjectHelper<double_offset_shelled_solid,1>::Construct )
-,		SchemaEntry("item_defined_transformation",&STEP::ObjectHelper<item_defined_transformation,4>::Construct )
-,		SchemaEntry("transformation_with_derived_angle",&STEP::ObjectHelper<transformation_with_derived_angle,0>::Construct )
-,		SchemaEntry("draped_defined_transformation",&STEP::ObjectHelper<draped_defined_transformation,0>::Construct )
-,		SchemaEntry("draughting_annotation_occurrence",&STEP::ObjectHelper<draughting_annotation_occurrence,0>::Construct )
-,		SchemaEntry("draughting_elements",&STEP::ObjectHelper<draughting_elements,0>::Construct )
-,		SchemaEntry("draughting_model",&STEP::ObjectHelper<draughting_model,0>::Construct )
-,		SchemaEntry("item_identified_representation_usage",&STEP::ObjectHelper<item_identified_representation_usage,5>::Construct )
-,		SchemaEntry("draughting_model_item_association",&STEP::ObjectHelper<draughting_model_item_association,0>::Construct )
-,		SchemaEntry("pre_defined_colour",&STEP::ObjectHelper<pre_defined_colour,0>::Construct )
-,		SchemaEntry("draughting_pre_defined_colour",&STEP::ObjectHelper<draughting_pre_defined_colour,0>::Construct )
-,		SchemaEntry("pre_defined_item",&STEP::ObjectHelper<pre_defined_item,1>::Construct )
-,		SchemaEntry("pre_defined_curve_font",&STEP::ObjectHelper<pre_defined_curve_font,0>::Construct )
-,		SchemaEntry("draughting_pre_defined_curve_font",&STEP::ObjectHelper<draughting_pre_defined_curve_font,0>::Construct )
-,		SchemaEntry("pre_defined_text_font",&STEP::ObjectHelper<pre_defined_text_font,0>::Construct )
-,		SchemaEntry("draughting_pre_defined_text_font",&STEP::ObjectHelper<draughting_pre_defined_text_font,0>::Construct )
-,		SchemaEntry("draughting_subfigure_representation",&STEP::ObjectHelper<draughting_subfigure_representation,0>::Construct )
-,		SchemaEntry("draughting_symbol_representation",&STEP::ObjectHelper<draughting_symbol_representation,0>::Construct )
-,		SchemaEntry("text_literal",&STEP::ObjectHelper<text_literal,5>::Construct )
-,		SchemaEntry("text_literal_with_delineation",&STEP::ObjectHelper<text_literal_with_delineation,1>::Construct )
-,		SchemaEntry("draughting_text_literal_with_delineation",&STEP::ObjectHelper<draughting_text_literal_with_delineation,0>::Construct )
-,		SchemaEntry("draughting_title",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("drawing_definition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_set",&STEP::ObjectHelper<presentation_set,0>::Construct )
-,		SchemaEntry("drawing_revision",&STEP::ObjectHelper<drawing_revision,3>::Construct )
-,		SchemaEntry("drawing_revision_sequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_representation",&STEP::ObjectHelper<presentation_representation,0>::Construct )
-,		SchemaEntry("presentation_area",&STEP::ObjectHelper<presentation_area,0>::Construct )
-,		SchemaEntry("drawing_sheet_revision",&STEP::ObjectHelper<drawing_sheet_revision,1>::Construct )
-,		SchemaEntry("drawing_sheet_revision_sequence",&STEP::ObjectHelper<drawing_sheet_revision_sequence,0>::Construct )
-,		SchemaEntry("drawing_sheet_revision_usage",&STEP::ObjectHelper<drawing_sheet_revision_usage,1>::Construct )
-,		SchemaEntry("edge",&STEP::ObjectHelper<edge,2>::Construct )
-,		SchemaEntry("edge_based_wireframe_model",&STEP::ObjectHelper<edge_based_wireframe_model,1>::Construct )
-,		SchemaEntry("edge_based_wireframe_shape_representation",&STEP::ObjectHelper<edge_based_wireframe_shape_representation,0>::Construct )
-,		SchemaEntry("edge_blended_solid",&STEP::ObjectHelper<edge_blended_solid,1>::Construct )
-,		SchemaEntry("edge_curve",&STEP::ObjectHelper<edge_curve,2>::Construct )
-,		SchemaEntry("edge_loop",&STEP::ObjectHelper<edge_loop,0>::Construct )
-,		SchemaEntry("effectivity_context_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("effectivity_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("electric_charge_measure_with_unit",&STEP::ObjectHelper<electric_charge_measure_with_unit,0>::Construct )
-,		SchemaEntry("electric_charge_unit",&STEP::ObjectHelper<electric_charge_unit,0>::Construct )
-,		SchemaEntry("electric_current_measure_with_unit",&STEP::ObjectHelper<electric_current_measure_with_unit,0>::Construct )
-,		SchemaEntry("electric_current_unit",&STEP::ObjectHelper<electric_current_unit,0>::Construct )
-,		SchemaEntry("electric_potential_measure_with_unit",&STEP::ObjectHelper<electric_potential_measure_with_unit,0>::Construct )
-,		SchemaEntry("electric_potential_unit",&STEP::ObjectHelper<electric_potential_unit,0>::Construct )
-,		SchemaEntry("elementary_brep_shape_representation",&STEP::ObjectHelper<elementary_brep_shape_representation,0>::Construct )
-,		SchemaEntry("ellipse",&STEP::ObjectHelper<ellipse,2>::Construct )
-,		SchemaEntry("energy_measure_with_unit",&STEP::ObjectHelper<energy_measure_with_unit,0>::Construct )
-,		SchemaEntry("energy_unit",&STEP::ObjectHelper<energy_unit,0>::Construct )
-,		SchemaEntry("property_definition",&STEP::ObjectHelper<property_definition,3>::Construct )
-,		SchemaEntry("fact_type",&STEP::ObjectHelper<fact_type,0>::Construct )
-,		SchemaEntry("entity_assertion",&STEP::ObjectHelper<entity_assertion,0>::Construct )
-,		SchemaEntry("enum_reference_prefix",&STEP::ObjectHelper<enum_reference_prefix,0>::Construct )
-,		SchemaEntry("environment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("evaluated_characteristic",&STEP::ObjectHelper<evaluated_characteristic,0>::Construct )
-,		SchemaEntry("evaluated_degenerate_pcurve",&STEP::ObjectHelper<evaluated_degenerate_pcurve,1>::Construct )
-,		SchemaEntry("evaluation_product_definition",&STEP::ObjectHelper<evaluation_product_definition,0>::Construct )
-,		SchemaEntry("event_occurrence",&STEP::ObjectHelper<event_occurrence,3>::Construct )
-,		SchemaEntry("event_occurrence_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("event_occurrence_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_concept_feature_category",&STEP::ObjectHelper<product_concept_feature_category,0>::Construct )
-,		SchemaEntry("exclusive_product_concept_feature_category",&STEP::ObjectHelper<exclusive_product_concept_feature_category,0>::Construct )
-,		SchemaEntry("uncertainty_qualifier",&STEP::ObjectHelper<uncertainty_qualifier,2>::Construct )
-,		SchemaEntry("standard_uncertainty",&STEP::ObjectHelper<standard_uncertainty,1>::Construct )
-,		SchemaEntry("expanded_uncertainty",&STEP::ObjectHelper<expanded_uncertainty,1>::Construct )
-,		SchemaEntry("representation_item_relationship",&STEP::ObjectHelper<representation_item_relationship,4>::Construct )
-,		SchemaEntry("explicit_procedural_representation_item_relationship",&STEP::ObjectHelper<explicit_procedural_representation_item_relationship,0>::Construct )
-,		SchemaEntry("explicit_procedural_geometric_representation_item_relationship",&STEP::ObjectHelper<explicit_procedural_geometric_representation_item_relationship,0>::Construct )
-,		SchemaEntry("explicit_procedural_representation_relationship",&STEP::ObjectHelper<explicit_procedural_representation_relationship,0>::Construct )
-,		SchemaEntry("explicit_procedural_shape_representation_relationship",&STEP::ObjectHelper<explicit_procedural_shape_representation_relationship,0>::Construct )
-,		SchemaEntry("expression_conversion_based_unit",&STEP::ObjectHelper<expression_conversion_based_unit,0>::Construct )
-,		SchemaEntry("extension",&STEP::ObjectHelper<extension,0>::Construct )
-,		SchemaEntry("extent",&STEP::ObjectHelper<extent,0>::Construct )
-,		SchemaEntry("external_source",&STEP::ObjectHelper<external_source,1>::Construct )
-,		SchemaEntry("external_class_library",&STEP::ObjectHelper<external_class_library,0>::Construct )
-,		SchemaEntry("external_source_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("externally_defined_class",&STEP::ObjectHelper<externally_defined_class,0>::Construct )
-,		SchemaEntry("externally_defined_colour",&STEP::ObjectHelper<externally_defined_colour,0>::Construct )
-,		SchemaEntry("externally_defined_context_dependent_unit",&STEP::ObjectHelper<externally_defined_context_dependent_unit,0>::Construct )
-,		SchemaEntry("externally_defined_conversion_based_unit",&STEP::ObjectHelper<externally_defined_conversion_based_unit,0>::Construct )
-,		SchemaEntry("externally_defined_currency",&STEP::ObjectHelper<externally_defined_currency,0>::Construct )
-,		SchemaEntry("externally_defined_item",&STEP::ObjectHelper<externally_defined_item,2>::Construct )
-,		SchemaEntry("externally_defined_curve_font",&STEP::ObjectHelper<externally_defined_curve_font,0>::Construct )
-,		SchemaEntry("externally_defined_dimension_definition",&STEP::ObjectHelper<externally_defined_dimension_definition,0>::Construct )
-,		SchemaEntry("externally_defined_general_property",&STEP::ObjectHelper<externally_defined_general_property,0>::Construct )
-,		SchemaEntry("externally_defined_hatch_style",&STEP::ObjectHelper<externally_defined_hatch_style,0>::Construct )
-,		SchemaEntry("externally_defined_item_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("externally_defined_marker",&STEP::ObjectHelper<externally_defined_marker,0>::Construct )
-,		SchemaEntry("picture_representation_item",&STEP::ObjectHelper<picture_representation_item,0>::Construct )
-,		SchemaEntry("externally_defined_picture_representation_item",&STEP::ObjectHelper<externally_defined_picture_representation_item,0>::Construct )
-,		SchemaEntry("externally_defined_representation_item",&STEP::ObjectHelper<externally_defined_representation_item,0>::Construct )
-,		SchemaEntry("externally_defined_string",&STEP::ObjectHelper<externally_defined_string,0>::Construct )
-,		SchemaEntry("externally_defined_symbol",&STEP::ObjectHelper<externally_defined_symbol,0>::Construct )
-,		SchemaEntry("externally_defined_terminator_symbol",&STEP::ObjectHelper<externally_defined_terminator_symbol,0>::Construct )
-,		SchemaEntry("externally_defined_text_font",&STEP::ObjectHelper<externally_defined_text_font,0>::Construct )
-,		SchemaEntry("externally_defined_tile",&STEP::ObjectHelper<externally_defined_tile,0>::Construct )
-,		SchemaEntry("externally_defined_tile_style",&STEP::ObjectHelper<externally_defined_tile_style,0>::Construct )
-,		SchemaEntry("swept_area_solid",&STEP::ObjectHelper<swept_area_solid,1>::Construct )
-,		SchemaEntry("extruded_area_solid",&STEP::ObjectHelper<extruded_area_solid,2>::Construct )
-,		SchemaEntry("swept_face_solid",&STEP::ObjectHelper<swept_face_solid,1>::Construct )
-,		SchemaEntry("extruded_face_solid",&STEP::ObjectHelper<extruded_face_solid,2>::Construct )
-,		SchemaEntry("extruded_face_solid_with_trim_conditions",&STEP::ObjectHelper<extruded_face_solid_with_trim_conditions,6>::Construct )
-,		SchemaEntry("extruded_face_solid_with_draft_angle",&STEP::ObjectHelper<extruded_face_solid_with_draft_angle,1>::Construct )
-,		SchemaEntry("extruded_face_solid_with_multiple_draft_angles",&STEP::ObjectHelper<extruded_face_solid_with_multiple_draft_angles,1>::Construct )
-,		SchemaEntry("face",&STEP::ObjectHelper<face,1>::Construct )
-,		SchemaEntry("face_based_surface_model",&STEP::ObjectHelper<face_based_surface_model,1>::Construct )
-,		SchemaEntry("face_bound",&STEP::ObjectHelper<face_bound,2>::Construct )
-,		SchemaEntry("face_outer_bound",&STEP::ObjectHelper<face_outer_bound,0>::Construct )
-,		SchemaEntry("faceted_brep",&STEP::ObjectHelper<faceted_brep,0>::Construct )
-,		SchemaEntry("faceted_brep_shape_representation",&STEP::ObjectHelper<faceted_brep_shape_representation,0>::Construct )
-,		SchemaEntry("fill_area_style",&STEP::ObjectHelper<fill_area_style,2>::Construct )
-,		SchemaEntry("fill_area_style_colour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("fill_area_style_hatching",&STEP::ObjectHelper<fill_area_style_hatching,5>::Construct )
-,		SchemaEntry("fill_area_style_tile_coloured_region",&STEP::ObjectHelper<fill_area_style_tile_coloured_region,2>::Construct )
-,		SchemaEntry("fill_area_style_tile_curve_with_style",&STEP::ObjectHelper<fill_area_style_tile_curve_with_style,1>::Construct )
-,		SchemaEntry("fill_area_style_tile_symbol_with_style",&STEP::ObjectHelper<fill_area_style_tile_symbol_with_style,1>::Construct )
-,		SchemaEntry("fill_area_style_tiles",&STEP::ObjectHelper<fill_area_style_tiles,3>::Construct )
-,		SchemaEntry("shape_representation_relationship",&STEP::ObjectHelper<shape_representation_relationship,0>::Construct )
-,		SchemaEntry("flat_pattern_ply_representation_relationship",&STEP::ObjectHelper<flat_pattern_ply_representation_relationship,0>::Construct )
-,		SchemaEntry("flatness_tolerance",&STEP::ObjectHelper<flatness_tolerance,0>::Construct )
-,		SchemaEntry("force_measure_with_unit",&STEP::ObjectHelper<force_measure_with_unit,0>::Construct )
-,		SchemaEntry("force_unit",&STEP::ObjectHelper<force_unit,0>::Construct )
-,		SchemaEntry("forward_chaining_rule",&STEP::ObjectHelper<forward_chaining_rule,0>::Construct )
-,		SchemaEntry("forward_chaining_rule_premise",&STEP::ObjectHelper<forward_chaining_rule_premise,0>::Construct )
-,		SchemaEntry("frequency_measure_with_unit",&STEP::ObjectHelper<frequency_measure_with_unit,0>::Construct )
-,		SchemaEntry("frequency_unit",&STEP::ObjectHelper<frequency_unit,0>::Construct )
-,		SchemaEntry("func",&STEP::ObjectHelper<func,0>::Construct )
-,		SchemaEntry("functional_breakdown_context",&STEP::ObjectHelper<functional_breakdown_context,0>::Construct )
-,		SchemaEntry("functional_element_usage",&STEP::ObjectHelper<functional_element_usage,0>::Construct )
-,		SchemaEntry("functionally_defined_transformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("general_material_property",&STEP::ObjectHelper<general_material_property,0>::Construct )
-,		SchemaEntry("general_property_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("simple_generic_expression",&STEP::ObjectHelper<simple_generic_expression,0>::Construct )
-,		SchemaEntry("generic_literal",&STEP::ObjectHelper<generic_literal,0>::Construct )
-,		SchemaEntry("generic_variable",&STEP::ObjectHelper<generic_variable,0>::Construct )
-,		SchemaEntry("geometric_alignment",&STEP::ObjectHelper<geometric_alignment,0>::Construct )
-,		SchemaEntry("geometric_set",&STEP::ObjectHelper<geometric_set,1>::Construct )
-,		SchemaEntry("geometric_curve_set",&STEP::ObjectHelper<geometric_curve_set,0>::Construct )
-,		SchemaEntry("geometric_intersection",&STEP::ObjectHelper<geometric_intersection,0>::Construct )
-,		SchemaEntry("geometric_item_specific_usage",&STEP::ObjectHelper<geometric_item_specific_usage,0>::Construct )
-,		SchemaEntry("geometric_model_element_relationship",&STEP::ObjectHelper<geometric_model_element_relationship,0>::Construct )
-,		SchemaEntry("representation_context",&STEP::ObjectHelper<representation_context,2>::Construct )
-,		SchemaEntry("geometric_representation_context",&STEP::ObjectHelper<geometric_representation_context,1>::Construct )
-,		SchemaEntry("geometric_tolerance_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("geometric_tolerance_with_defined_unit",&STEP::ObjectHelper<geometric_tolerance_with_defined_unit,1>::Construct )
-,		SchemaEntry("geometrical_tolerance_callout",&STEP::ObjectHelper<geometrical_tolerance_callout,0>::Construct )
-,		SchemaEntry("geometrically_bounded_2d_wireframe_representation",&STEP::ObjectHelper<geometrically_bounded_2d_wireframe_representation,0>::Construct )
-,		SchemaEntry("geometrically_bounded_surface_shape_representation",&STEP::ObjectHelper<geometrically_bounded_surface_shape_representation,0>::Construct )
-,		SchemaEntry("geometrically_bounded_wireframe_shape_representation",&STEP::ObjectHelper<geometrically_bounded_wireframe_shape_representation,0>::Construct )
-,		SchemaEntry("global_assignment",&STEP::ObjectHelper<global_assignment,0>::Construct )
-,		SchemaEntry("global_uncertainty_assigned_context",&STEP::ObjectHelper<global_uncertainty_assigned_context,1>::Construct )
-,		SchemaEntry("global_unit_assigned_context",&STEP::ObjectHelper<global_unit_assigned_context,1>::Construct )
-,		SchemaEntry("ground_fact",&STEP::ObjectHelper<ground_fact,0>::Construct )
-,		SchemaEntry("group_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("hardness_representation",&STEP::ObjectHelper<hardness_representation,0>::Construct )
-,		SchemaEntry("hidden_element_over_riding_styled_item",&STEP::ObjectHelper<hidden_element_over_riding_styled_item,0>::Construct )
-,		SchemaEntry("hyperbola",&STEP::ObjectHelper<hyperbola,2>::Construct )
-,		SchemaEntry("id_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("identification_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("illuminance_measure_with_unit",&STEP::ObjectHelper<illuminance_measure_with_unit,0>::Construct )
-,		SchemaEntry("illuminance_unit",&STEP::ObjectHelper<illuminance_unit,0>::Construct )
-,		SchemaEntry("included_text_block",&STEP::ObjectHelper<included_text_block,0>::Construct )
-,		SchemaEntry("inclusion_product_concept_feature",&STEP::ObjectHelper<inclusion_product_concept_feature,0>::Construct )
-,		SchemaEntry("user_selected_elements",&STEP::ObjectHelper<user_selected_elements,1>::Construct )
-,		SchemaEntry("indirectly_selected_elements",&STEP::ObjectHelper<indirectly_selected_elements,1>::Construct )
-,		SchemaEntry("indirectly_selected_shape_elements",&STEP::ObjectHelper<indirectly_selected_shape_elements,0>::Construct )
-,		SchemaEntry("inductance_measure_with_unit",&STEP::ObjectHelper<inductance_measure_with_unit,0>::Construct )
-,		SchemaEntry("inductance_unit",&STEP::ObjectHelper<inductance_unit,0>::Construct )
-,		SchemaEntry("information_right",&STEP::ObjectHelper<information_right,0>::Construct )
-,		SchemaEntry("information_usage_right",&STEP::ObjectHelper<information_usage_right,0>::Construct )
-,		SchemaEntry("instance_usage_context_assignment",&STEP::ObjectHelper<instance_usage_context_assignment,1>::Construct )
-,		SchemaEntry("instanced_feature",&STEP::ObjectHelper<instanced_feature,0>::Construct )
-,		SchemaEntry("literal_number",&STEP::ObjectHelper<literal_number,1>::Construct )
-,		SchemaEntry("int_literal",&STEP::ObjectHelper<int_literal,0>::Construct )
-,		SchemaEntry("integer_representation_item",&STEP::ObjectHelper<integer_representation_item,0>::Construct )
-,		SchemaEntry("surface_curve",&STEP::ObjectHelper<surface_curve,3>::Construct )
-,		SchemaEntry("intersection_curve",&STEP::ObjectHelper<intersection_curve,0>::Construct )
-,		SchemaEntry("interval_expression",&STEP::ObjectHelper<interval_expression,0>::Construct )
-,		SchemaEntry("iso4217_currency",&STEP::ObjectHelper<iso4217_currency,0>::Construct )
-,		SchemaEntry("known_source",&STEP::ObjectHelper<known_source,0>::Construct )
-,		SchemaEntry("laid_defined_transformation",&STEP::ObjectHelper<laid_defined_transformation,0>::Construct )
-,		SchemaEntry("language",&STEP::ObjectHelper<language,0>::Construct )
-,		SchemaEntry("leader_curve",&STEP::ObjectHelper<leader_curve,0>::Construct )
-,		SchemaEntry("leader_directed_callout",&STEP::ObjectHelper<leader_directed_callout,0>::Construct )
-,		SchemaEntry("leader_directed_dimension",&STEP::ObjectHelper<leader_directed_dimension,0>::Construct )
-,		SchemaEntry("leader_terminator",&STEP::ObjectHelper<leader_terminator,0>::Construct )
-,		SchemaEntry("length_measure_with_unit",&STEP::ObjectHelper<length_measure_with_unit,0>::Construct )
-,		SchemaEntry("length_unit",&STEP::ObjectHelper<length_unit,0>::Construct )
-,		SchemaEntry("light_source",&STEP::ObjectHelper<light_source,1>::Construct )
-,		SchemaEntry("light_source_ambient",&STEP::ObjectHelper<light_source_ambient,0>::Construct )
-,		SchemaEntry("light_source_directional",&STEP::ObjectHelper<light_source_directional,1>::Construct )
-,		SchemaEntry("light_source_positional",&STEP::ObjectHelper<light_source_positional,3>::Construct )
-,		SchemaEntry("light_source_spot",&STEP::ObjectHelper<light_source_spot,6>::Construct )
-,		SchemaEntry("limits_and_fits",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("line",&STEP::ObjectHelper<line,2>::Construct )
-,		SchemaEntry("line_profile_tolerance",&STEP::ObjectHelper<line_profile_tolerance,0>::Construct )
-,		SchemaEntry("linear_dimension",&STEP::ObjectHelper<linear_dimension,0>::Construct )
-,		SchemaEntry("simple_clause",&STEP::ObjectHelper<simple_clause,0>::Construct )
-,		SchemaEntry("literal_conjunction",&STEP::ObjectHelper<literal_conjunction,0>::Construct )
-,		SchemaEntry("literal_disjunction",&STEP::ObjectHelper<literal_disjunction,0>::Construct )
-,		SchemaEntry("local_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("logical_literal",&STEP::ObjectHelper<logical_literal,1>::Construct )
-,		SchemaEntry("logical_representation_item",&STEP::ObjectHelper<logical_representation_item,0>::Construct )
-,		SchemaEntry("loop",&STEP::ObjectHelper<loop,0>::Construct )
-,		SchemaEntry("loss_tangent_measure_with_unit",&STEP::ObjectHelper<loss_tangent_measure_with_unit,0>::Construct )
-,		SchemaEntry("lot_effectivity",&STEP::ObjectHelper<lot_effectivity,2>::Construct )
-,		SchemaEntry("luminous_flux_measure_with_unit",&STEP::ObjectHelper<luminous_flux_measure_with_unit,0>::Construct )
-,		SchemaEntry("luminous_flux_unit",&STEP::ObjectHelper<luminous_flux_unit,0>::Construct )
-,		SchemaEntry("luminous_intensity_measure_with_unit",&STEP::ObjectHelper<luminous_intensity_measure_with_unit,0>::Construct )
-,		SchemaEntry("luminous_intensity_unit",&STEP::ObjectHelper<luminous_intensity_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_density_measure_with_unit",&STEP::ObjectHelper<magnetic_flux_density_measure_with_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_density_unit",&STEP::ObjectHelper<magnetic_flux_density_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_measure_with_unit",&STEP::ObjectHelper<magnetic_flux_measure_with_unit,0>::Construct )
-,		SchemaEntry("magnetic_flux_unit",&STEP::ObjectHelper<magnetic_flux_unit,0>::Construct )
-,		SchemaEntry("make_from_usage_option",&STEP::ObjectHelper<make_from_usage_option,3>::Construct )
-,		SchemaEntry("manifold_subsurface_shape_representation",&STEP::ObjectHelper<manifold_subsurface_shape_representation,0>::Construct )
-,		SchemaEntry("manifold_surface_shape_representation",&STEP::ObjectHelper<manifold_surface_shape_representation,0>::Construct )
-,		SchemaEntry("mass_measure_with_unit",&STEP::ObjectHelper<mass_measure_with_unit,0>::Construct )
-,		SchemaEntry("mass_unit",&STEP::ObjectHelper<mass_unit,0>::Construct )
-,		SchemaEntry("material_designation_characterization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("material_property",&STEP::ObjectHelper<material_property,0>::Construct )
-,		SchemaEntry("property_definition_representation",&STEP::ObjectHelper<property_definition_representation,2>::Construct )
-,		SchemaEntry("material_property_representation",&STEP::ObjectHelper<material_property_representation,1>::Construct )
-,		SchemaEntry("measure_qualification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("measure_representation_item",&STEP::ObjectHelper<measure_representation_item,0>::Construct )
-,		SchemaEntry("product_context",&STEP::ObjectHelper<product_context,1>::Construct )
-,		SchemaEntry("mechanical_context",&STEP::ObjectHelper<mechanical_context,0>::Construct )
-,		SchemaEntry("mechanical_design_and_draughting_relationship",&STEP::ObjectHelper<mechanical_design_and_draughting_relationship,0>::Construct )
-,		SchemaEntry("mechanical_design_geometric_presentation_area",&STEP::ObjectHelper<mechanical_design_geometric_presentation_area,0>::Construct )
-,		SchemaEntry("mechanical_design_geometric_presentation_representation",&STEP::ObjectHelper<mechanical_design_geometric_presentation_representation,0>::Construct )
-,		SchemaEntry("mechanical_design_presentation_representation_with_draughting",&STEP::ObjectHelper<mechanical_design_presentation_representation_with_draughting,0>::Construct )
-,		SchemaEntry("mechanical_design_shaded_presentation_area",&STEP::ObjectHelper<mechanical_design_shaded_presentation_area,0>::Construct )
-,		SchemaEntry("mechanical_design_shaded_presentation_representation",&STEP::ObjectHelper<mechanical_design_shaded_presentation_representation,0>::Construct )
-,		SchemaEntry("min_and_major_ply_orientation_basis",&STEP::ObjectHelper<min_and_major_ply_orientation_basis,0>::Construct )
-,		SchemaEntry("modified_geometric_tolerance",&STEP::ObjectHelper<modified_geometric_tolerance,1>::Construct )
-,		SchemaEntry("modified_solid_with_placed_configuration",&STEP::ObjectHelper<modified_solid_with_placed_configuration,1>::Construct )
-,		SchemaEntry("moments_of_inertia_representation",&STEP::ObjectHelper<moments_of_inertia_representation,0>::Construct )
-,		SchemaEntry("multi_language_attribute_assignment",&STEP::ObjectHelper<multi_language_attribute_assignment,1>::Construct )
-,		SchemaEntry("multiple_arity_boolean_expression",&STEP::ObjectHelper<multiple_arity_boolean_expression,0>::Construct )
-,		SchemaEntry("multiple_arity_generic_expression",&STEP::ObjectHelper<multiple_arity_generic_expression,1>::Construct )
-,		SchemaEntry("multiple_arity_numeric_expression",&STEP::ObjectHelper<multiple_arity_numeric_expression,0>::Construct )
-,		SchemaEntry("name_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("next_assembly_usage_occurrence",&STEP::ObjectHelper<next_assembly_usage_occurrence,0>::Construct )
-,		SchemaEntry("non_manifold_surface_shape_representation",&STEP::ObjectHelper<non_manifold_surface_shape_representation,0>::Construct )
-,		SchemaEntry("null_representation_item",&STEP::ObjectHelper<null_representation_item,0>::Construct )
-,		SchemaEntry("numeric_expression",&STEP::ObjectHelper<numeric_expression,0>::Construct )
-,		SchemaEntry("object_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("offset_curve_2d",&STEP::ObjectHelper<offset_curve_2d,3>::Construct )
-,		SchemaEntry("offset_curve_3d",&STEP::ObjectHelper<offset_curve_3d,4>::Construct )
-,		SchemaEntry("offset_surface",&STEP::ObjectHelper<offset_surface,3>::Construct )
-,		SchemaEntry("one_direction_repeat_factor",&STEP::ObjectHelper<one_direction_repeat_factor,1>::Construct )
-,		SchemaEntry("open_shell",&STEP::ObjectHelper<open_shell,0>::Construct )
-,		SchemaEntry("ordinal_date",&STEP::ObjectHelper<ordinal_date,1>::Construct )
-,		SchemaEntry("projection_directed_callout",&STEP::ObjectHelper<projection_directed_callout,0>::Construct )
-,		SchemaEntry("ordinate_dimension",&STEP::ObjectHelper<ordinate_dimension,0>::Construct )
-,		SchemaEntry("organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organization_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organization_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organizational_address",&STEP::ObjectHelper<organizational_address,2>::Construct )
-,		SchemaEntry("organizational_project",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organizational_project_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("organizational_project_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("oriented_closed_shell",&STEP::ObjectHelper<oriented_closed_shell,2>::Construct )
-,		SchemaEntry("oriented_edge",&STEP::ObjectHelper<oriented_edge,2>::Construct )
-,		SchemaEntry("oriented_face",&STEP::ObjectHelper<oriented_face,2>::Construct )
-,		SchemaEntry("oriented_open_shell",&STEP::ObjectHelper<oriented_open_shell,2>::Construct )
-,		SchemaEntry("path",&STEP::ObjectHelper<path,1>::Construct )
-,		SchemaEntry("oriented_path",&STEP::ObjectHelper<oriented_path,2>::Construct )
-,		SchemaEntry("oriented_surface",&STEP::ObjectHelper<oriented_surface,1>::Construct )
-,		SchemaEntry("outer_boundary_curve",&STEP::ObjectHelper<outer_boundary_curve,0>::Construct )
-,		SchemaEntry("package_product_concept_feature",&STEP::ObjectHelper<package_product_concept_feature,0>::Construct )
-,		SchemaEntry("parabola",&STEP::ObjectHelper<parabola,1>::Construct )
-,		SchemaEntry("parallel_offset",&STEP::ObjectHelper<parallel_offset,1>::Construct )
-,		SchemaEntry("parallelism_tolerance",&STEP::ObjectHelper<parallelism_tolerance,0>::Construct )
-,		SchemaEntry("parametric_representation_context",&STEP::ObjectHelper<parametric_representation_context,0>::Construct )
-,		SchemaEntry("partial_document_with_structured_text_representation_assignment",&STEP::ObjectHelper<partial_document_with_structured_text_representation_assignment,0>::Construct )
-,		SchemaEntry("pcurve",&STEP::ObjectHelper<pcurve,2>::Construct )
-,		SchemaEntry("percentage_laminate_definition",&STEP::ObjectHelper<percentage_laminate_definition,0>::Construct )
-,		SchemaEntry("zone_structural_makeup",&STEP::ObjectHelper<zone_structural_makeup,0>::Construct )
-,		SchemaEntry("percentage_laminate_table",&STEP::ObjectHelper<percentage_laminate_table,0>::Construct )
-,		SchemaEntry("percentage_ply_definition",&STEP::ObjectHelper<percentage_ply_definition,0>::Construct )
-,		SchemaEntry("perpendicular_to",&STEP::ObjectHelper<perpendicular_to,0>::Construct )
-,		SchemaEntry("perpendicularity_tolerance",&STEP::ObjectHelper<perpendicularity_tolerance,0>::Construct )
-,		SchemaEntry("person",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("person_and_organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("person_and_organization_address",&STEP::ObjectHelper<person_and_organization_address,0>::Construct )
-,		SchemaEntry("person_and_organization_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("personal_address",&STEP::ObjectHelper<personal_address,2>::Construct )
-,		SchemaEntry("physical_breakdown_context",&STEP::ObjectHelper<physical_breakdown_context,0>::Construct )
-,		SchemaEntry("physical_element_usage",&STEP::ObjectHelper<physical_element_usage,0>::Construct )
-,		SchemaEntry("presentation_view",&STEP::ObjectHelper<presentation_view,0>::Construct )
-,		SchemaEntry("picture_representation",&STEP::ObjectHelper<picture_representation,0>::Construct )
-,		SchemaEntry("placed_datum_target_feature",&STEP::ObjectHelper<placed_datum_target_feature,0>::Construct )
-,		SchemaEntry("placed_feature",&STEP::ObjectHelper<placed_feature,0>::Construct )
-,		SchemaEntry("planar_extent",&STEP::ObjectHelper<planar_extent,2>::Construct )
-,		SchemaEntry("planar_box",&STEP::ObjectHelper<planar_box,1>::Construct )
-,		SchemaEntry("plane",&STEP::ObjectHelper<plane,0>::Construct )
-,		SchemaEntry("plane_angle_measure_with_unit",&STEP::ObjectHelper<plane_angle_measure_with_unit,0>::Construct )
-,		SchemaEntry("plane_angle_unit",&STEP::ObjectHelper<plane_angle_unit,0>::Construct )
-,		SchemaEntry("plus_minus_tolerance",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ply_laminate_definition",&STEP::ObjectHelper<ply_laminate_definition,0>::Construct )
-,		SchemaEntry("ply_laminate_sequence_definition",&STEP::ObjectHelper<ply_laminate_sequence_definition,0>::Construct )
-,		SchemaEntry("ply_laminate_table",&STEP::ObjectHelper<ply_laminate_table,0>::Construct )
-,		SchemaEntry("point_and_vector",&STEP::ObjectHelper<point_and_vector,0>::Construct )
-,		SchemaEntry("point_on_curve",&STEP::ObjectHelper<point_on_curve,2>::Construct )
-,		SchemaEntry("point_on_surface",&STEP::ObjectHelper<point_on_surface,3>::Construct )
-,		SchemaEntry("point_path",&STEP::ObjectHelper<point_path,0>::Construct )
-,		SchemaEntry("point_replica",&STEP::ObjectHelper<point_replica,2>::Construct )
-,		SchemaEntry("point_style",&STEP::ObjectHelper<point_style,4>::Construct )
-,		SchemaEntry("polar_complex_number_literal",&STEP::ObjectHelper<polar_complex_number_literal,2>::Construct )
-,		SchemaEntry("poly_loop",&STEP::ObjectHelper<poly_loop,1>::Construct )
-,		SchemaEntry("polyline",&STEP::ObjectHelper<polyline,1>::Construct )
-,		SchemaEntry("position_tolerance",&STEP::ObjectHelper<position_tolerance,0>::Construct )
-,		SchemaEntry("positioned_sketch",&STEP::ObjectHelper<positioned_sketch,2>::Construct )
-,		SchemaEntry("power_measure_with_unit",&STEP::ObjectHelper<power_measure_with_unit,0>::Construct )
-,		SchemaEntry("power_unit",&STEP::ObjectHelper<power_unit,0>::Construct )
-,		SchemaEntry("pre_defined_symbol",&STEP::ObjectHelper<pre_defined_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_dimension_symbol",&STEP::ObjectHelper<pre_defined_dimension_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_geometrical_tolerance_symbol",&STEP::ObjectHelper<pre_defined_geometrical_tolerance_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_marker",&STEP::ObjectHelper<pre_defined_marker,0>::Construct )
-,		SchemaEntry("pre_defined_point_marker_symbol",&STEP::ObjectHelper<pre_defined_point_marker_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_surface_condition_symbol",&STEP::ObjectHelper<pre_defined_surface_condition_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_surface_side_style",&STEP::ObjectHelper<pre_defined_surface_side_style,0>::Construct )
-,		SchemaEntry("pre_defined_terminator_symbol",&STEP::ObjectHelper<pre_defined_terminator_symbol,0>::Construct )
-,		SchemaEntry("pre_defined_tile",&STEP::ObjectHelper<pre_defined_tile,0>::Construct )
-,		SchemaEntry("precision_qualifier",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("predefined_picture_representation_item",&STEP::ObjectHelper<predefined_picture_representation_item,0>::Construct )
-,		SchemaEntry("presentation_layer_assignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_size",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("presentation_style_assignment",&STEP::ObjectHelper<presentation_style_assignment,1>::Construct )
-,		SchemaEntry("presentation_style_by_context",&STEP::ObjectHelper<presentation_style_by_context,1>::Construct )
-//,		SchemaEntry("presented_item_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("pressure_measure_with_unit",&STEP::ObjectHelper<pressure_measure_with_unit,0>::Construct )
-,		SchemaEntry("pressure_unit",&STEP::ObjectHelper<pressure_unit,0>::Construct )
-,		SchemaEntry("procedural_representation",&STEP::ObjectHelper<procedural_representation,0>::Construct )
-,		SchemaEntry("procedural_representation_sequence",&STEP::ObjectHelper<procedural_representation_sequence,3>::Construct )
-,		SchemaEntry("procedural_shape_representation",&STEP::ObjectHelper<procedural_shape_representation,0>::Construct )
-,		SchemaEntry("procedural_shape_representation_sequence",&STEP::ObjectHelper<procedural_shape_representation_sequence,0>::Construct )
-,		SchemaEntry("product",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_category",&STEP::ObjectHelper<product_category,2>::Construct )
-,		SchemaEntry("product_class",&STEP::ObjectHelper<product_class,0>::Construct )
-,		SchemaEntry("product_concept",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_concept_context",&STEP::ObjectHelper<product_concept_context,1>::Construct )
-,		SchemaEntry("product_concept_feature_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_concept_feature_category_usage",&STEP::ObjectHelper<product_concept_feature_category_usage,1>::Construct )
-,		SchemaEntry("product_concept_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_context_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_context_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_element_relationship",&STEP::ObjectHelper<product_definition_element_relationship,0>::Construct )
-,		SchemaEntry("product_definition_formation",&STEP::ObjectHelper<product_definition_formation,3>::Construct )
-,		SchemaEntry("product_definition_formation_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_formation_with_specified_source",&STEP::ObjectHelper<product_definition_formation_with_specified_source,1>::Construct )
-,		SchemaEntry("product_definition_group_assignment",&STEP::ObjectHelper<product_definition_group_assignment,1>::Construct )
-,		SchemaEntry("product_definition_occurrence_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_shape",&STEP::ObjectHelper<product_definition_shape,0>::Construct )
-,		SchemaEntry("product_definition_substitute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("product_definition_with_associated_documents",&STEP::ObjectHelper<product_definition_with_associated_documents,1>::Construct )
-,		SchemaEntry("product_identification",&STEP::ObjectHelper<product_identification,0>::Construct )
-,		SchemaEntry("product_material_composition_relationship",&STEP::ObjectHelper<product_material_composition_relationship,4>::Construct )
-,		SchemaEntry("product_related_product_category",&STEP::ObjectHelper<product_related_product_category,1>::Construct )
-,		SchemaEntry("product_specification",&STEP::ObjectHelper<product_specification,0>::Construct )
-,		SchemaEntry("tolerance_zone_definition",&STEP::ObjectHelper<tolerance_zone_definition,2>::Construct )
-,		SchemaEntry("projected_zone_definition",&STEP::ObjectHelper<projected_zone_definition,2>::Construct )
-,		SchemaEntry("projection_curve",&STEP::ObjectHelper<projection_curve,0>::Construct )
-,		SchemaEntry("promissory_usage_occurrence",&STEP::ObjectHelper<promissory_usage_occurrence,0>::Construct )
-,		SchemaEntry("property_definition_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("qualified_representation_item",&STEP::ObjectHelper<qualified_representation_item,1>::Construct )
-,		SchemaEntry("qualitative_uncertainty",&STEP::ObjectHelper<qualitative_uncertainty,1>::Construct )
-,		SchemaEntry("quantified_assembly_component_usage",&STEP::ObjectHelper<quantified_assembly_component_usage,1>::Construct )
-,		SchemaEntry("quasi_uniform_curve",&STEP::ObjectHelper<quasi_uniform_curve,0>::Construct )
-,		SchemaEntry("quasi_uniform_surface",&STEP::ObjectHelper<quasi_uniform_surface,0>::Construct )
-,		SchemaEntry("radioactivity_measure_with_unit",&STEP::ObjectHelper<radioactivity_measure_with_unit,0>::Construct )
-,		SchemaEntry("radioactivity_unit",&STEP::ObjectHelper<radioactivity_unit,0>::Construct )
-,		SchemaEntry("radius_dimension",&STEP::ObjectHelper<radius_dimension,0>::Construct )
-,		SchemaEntry("range_characteristic",&STEP::ObjectHelper<range_characteristic,0>::Construct )
-,		SchemaEntry("ratio_unit",&STEP::ObjectHelper<ratio_unit,0>::Construct )
-,		SchemaEntry("rational_b_spline_curve",&STEP::ObjectHelper<rational_b_spline_curve,1>::Construct )
-,		SchemaEntry("rational_b_spline_surface",&STEP::ObjectHelper<rational_b_spline_surface,0>::Construct )
-,		SchemaEntry("rational_representation_item",&STEP::ObjectHelper<rational_representation_item,0>::Construct )
-,		SchemaEntry("real_literal",&STEP::ObjectHelper<real_literal,0>::Construct )
-,		SchemaEntry("real_representation_item",&STEP::ObjectHelper<real_representation_item,0>::Construct )
-,		SchemaEntry("rectangular_composite_surface",&STEP::ObjectHelper<rectangular_composite_surface,0>::Construct )
-,		SchemaEntry("rectangular_trimmed_surface",&STEP::ObjectHelper<rectangular_trimmed_surface,7>::Construct )
-,		SchemaEntry("referenced_modified_datum",&STEP::ObjectHelper<referenced_modified_datum,1>::Construct )
-,		SchemaEntry("relative_event_occurrence",&STEP::ObjectHelper<relative_event_occurrence,2>::Construct )
-,		SchemaEntry("rep_item_group",&STEP::ObjectHelper<rep_item_group,0>::Construct )
-,		SchemaEntry("reparametrised_composite_curve_segment",&STEP::ObjectHelper<reparametrised_composite_curve_segment,1>::Construct )
-,		SchemaEntry("representation_relationship_with_transformation",&STEP::ObjectHelper<representation_relationship_with_transformation,1>::Construct )
-,		SchemaEntry("requirement_assigned_object",&STEP::ObjectHelper<requirement_assigned_object,1>::Construct )
-,		SchemaEntry("requirement_assignment",&STEP::ObjectHelper<requirement_assignment,0>::Construct )
-,		SchemaEntry("requirement_source",&STEP::ObjectHelper<requirement_source,0>::Construct )
-,		SchemaEntry("requirement_view_definition_relationship",&STEP::ObjectHelper<requirement_view_definition_relationship,0>::Construct )
-,		SchemaEntry("resistance_measure_with_unit",&STEP::ObjectHelper<resistance_measure_with_unit,0>::Construct )
-,		SchemaEntry("resistance_unit",&STEP::ObjectHelper<resistance_unit,0>::Construct )
-,		SchemaEntry("revolved_area_solid",&STEP::ObjectHelper<revolved_area_solid,2>::Construct )
-,		SchemaEntry("revolved_face_solid",&STEP::ObjectHelper<revolved_face_solid,2>::Construct )
-,		SchemaEntry("revolved_face_solid_with_trim_conditions",&STEP::ObjectHelper<revolved_face_solid_with_trim_conditions,2>::Construct )
-,		SchemaEntry("right_angular_wedge",&STEP::ObjectHelper<right_angular_wedge,5>::Construct )
-,		SchemaEntry("right_circular_cone",&STEP::ObjectHelper<right_circular_cone,4>::Construct )
-,		SchemaEntry("right_circular_cylinder",&STEP::ObjectHelper<right_circular_cylinder,3>::Construct )
-,		SchemaEntry("right_to_usage_association",&STEP::ObjectHelper<right_to_usage_association,0>::Construct )
-,		SchemaEntry("role_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("roundness_tolerance",&STEP::ObjectHelper<roundness_tolerance,0>::Construct )
-,		SchemaEntry("row_representation_item",&STEP::ObjectHelper<row_representation_item,0>::Construct )
-,		SchemaEntry("row_value",&STEP::ObjectHelper<row_value,0>::Construct )
-,		SchemaEntry("row_variable",&STEP::ObjectHelper<row_variable,0>::Construct )
-,		SchemaEntry("rule_action",&STEP::ObjectHelper<rule_action,0>::Construct )
-,		SchemaEntry("rule_condition",&STEP::ObjectHelper<rule_condition,0>::Construct )
-,		SchemaEntry("rule_set",&STEP::ObjectHelper<rule_set,0>::Construct )
-,		SchemaEntry("rule_set_group",&STEP::ObjectHelper<rule_set_group,0>::Construct )
-,		SchemaEntry("rule_superseded_assignment",&STEP::ObjectHelper<rule_superseded_assignment,1>::Construct )
-,		SchemaEntry("rule_supersedence",&STEP::ObjectHelper<rule_supersedence,0>::Construct )
-,		SchemaEntry("surface_curve_swept_area_solid",&STEP::ObjectHelper<surface_curve_swept_area_solid,4>::Construct )
-,		SchemaEntry("ruled_surface_swept_area_solid",&STEP::ObjectHelper<ruled_surface_swept_area_solid,0>::Construct )
-,		SchemaEntry("runout_zone_definition",&STEP::ObjectHelper<runout_zone_definition,1>::Construct )
-,		SchemaEntry("runout_zone_orientation",&STEP::ObjectHelper<runout_zone_orientation,1>::Construct )
-,		SchemaEntry("runout_zone_orientation_reference_direction",&STEP::ObjectHelper<runout_zone_orientation_reference_direction,1>::Construct )
-,		SchemaEntry("satisfied_requirement",&STEP::ObjectHelper<satisfied_requirement,1>::Construct )
-,		SchemaEntry("satisfies_requirement",&STEP::ObjectHelper<satisfies_requirement,0>::Construct )
-,		SchemaEntry("satisfying_item",&STEP::ObjectHelper<satisfying_item,1>::Construct )
-,		SchemaEntry("scalar_variable",&STEP::ObjectHelper<scalar_variable,0>::Construct )
-,		SchemaEntry("scattering_parameter",&STEP::ObjectHelper<scattering_parameter,0>::Construct )
-,		SchemaEntry("sculptured_solid",&STEP::ObjectHelper<sculptured_solid,2>::Construct )
-,		SchemaEntry("seam_curve",&STEP::ObjectHelper<seam_curve,0>::Construct )
-,		SchemaEntry("security_classification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("security_classification_level",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("serial_numbered_effectivity",&STEP::ObjectHelper<serial_numbered_effectivity,2>::Construct )
-,		SchemaEntry("shape_aspect_associativity",&STEP::ObjectHelper<shape_aspect_associativity,0>::Construct )
-,		SchemaEntry("shape_aspect_deriving_relationship",&STEP::ObjectHelper<shape_aspect_deriving_relationship,0>::Construct )
-,		SchemaEntry("shape_definition_representation",&STEP::ObjectHelper<shape_definition_representation,0>::Construct )
-,		SchemaEntry("shape_dimension_representation",&STEP::ObjectHelper<shape_dimension_representation,0>::Construct )
-,		SchemaEntry("shape_feature_definition",&STEP::ObjectHelper<shape_feature_definition,0>::Construct )
-,		SchemaEntry("shape_representation_with_parameters",&STEP::ObjectHelper<shape_representation_with_parameters,0>::Construct )
-,		SchemaEntry("shell_based_surface_model",&STEP::ObjectHelper<shell_based_surface_model,1>::Construct )
-,		SchemaEntry("shell_based_wireframe_model",&STEP::ObjectHelper<shell_based_wireframe_model,1>::Construct )
-,		SchemaEntry("shell_based_wireframe_shape_representation",&STEP::ObjectHelper<shell_based_wireframe_shape_representation,0>::Construct )
-,		SchemaEntry("si_absorbed_dose_unit",&STEP::ObjectHelper<si_absorbed_dose_unit,0>::Construct )
-,		SchemaEntry("si_capacitance_unit",&STEP::ObjectHelper<si_capacitance_unit,0>::Construct )
-,		SchemaEntry("si_conductance_unit",&STEP::ObjectHelper<si_conductance_unit,0>::Construct )
-,		SchemaEntry("si_dose_equivalent_unit",&STEP::ObjectHelper<si_dose_equivalent_unit,0>::Construct )
-,		SchemaEntry("si_electric_charge_unit",&STEP::ObjectHelper<si_electric_charge_unit,0>::Construct )
-,		SchemaEntry("si_electric_potential_unit",&STEP::ObjectHelper<si_electric_potential_unit,0>::Construct )
-,		SchemaEntry("si_energy_unit",&STEP::ObjectHelper<si_energy_unit,0>::Construct )
-,		SchemaEntry("si_force_unit",&STEP::ObjectHelper<si_force_unit,0>::Construct )
-,		SchemaEntry("si_frequency_unit",&STEP::ObjectHelper<si_frequency_unit,0>::Construct )
-,		SchemaEntry("si_illuminance_unit",&STEP::ObjectHelper<si_illuminance_unit,0>::Construct )
-,		SchemaEntry("si_inductance_unit",&STEP::ObjectHelper<si_inductance_unit,0>::Construct )
-,		SchemaEntry("si_magnetic_flux_density_unit",&STEP::ObjectHelper<si_magnetic_flux_density_unit,0>::Construct )
-,		SchemaEntry("si_magnetic_flux_unit",&STEP::ObjectHelper<si_magnetic_flux_unit,0>::Construct )
-,		SchemaEntry("si_power_unit",&STEP::ObjectHelper<si_power_unit,0>::Construct )
-,		SchemaEntry("si_pressure_unit",&STEP::ObjectHelper<si_pressure_unit,0>::Construct )
-,		SchemaEntry("si_radioactivity_unit",&STEP::ObjectHelper<si_radioactivity_unit,0>::Construct )
-,		SchemaEntry("si_resistance_unit",&STEP::ObjectHelper<si_resistance_unit,0>::Construct )
-,		SchemaEntry("si_unit",&STEP::ObjectHelper<si_unit,2>::Construct )
-,		SchemaEntry("simple_boolean_expression",&STEP::ObjectHelper<simple_boolean_expression,0>::Construct )
-,		SchemaEntry("simple_numeric_expression",&STEP::ObjectHelper<simple_numeric_expression,0>::Construct )
-,		SchemaEntry("slash_expression",&STEP::ObjectHelper<slash_expression,0>::Construct )
-,		SchemaEntry("smeared_material_definition",&STEP::ObjectHelper<smeared_material_definition,0>::Construct )
-,		SchemaEntry("solid_angle_measure_with_unit",&STEP::ObjectHelper<solid_angle_measure_with_unit,0>::Construct )
-,		SchemaEntry("solid_angle_unit",&STEP::ObjectHelper<solid_angle_unit,0>::Construct )
-,		SchemaEntry("solid_curve_font",&STEP::ObjectHelper<solid_curve_font,0>::Construct )
-,		SchemaEntry("solid_replica",&STEP::ObjectHelper<solid_replica,2>::Construct )
-,		SchemaEntry("solid_with_chamfered_edges",&STEP::ObjectHelper<solid_with_chamfered_edges,0>::Construct )
-,		SchemaEntry("solid_with_angle_based_chamfer",&STEP::ObjectHelper<solid_with_angle_based_chamfer,3>::Construct )
-,		SchemaEntry("solid_with_shape_element_pattern",&STEP::ObjectHelper<solid_with_shape_element_pattern,1>::Construct )
-,		SchemaEntry("solid_with_circular_pattern",&STEP::ObjectHelper<solid_with_circular_pattern,4>::Construct )
-,		SchemaEntry("solid_with_depression",&STEP::ObjectHelper<solid_with_depression,1>::Construct )
-,		SchemaEntry("solid_with_pocket",&STEP::ObjectHelper<solid_with_pocket,2>::Construct )
-,		SchemaEntry("solid_with_circular_pocket",&STEP::ObjectHelper<solid_with_circular_pocket,1>::Construct )
-,		SchemaEntry("solid_with_protrusion",&STEP::ObjectHelper<solid_with_protrusion,2>::Construct )
-,		SchemaEntry("solid_with_circular_protrusion",&STEP::ObjectHelper<solid_with_circular_protrusion,1>::Construct )
-,		SchemaEntry("solid_with_hole",&STEP::ObjectHelper<solid_with_hole,0>::Construct )
-,		SchemaEntry("solid_with_stepped_round_hole",&STEP::ObjectHelper<solid_with_stepped_round_hole,1>::Construct )
-,		SchemaEntry("solid_with_conical_bottom_round_hole",&STEP::ObjectHelper<solid_with_conical_bottom_round_hole,2>::Construct )
-,		SchemaEntry("solid_with_constant_radius_edge_blend",&STEP::ObjectHelper<solid_with_constant_radius_edge_blend,1>::Construct )
-,		SchemaEntry("solid_with_slot",&STEP::ObjectHelper<solid_with_slot,2>::Construct )
-,		SchemaEntry("solid_with_curved_slot",&STEP::ObjectHelper<solid_with_curved_slot,1>::Construct )
-,		SchemaEntry("solid_with_double_offset_chamfer",&STEP::ObjectHelper<solid_with_double_offset_chamfer,2>::Construct )
-,		SchemaEntry("solid_with_flat_bottom_round_hole",&STEP::ObjectHelper<solid_with_flat_bottom_round_hole,1>::Construct )
-,		SchemaEntry("solid_with_general_pocket",&STEP::ObjectHelper<solid_with_general_pocket,2>::Construct )
-,		SchemaEntry("solid_with_general_protrusion",&STEP::ObjectHelper<solid_with_general_protrusion,2>::Construct )
-,		SchemaEntry("solid_with_groove",&STEP::ObjectHelper<solid_with_groove,5>::Construct )
-,		SchemaEntry("solid_with_incomplete_circular_pattern",&STEP::ObjectHelper<solid_with_incomplete_circular_pattern,1>::Construct )
-,		SchemaEntry("solid_with_rectangular_pattern",&STEP::ObjectHelper<solid_with_rectangular_pattern,4>::Construct )
-,		SchemaEntry("solid_with_incomplete_rectangular_pattern",&STEP::ObjectHelper<solid_with_incomplete_rectangular_pattern,0>::Construct )
-,		SchemaEntry("solid_with_rectangular_pocket",&STEP::ObjectHelper<solid_with_rectangular_pocket,3>::Construct )
-,		SchemaEntry("solid_with_rectangular_protrusion",&STEP::ObjectHelper<solid_with_rectangular_protrusion,3>::Construct )
-,		SchemaEntry("solid_with_single_offset_chamfer",&STEP::ObjectHelper<solid_with_single_offset_chamfer,1>::Construct )
-,		SchemaEntry("solid_with_spherical_bottom_round_hole",&STEP::ObjectHelper<solid_with_spherical_bottom_round_hole,1>::Construct )
-,		SchemaEntry("solid_with_stepped_round_hole_and_conical_transitions",&STEP::ObjectHelper<solid_with_stepped_round_hole_and_conical_transitions,1>::Construct )
-,		SchemaEntry("solid_with_straight_slot",&STEP::ObjectHelper<solid_with_straight_slot,1>::Construct )
-,		SchemaEntry("solid_with_tee_section_slot",&STEP::ObjectHelper<solid_with_tee_section_slot,2>::Construct )
-,		SchemaEntry("solid_with_through_depression",&STEP::ObjectHelper<solid_with_through_depression,1>::Construct )
-,		SchemaEntry("solid_with_trapezoidal_section_slot",&STEP::ObjectHelper<solid_with_trapezoidal_section_slot,2>::Construct )
-,		SchemaEntry("solid_with_variable_radius_edge_blend",&STEP::ObjectHelper<solid_with_variable_radius_edge_blend,3>::Construct )
-,		SchemaEntry("source_for_requirement",&STEP::ObjectHelper<source_for_requirement,1>::Construct )
-,		SchemaEntry("sourced_requirement",&STEP::ObjectHelper<sourced_requirement,1>::Construct )
-,		SchemaEntry("specification_definition",&STEP::ObjectHelper<specification_definition,0>::Construct )
-,		SchemaEntry("specified_higher_usage_occurrence",&STEP::ObjectHelper<specified_higher_usage_occurrence,2>::Construct )
-,		SchemaEntry("sphere",&STEP::ObjectHelper<sphere,2>::Construct )
-,		SchemaEntry("spherical_surface",&STEP::ObjectHelper<spherical_surface,1>::Construct )
-,		SchemaEntry("start_request",&STEP::ObjectHelper<start_request,1>::Construct )
-,		SchemaEntry("start_work",&STEP::ObjectHelper<start_work,1>::Construct )
-,		SchemaEntry("straightness_tolerance",&STEP::ObjectHelper<straightness_tolerance,0>::Construct )
-,		SchemaEntry("structured_dimension_callout",&STEP::ObjectHelper<structured_dimension_callout,0>::Construct )
-,		SchemaEntry("structured_text_composition",&STEP::ObjectHelper<structured_text_composition,0>::Construct )
-,		SchemaEntry("structured_text_representation",&STEP::ObjectHelper<structured_text_representation,0>::Construct )
-,		SchemaEntry("subedge",&STEP::ObjectHelper<subedge,1>::Construct )
-,		SchemaEntry("subface",&STEP::ObjectHelper<subface,1>::Construct )
-,		SchemaEntry("supplied_part_relationship",&STEP::ObjectHelper<supplied_part_relationship,0>::Construct )
-,		SchemaEntry("surface_condition_callout",&STEP::ObjectHelper<surface_condition_callout,0>::Construct )
-,		SchemaEntry("swept_surface",&STEP::ObjectHelper<swept_surface,1>::Construct )
-,		SchemaEntry("surface_of_linear_extrusion",&STEP::ObjectHelper<surface_of_linear_extrusion,1>::Construct )
-,		SchemaEntry("surface_of_revolution",&STEP::ObjectHelper<surface_of_revolution,1>::Construct )
-,		SchemaEntry("surface_patch",&STEP::ObjectHelper<surface_patch,5>::Construct )
-,		SchemaEntry("surface_profile_tolerance",&STEP::ObjectHelper<surface_profile_tolerance,0>::Construct )
-,		SchemaEntry("surface_rendering_properties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("surface_replica",&STEP::ObjectHelper<surface_replica,2>::Construct )
-,		SchemaEntry("surface_side_style",&STEP::ObjectHelper<surface_side_style,2>::Construct )
-,		SchemaEntry("surface_style_boundary",&STEP::ObjectHelper<surface_style_boundary,1>::Construct )
-,		SchemaEntry("surface_style_control_grid",&STEP::ObjectHelper<surface_style_control_grid,1>::Construct )
-,		SchemaEntry("surface_style_fill_area",&STEP::ObjectHelper<surface_style_fill_area,1>::Construct )
-,		SchemaEntry("surface_style_parameter_line",&STEP::ObjectHelper<surface_style_parameter_line,2>::Construct )
-,		SchemaEntry("surface_style_reflectance_ambient",&STEP::ObjectHelper<surface_style_reflectance_ambient,1>::Construct )
-,		SchemaEntry("surface_style_reflectance_ambient_diffuse",&STEP::ObjectHelper<surface_style_reflectance_ambient_diffuse,1>::Construct )
-,		SchemaEntry("surface_style_reflectance_ambient_diffuse_specular",&STEP::ObjectHelper<surface_style_reflectance_ambient_diffuse_specular,3>::Construct )
-,		SchemaEntry("surface_style_rendering",&STEP::ObjectHelper<surface_style_rendering,2>::Construct )
-,		SchemaEntry("surface_style_rendering_with_properties",&STEP::ObjectHelper<surface_style_rendering_with_properties,1>::Construct )
-,		SchemaEntry("surface_style_segmentation_curve",&STEP::ObjectHelper<surface_style_segmentation_curve,1>::Construct )
-,		SchemaEntry("surface_style_silhouette",&STEP::ObjectHelper<surface_style_silhouette,1>::Construct )
-,		SchemaEntry("surface_style_transparent",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("surface_style_usage",&STEP::ObjectHelper<surface_style_usage,2>::Construct )
-,		SchemaEntry("surface_texture_representation",&STEP::ObjectHelper<surface_texture_representation,0>::Construct )
-,		SchemaEntry("surfaced_open_shell",&STEP::ObjectHelper<surfaced_open_shell,0>::Construct )
-,		SchemaEntry("swept_disk_solid",&STEP::ObjectHelper<swept_disk_solid,5>::Construct )
-,		SchemaEntry("symbol",&STEP::ObjectHelper<symbol,0>::Construct )
-,		SchemaEntry("symbol_colour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("symbol_representation_map",&STEP::ObjectHelper<symbol_representation_map,0>::Construct )
-,		SchemaEntry("symbol_style",&STEP::ObjectHelper<symbol_style,2>::Construct )
-,		SchemaEntry("symbol_target",&STEP::ObjectHelper<symbol_target,3>::Construct )
-,		SchemaEntry("symmetric_shape_aspect",&STEP::ObjectHelper<symmetric_shape_aspect,0>::Construct )
-,		SchemaEntry("symmetry_tolerance",&STEP::ObjectHelper<symmetry_tolerance,0>::Construct )
-,		SchemaEntry("table_representation_item",&STEP::ObjectHelper<table_representation_item,0>::Construct )
-,		SchemaEntry("tactile_appearance_representation",&STEP::ObjectHelper<tactile_appearance_representation,0>::Construct )
-,		SchemaEntry("tagged_text_format",&STEP::ObjectHelper<tagged_text_format,0>::Construct )
-,		SchemaEntry("tagged_text_item",&STEP::ObjectHelper<tagged_text_item,0>::Construct )
-,		SchemaEntry("tangent",&STEP::ObjectHelper<tangent,0>::Construct )
-,		SchemaEntry("text_font",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_font_family",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_font_in_family",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_literal_with_associated_curves",&STEP::ObjectHelper<text_literal_with_associated_curves,1>::Construct )
-,		SchemaEntry("text_literal_with_blanking_box",&STEP::ObjectHelper<text_literal_with_blanking_box,1>::Construct )
-,		SchemaEntry("text_literal_with_extent",&STEP::ObjectHelper<text_literal_with_extent,1>::Construct )
-,		SchemaEntry("text_string_representation",&STEP::ObjectHelper<text_string_representation,0>::Construct )
-,		SchemaEntry("text_style",&STEP::ObjectHelper<text_style,2>::Construct )
-,		SchemaEntry("text_style_for_defined_font",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("text_style_with_box_characteristics",&STEP::ObjectHelper<text_style_with_box_characteristics,1>::Construct )
-,		SchemaEntry("text_style_with_mirror",&STEP::ObjectHelper<text_style_with_mirror,1>::Construct )
-,		SchemaEntry("text_style_with_spacing",&STEP::ObjectHelper<text_style_with_spacing,1>::Construct )
-,		SchemaEntry("thermal_resistance_measure_with_unit",&STEP::ObjectHelper<thermal_resistance_measure_with_unit,0>::Construct )
-,		SchemaEntry("thermal_resistance_unit",&STEP::ObjectHelper<thermal_resistance_unit,0>::Construct )
-,		SchemaEntry("thermodynamic_temperature_measure_with_unit",&STEP::ObjectHelper<thermodynamic_temperature_measure_with_unit,0>::Construct )
-,		SchemaEntry("thermodynamic_temperature_unit",&STEP::ObjectHelper<thermodynamic_temperature_unit,0>::Construct )
-,		SchemaEntry("thickened_face_solid",&STEP::ObjectHelper<thickened_face_solid,3>::Construct )
-,		SchemaEntry("thickness_laminate_definition",&STEP::ObjectHelper<thickness_laminate_definition,0>::Construct )
-,		SchemaEntry("thickness_laminate_table",&STEP::ObjectHelper<thickness_laminate_table,0>::Construct )
-,		SchemaEntry("time_interval",&STEP::ObjectHelper<time_interval,3>::Construct )
-,		SchemaEntry("time_interval_based_effectivity",&STEP::ObjectHelper<time_interval_based_effectivity,1>::Construct )
-,		SchemaEntry("time_interval_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("time_interval_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("time_interval_with_bounds",&STEP::ObjectHelper<time_interval_with_bounds,3>::Construct )
-,		SchemaEntry("time_measure_with_unit",&STEP::ObjectHelper<time_measure_with_unit,0>::Construct )
-,		SchemaEntry("time_unit",&STEP::ObjectHelper<time_unit,0>::Construct )
-,		SchemaEntry("tolerance_value",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("tolerance_zone",&STEP::ObjectHelper<tolerance_zone,2>::Construct )
-,		SchemaEntry("tolerance_zone_form",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("torus",&STEP::ObjectHelper<torus,3>::Construct )
-,		SchemaEntry("total_runout_tolerance",&STEP::ObjectHelper<total_runout_tolerance,0>::Construct )
-,		SchemaEntry("track_blended_solid",&STEP::ObjectHelper<track_blended_solid,0>::Construct )
-,		SchemaEntry("track_blended_solid_with_end_conditions",&STEP::ObjectHelper<track_blended_solid_with_end_conditions,1>::Construct )
-,		SchemaEntry("trimmed_curve",&STEP::ObjectHelper<trimmed_curve,5>::Construct )
-,		SchemaEntry("two_direction_repeat_factor",&STEP::ObjectHelper<two_direction_repeat_factor,1>::Construct )
-,		SchemaEntry("type_qualifier",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("unary_generic_expression",&STEP::ObjectHelper<unary_generic_expression,1>::Construct )
-,		SchemaEntry("unary_numeric_expression",&STEP::ObjectHelper<unary_numeric_expression,0>::Construct )
-,		SchemaEntry("uncertainty_assigned_representation",&STEP::ObjectHelper<uncertainty_assigned_representation,1>::Construct )
-,		SchemaEntry("uncertainty_measure_with_unit",&STEP::ObjectHelper<uncertainty_measure_with_unit,2>::Construct )
-,		SchemaEntry("uniform_curve",&STEP::ObjectHelper<uniform_curve,0>::Construct )
-,		SchemaEntry("uniform_resource_identifier",&STEP::ObjectHelper<uniform_resource_identifier,0>::Construct )
-,		SchemaEntry("uniform_surface",&STEP::ObjectHelper<uniform_surface,0>::Construct )
-,		SchemaEntry("usage_association",&STEP::ObjectHelper<usage_association,0>::Construct )
-,		SchemaEntry("user_defined_curve_font",&STEP::ObjectHelper<user_defined_curve_font,0>::Construct )
-,		SchemaEntry("user_defined_marker",&STEP::ObjectHelper<user_defined_marker,0>::Construct )
-,		SchemaEntry("user_defined_terminator_symbol",&STEP::ObjectHelper<user_defined_terminator_symbol,0>::Construct )
-,		SchemaEntry("user_selected_shape_elements",&STEP::ObjectHelper<user_selected_shape_elements,0>::Construct )
-,		SchemaEntry("value_range",&STEP::ObjectHelper<value_range,0>::Construct )
-,		SchemaEntry("value_representation_item",&STEP::ObjectHelper<value_representation_item,1>::Construct )
-,		SchemaEntry("variable_semantics",&STEP::ObjectHelper<variable_semantics,0>::Construct )
-,		SchemaEntry("variational_representation_item",&STEP::ObjectHelper<variational_representation_item,0>::Construct )
-,		SchemaEntry("vector",&STEP::ObjectHelper<vector,2>::Construct )
-,		SchemaEntry("vector_style",&STEP::ObjectHelper<vector_style,0>::Construct )
-,		SchemaEntry("velocity_measure_with_unit",&STEP::ObjectHelper<velocity_measure_with_unit,0>::Construct )
-,		SchemaEntry("velocity_unit",&STEP::ObjectHelper<velocity_unit,0>::Construct )
-,		SchemaEntry("versioned_action_request",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("vertex",&STEP::ObjectHelper<vertex,0>::Construct )
-,		SchemaEntry("vertex_loop",&STEP::ObjectHelper<vertex_loop,1>::Construct )
-,		SchemaEntry("vertex_point",&STEP::ObjectHelper<vertex_point,1>::Construct )
-,		SchemaEntry("vertex_shell",&STEP::ObjectHelper<vertex_shell,1>::Construct )
-,		SchemaEntry("view_volume",&STEP::ObjectHelper<view_volume,9>::Construct )
-,		SchemaEntry("visual_appearance_representation",&STEP::ObjectHelper<visual_appearance_representation,0>::Construct )
-,		SchemaEntry("volume_measure_with_unit",&STEP::ObjectHelper<volume_measure_with_unit,0>::Construct )
-,		SchemaEntry("volume_unit",&STEP::ObjectHelper<volume_unit,0>::Construct )
-,		SchemaEntry("week_of_year_and_day_date",&STEP::ObjectHelper<week_of_year_and_day_date,2>::Construct )
-,		SchemaEntry("wire_shell",&STEP::ObjectHelper<wire_shell,1>::Construct )
-,		SchemaEntry("year_month",&STEP::ObjectHelper<year_month,1>::Construct )
-
-	};
-}
-
-// -----------------------------------------------------------------------------------------------------------
-void StepFile::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<measure_with_unit>(const DB& db, const LIST& params, measure_with_unit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to measure_with_unit"); }    do { // convert the 'value_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::measure_with_unit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->value_component, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to measure_with_unit to be a `measure_value`")); }
-    } while(0);
-    do { // convert the 'unit_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::measure_with_unit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->unit_component, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to measure_with_unit to be a `unit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<absorbed_dose_measure_with_unit>(const DB& db, const LIST& params, absorbed_dose_measure_with_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to absorbed_dose_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<derived_unit>(const DB& db, const LIST& params, derived_unit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to derived_unit"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::derived_unit,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->elements, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to derived_unit to be a `SET [1:?] OF derived_unit_element`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<absorbed_dose_unit>(const DB& db, const LIST& params, absorbed_dose_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<derived_unit*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to absorbed_dose_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<abstract_variable>(const DB&, const LIST&, abstract_variable*) {
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<acceleration_measure_with_unit>(const DB& db, const LIST& params, acceleration_measure_with_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to acceleration_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<acceleration_unit>(const DB& db, const LIST& params, acceleration_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<derived_unit*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to acceleration_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action>(const DB& db, const LIST& params, action* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to action"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::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 action to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,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 action to be a `text`")); }
-    } while(0);
-    do { // convert the 'chosen_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->chosen_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action to be a `action_method`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_assignment>(const DB& db, const LIST& params, action_assignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to action_assignment"); }    do { // convert the 'assigned_action' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_assignment,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->assigned_action, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_assignment to be a `action`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_method>(const DB& db, const LIST& params, action_method* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to action_method"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::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 action_method to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::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 action_method to be a `text`")); }
-    } while(0);
-    do { // convert the 'consequence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->consequence, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action_method to be a `text`")); }
-    } while(0);
-    do { // convert the 'purpose' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->purpose, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to action_method to be a `text`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_method_assignment>(const DB& db, const LIST& params, action_method_assignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to action_method_assignment"); }    do { // convert the 'assigned_action_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_assignment,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->assigned_action_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method_assignment to be a `action_method`")); }
-    } while(0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_assignment,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->role, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method_assignment to be a `action_method_role`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_method_relationship>(const DB& db, const LIST& params, action_method_relationship* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to action_method_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::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 action_method_relationship to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::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 action_method_relationship to be a `text`")); }
-    } while(0);
-    do { // convert the 'relating_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->relating_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action_method_relationship to be a `action_method`")); }
-    } while(0);
-    do { // convert the 'related_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->related_method, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to action_method_relationship to be a `action_method`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<action_request_assignment>(const DB& db, const LIST& params, action_request_assignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to action_request_assignment"); }    do { // convert the 'assigned_action_request' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_request_assignment,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->assigned_action_request, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_request_assignment to be a `versioned_action_request`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<address>(const DB& db, const LIST& params, address* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to address"); }    do { // convert the 'internal_location' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->internal_location, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'street_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->street_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'street' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->street, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'postal_box' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->postal_box, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'town' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[4]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->town, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'region' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[5]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->region, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'postal_code' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[6]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->postal_code, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'country' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[7]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->country, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'facsimile_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[8]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->facsimile_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'telephone_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[9]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->telephone_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'electronic_mail_address' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[10]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->electronic_mail_address, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to address to be a `label`")); }
-    } while(0);
-    do { // convert the 'telex_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[11]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->telex_number, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to address to be a `label`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation>(const DB& db, const LIST& params, representation* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to representation"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::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 representation to be a `label`")); }
-    } while(0);
-    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->items, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation to be a `SET [1:?] OF representation_item`")); }
-    } while(0);
-    do { // convert the 'context_of_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->context_of_items, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation to be a `representation_context`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_representation>(const DB& db, const LIST& params, shape_representation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<advanced_brep_shape_representation>(const DB& db, const LIST& params, advanced_brep_shape_representation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<shape_representation*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to advanced_brep_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_surface>(const DB& db, const LIST& params, face_surface* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face_surface"); }    do { // convert the 'face_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_surface,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->face_geometry, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to face_surface to be a `surface`")); }
-    } while(0);
-    do { // convert the 'same_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_surface,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->same_sense, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_surface to be a `BOOLEAN`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<advanced_face>(const DB& db, const LIST& params, advanced_face* in)
-{
-	size_t base = GenericFill(db,params,static_cast<face_surface*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to advanced_face"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<amount_of_substance_measure_with_unit>(const DB& db, const LIST& params, amount_of_substance_measure_with_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to amount_of_substance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<named_unit>(const DB& db, const LIST& params, named_unit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to named_unit"); }    do { // convert the 'dimensions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::named_unit,1>::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 named_unit to be a `dimensional_exponents`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<amount_of_substance_unit>(const DB& db, const LIST& params, amount_of_substance_unit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<named_unit*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to amount_of_substance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angle_direction_reference>(const DB&, const LIST&, angle_direction_reference*)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_item>(const DB& db, const LIST& params, representation_item* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to representation_item"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item,1>::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 representation_item to be a `label`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_representation_item>(const DB& db, const LIST& params, geometric_representation_item* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to geometric_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_callout>(const DB& db, const LIST& params, draughting_callout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_representation_item*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to draughting_callout"); }    do { // convert the 'contents' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->contents, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout to be a `SET [1:?] OF draughting_callout_element`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve_directed_callout>(const DB& db, const LIST& params, dimension_curve_directed_callout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<draughting_callout*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_curve_directed_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angular_dimension>(const DB& db, const LIST& params, angular_dimension* in)
-{
-	size_t base = GenericFill(db,params,static_cast<dimension_curve_directed_callout*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to angular_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect_relationship>(const DB& db, const LIST& params, shape_aspect_relationship* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::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 shape_aspect_relationship to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::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 shape_aspect_relationship to be a `text`")); }
-    } while(0);
-    do { // convert the 'relating_shape_aspect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->relating_shape_aspect, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to shape_aspect_relationship to be a `shape_aspect`")); }
-    } while(0);
-    do { // convert the 'related_shape_aspect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->related_shape_aspect, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shape_aspect_relationship to be a `shape_aspect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_location>(const DB& db, const LIST& params, dimensional_location* in)
-{
-	size_t base = GenericFill(db,params,static_cast<shape_aspect_relationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimensional_location"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angular_location>(const DB& db, const LIST& params, angular_location* in)
-{
-	size_t base = GenericFill(db,params,static_cast<dimensional_location*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to angular_location"); }    do { // convert the 'angle_selection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->angle_selection, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to angular_location to be a `angle_relator`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_size>(const DB& db, const LIST& params, dimensional_size* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimensional_size"); }    do { // convert the 'applies_to' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::dimensional_size,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->applies_to, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to dimensional_size to be a `shape_aspect`")); }
-    } while(0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::dimensional_size,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->name, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dimensional_size to be a `label`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angular_size>(const DB& db, const LIST& params, angular_size* in)
-{
-	size_t base = GenericFill(db,params,static_cast<dimensional_size*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to angular_size"); }    do { // convert the 'angle_selection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->angle_selection, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to angular_size to be a `angle_relator`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_tolerance>(const DB& db, const LIST& params, geometric_tolerance* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_tolerance"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::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 geometric_tolerance to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to geometric_tolerance to be a `text`")); }
-    } while(0);
-    do { // convert the 'magnitude' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->magnitude, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to geometric_tolerance to be a `measure_with_unit`")); }
-    } while(0);
-    do { // convert the 'toleranced_shape_aspect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->toleranced_shape_aspect, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to geometric_tolerance to be a `shape_aspect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_tolerance_with_datum_reference>(const DB& db, const LIST& params, geometric_tolerance_with_datum_reference* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_tolerance*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_tolerance_with_datum_reference"); }    do { // convert the 'datum_system' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance_with_datum_reference,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->datum_system, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to geometric_tolerance_with_datum_reference to be a `SET [1:?] OF datum_reference`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<angularity_tolerance>(const DB& db, const LIST& params, angularity_tolerance* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_tolerance_with_datum_reference*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to angularity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<styled_item>(const DB& db, const LIST& params, styled_item* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to styled_item"); }    do { // convert the 'styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::styled_item,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->styles, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to styled_item to be a `SET [1:?] OF presentation_style_assignment`")); }
-    } while(0);
-    do { // convert the 'item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::styled_item,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->item, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to styled_item to be a `representation_item`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_occurrence>(const DB& db, const LIST& params, annotation_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<styled_item*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_curve_occurrence>(const DB& db, const LIST& params, annotation_curve_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_curve_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_fill_area>(const DB& db, const LIST& params, annotation_fill_area* in)
-{
-	size_t base = GenericFill(db,params,static_cast<geometric_representation_item*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to annotation_fill_area"); }    do { // convert the 'boundaries' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->boundaries, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to annotation_fill_area to be a `SET [1:?] OF curve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_fill_area_occurrence>(const DB& db, const LIST& params, annotation_fill_area_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_fill_area_occurrence"); }    do { // convert the 'fill_style_target' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->fill_style_target, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_fill_area_occurrence to be a `point`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_occurrence_relationship>(const DB& db, const LIST& params, annotation_occurrence_relationship* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_occurrence_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::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 annotation_occurrence_relationship to be a `label`")); }
-    } while(0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->description, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to annotation_occurrence_relationship to be a `text`")); }
-    } while(0);
-    do { // convert the 'relating_annotation_occurrence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->relating_annotation_occurrence, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to annotation_occurrence_relationship to be a `annotation_occurrence`")); }
-    } while(0);
-    do { // convert the 'related_annotation_occurrence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->related_annotation_occurrence, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_occurrence_relationship to be a `annotation_occurrence`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_occurrence_associativity>(const DB& db, const LIST& params, annotation_occurrence_associativity* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence_relationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_occurrence_associativity"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_plane>(const DB& db, const LIST& params, annotation_plane* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to annotation_plane"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->elements, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to annotation_plane to be a `SET [1:?] OF annotation_plane_element`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_symbol_occurrence>(const DB& db, const LIST& params, annotation_symbol_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_symbol_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_subfigure_occurrence>(const DB& db, const LIST& params, annotation_subfigure_occurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<annotation_symbol_occurrence*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_subfigure_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mapped_item>(const DB& db, const LIST& params, mapped_item* in)
-{
-	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mapped_item"); }    do { // convert the 'mapping_source' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::mapped_item,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->mapping_source, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to mapped_item to be a `representation_map`")); }
-    } while(0);
-    do { // convert the 'mapping_target' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::mapped_item,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->mapping_target, arg, db ); break; } 
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to mapped_item to be a `representation_item`")); }
-    } while(0);
-	return base;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_symbol>(const DB& db, const LIST& params, annotation_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_text>(const DB& db, const LIST& params, annotation_text* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_text"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_text_character>(const DB& db, const LIST& params, annotation_text_character* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_text_character"); }    do { // convert the 'alignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->alignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_text_character to be a `text_alignment`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<annotation_text_occurrence>(const DB& db, const LIST& params, annotation_text_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_text_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect>(const DB& db, const LIST& params, shape_aspect* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::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 shape_aspect to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::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 shape_aspect to be a `text`")); }
-    } while (0);
-    do { // convert the 'of_shape' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->of_shape, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to shape_aspect to be a `product_definition_shape`")); }
-    } while (0);
-    do { // convert the 'product_definitional' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->product_definitional, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shape_aspect to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<derived_shape_aspect>(const DB& db, const LIST& params, derived_shape_aspect* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to derived_shape_aspect"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<apex>(const DB& db, const LIST& params, apex* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to apex"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<application_context_element>(const DB& db, const LIST& params, application_context_element* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to application_context_element"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::application_context_element, 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 application_context_element to be a `label`")); }
-    } while (0);
-    do { // convert the 'frame_of_reference' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::application_context_element, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->frame_of_reference, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to application_context_element to be a `application_context`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_action_assignment>(const DB& db, const LIST& params, applied_action_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_action_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::applied_action_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_action_assignment to be a `SET [1:?] OF action_items`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_action_method_assignment>(const DB& db, const LIST& params, applied_action_method_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_action_method_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_action_method_assignment to be a `SET [1:?] OF action_method_items`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_action_request_assignment>(const DB& db, const LIST& params, applied_action_request_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_action_request_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_action_request_assignment to be a `SET [1:?] OF action_request_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<approval_assignment>(const DB& db, const LIST& params, approval_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to approval_assignment"); }    do { // convert the 'assigned_approval' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::approval_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_approval, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to approval_assignment to be a `approval`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_approval_assignment>(const DB& db, const LIST& params, applied_approval_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_approval_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_approval_assignment to be a `SET [1:?] OF approval_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_classification_assignment>(const DB& db, const LIST& params, attribute_classification_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_classification_assignment"); }    do { // convert the 'assigned_class' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_class, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_classification_assignment to be a `group`")); }
-    } while (0);
-    do { // convert the 'attribute_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->attribute_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_classification_assignment to be a `label`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_classification_assignment to be a `classification_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_attribute_classification_assignment>(const DB& db, const LIST& params, applied_attribute_classification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_attribute_classification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_attribute_classification_assignment to be a `SET [1:?] OF attribute_classification_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<certification_assignment>(const DB& db, const LIST& params, certification_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to certification_assignment"); }    do { // convert the 'assigned_certification' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::certification_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_certification, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to certification_assignment to be a `certification`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_certification_assignment>(const DB& db, const LIST& params, applied_certification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_certification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_certification_assignment to be a `SET [1:?] OF certification_item`")); }
-    } while (0);
-    return base;
-}
-
-} // ! STEP
-} // ! Assimp
-
-#endif
diff --git a/code/AssetLib/StepFile/StepFileGen2.cpp b/code/AssetLib/StepFile/StepFileGen2.cpp
deleted file mode 100644
index ea12cd7ba..000000000
--- a/code/AssetLib/StepFile/StepFileGen2.cpp
+++ /dev/null
@@ -1,3068 +0,0 @@
-/*
-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 "code/Importer/StepFile/StepReaderGen.h"
-
-namespace Assimp {
-using namespace StepFile;
-namespace STEP {
-
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<classification_assignment>(const DB& db, const LIST& params, classification_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to classification_assignment"); }    do { // convert the 'assigned_class' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_class, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to classification_assignment to be a `group`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to classification_assignment to be a `classification_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_classification_assignment>(const DB& db, const LIST& params, applied_classification_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<classification_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_classification_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_classification_assignment to be a `SET [1:?] OF classification_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<contract_assignment>(const DB& db, const LIST& params, contract_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to contract_assignment"); }    do { // convert the 'assigned_contract' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::contract_assignment, 1>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_contract, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to contract_assignment to be a `contract`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_contract_assignment>(const DB& db, const LIST& params, applied_contract_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_contract_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_contract_assignment to be a `SET [1:?] OF contract_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<date_and_time_assignment>(const DB& db, const LIST& params, date_and_time_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_and_time_assignment"); }    do { // convert the 'assigned_date_and_time' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_date_and_time, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_and_time_assignment to be a `date_and_time`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_and_time_assignment to be a `date_time_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_date_and_time_assignment>(const DB& db, const LIST& params, applied_date_and_time_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_and_time_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_and_time_assignment to be a `SET [1:?] OF date_and_time_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<date_assignment>(const DB& db, const LIST& params, date_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_assignment"); }    do { // convert the 'assigned_date' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_date, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_assignment to be a `date`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_assignment to be a `date_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_date_assignment>(const DB& db, const LIST& params, applied_date_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<date_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_assignment to be a `SET [1:?] OF date_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<document_reference>(const DB& db, const LIST& params, document_reference* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_reference"); }    do { // convert the 'assigned_document' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_document, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_reference to be a `document`")); }
-        } while (0);
-        do { // convert the 'source' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->source, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_reference to be a `label`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_document_reference>(const DB& db, const LIST& params, applied_document_reference* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_reference"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_reference to be a `SET [1:?] OF document_reference_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<document_usage_constraint_assignment>(const DB& db, const LIST& params, document_usage_constraint_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_usage_constraint_assignment"); }    do { // convert the 'assigned_document_usage' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_document_usage, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_usage_constraint_assignment to be a `document_usage_constraint`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_usage_constraint_assignment to be a `document_usage_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_document_usage_constraint_assignment>(const DB& db, const LIST& params, applied_document_usage_constraint_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<document_usage_constraint_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_usage_constraint_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_usage_constraint_assignment to be a `SET [1:?] OF document_reference_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<effectivity_assignment>(const DB& db, const LIST& params, effectivity_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity_assignment"); }    do { // convert the 'assigned_effectivity' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_assignment, 1>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_effectivity, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_assignment to be a `effectivity`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_effectivity_assignment>(const DB& db, const LIST& params, applied_effectivity_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_effectivity_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_effectivity_assignment to be a `SET [1:?] OF effectivity_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<event_occurrence_assignment>(const DB& db, const LIST& params, event_occurrence_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to event_occurrence_assignment"); }    do { // convert the 'assigned_event_occurrence' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_event_occurrence, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence_assignment to be a `event_occurrence`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence_assignment to be a `event_occurrence_role`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<applied_event_occurrence_assignment>(const DB& db, const LIST& params, applied_event_occurrence_assignment* in)
-    {
-        size_t base = GenericFill(db, params, static_cast<event_occurrence_assignment*>(in));
-        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_event_occurrence_assignment"); }    do { // convert the 'items' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            try { GenericConvert(in->items, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_event_occurrence_assignment to be a `SET [1:?] OF event_occurrence_item`")); }
-        } while (0);
-        return base;
-    }
-    // -----------------------------------------------------------------------------------------------------------
-    template <> size_t GenericFill<identification_assignment>(const DB& db, const LIST& params, identification_assignment* in)
-    {
-        size_t base = 0;
-        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to identification_assignment"); }    do { // convert the 'assigned_id' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[0] = true; break; }
-            try { GenericConvert(in->assigned_id, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to identification_assignment to be a `identifier`")); }
-        } while (0);
-        do { // convert the 'role' argument
-            std::shared_ptr<const DataType> arg = params[base++];
-            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[1] = true; break; }
-            try { GenericConvert(in->role, arg, db); break; }
-            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to identification_assignment to be a `identification_role`")); }
-        } while (0);
-        return base;
-    }
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<external_identification_assignment>(const DB& db, const LIST& params, external_identification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to external_identification_assignment"); }    do { // convert the 'source' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_identification_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->source, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to external_identification_assignment to be a `external_source`")); }
-    } while (0);
-    return base;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_external_identification_assignment>(const DB& db, const LIST& params, applied_external_identification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<external_identification_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_external_identification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_external_identification_assignment to be a `SET [1:?] OF external_identification_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<group_assignment>(const DB& db, const LIST& params, group_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to group_assignment"); }    do { // convert the 'assigned_group' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_group, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group_assignment to be a `group`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_group_assignment>(const DB& db, const LIST& params, applied_group_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_group_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_group_assignment to be a `SET [1:?] OF groupable_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_identification_assignment>(const DB& db, const LIST& params, applied_identification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_identification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_identification_assignment to be a `SET [1:?] OF identification_item`")); }
-    } while (0);
-    return base;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<name_assignment>(const DB& db, const LIST& params, name_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to name_assignment"); }    do { // convert the 'assigned_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::name_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to name_assignment to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_name_assignment>(const DB& db, const LIST& params, applied_name_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<name_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_name_assignment"); }    do { // convert the 'item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_name_assignment to be a `name_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<organization_assignment>(const DB& db, const LIST& params, organization_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organization_assignment"); }    do { // convert the 'assigned_organization' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_organization, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organization_assignment to be a `organization`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organization_assignment to be a `organization_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_organization_assignment>(const DB& db, const LIST& params, applied_organization_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<organization_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organization_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organization_assignment to be a `SET [1:?] OF organization_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<organizational_project_assignment>(const DB& db, const LIST& params, organizational_project_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organizational_project_assignment"); }    do { // convert the 'assigned_organizational_project' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_organizational_project, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organizational_project_assignment to be a `organizational_project`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organizational_project_assignment to be a `organizational_project_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_organizational_project_assignment>(const DB& db, const LIST& params, applied_organizational_project_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<organizational_project_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organizational_project_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organizational_project_assignment to be a `SET [1:?] OF project_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<person_and_organization_assignment>(const DB& db, const LIST& params, person_and_organization_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to person_and_organization_assignment"); }    do { // convert the 'assigned_person_and_organization' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_person_and_organization, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to person_and_organization_assignment to be a `person_and_organization`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to person_and_organization_assignment to be a `person_and_organization_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_person_and_organization_assignment>(const DB& db, const LIST& params, applied_person_and_organization_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_person_and_organization_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_person_and_organization_assignment to be a `SET [1:?] OF person_and_organization_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<presented_item>(const DB& db, const LIST& params, presented_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_presented_item>(const DB& db, const LIST& params, applied_presented_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presented_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to applied_presented_item"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to applied_presented_item to be a `SET [1:?] OF presented_item_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<security_classification_assignment>(const DB& db, const LIST& params, security_classification_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to security_classification_assignment"); }    do { // convert the 'assigned_security_classification' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::security_classification_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_security_classification, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to security_classification_assignment to be a `security_classification`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_security_classification_assignment>(const DB& db, const LIST& params, applied_security_classification_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_security_classification_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_security_classification_assignment to be a `SET [1:?] OF security_classification_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval_assignment>(const DB& db, const LIST& params, time_interval_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_assignment"); }    do { // convert the 'assigned_time_interval' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_time_interval, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval_assignment to be a `time_interval`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_assignment to be a `time_interval_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_time_interval_assignment>(const DB& db, const LIST& params, applied_time_interval_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<time_interval_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_time_interval_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_time_interval_assignment to be a `SET [0:?] OF time_interval_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<applied_usage_right>(const DB& db, const LIST& params, applied_usage_right* in)
-{
-    size_t base = GenericFill(db, params, static_cast<applied_action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_usage_right"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<area_in_set>(const DB& db, const LIST& params, area_in_set* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_in_set"); }    do { // convert the 'area' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->area, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to area_in_set to be a `presentation_area`")); }
-    } while (0);
-    do { // convert the 'in_set' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->in_set, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to area_in_set to be a `presentation_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<area_measure_with_unit>(const DB& db, const LIST& params, area_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<area_unit>(const DB& db, const LIST& params, area_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to area_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_relationship>(const DB& db, const LIST& params, product_definition_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_relationship"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_relationship to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[2] = 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 2 to product_definition_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_product_definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->relating_product_definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_relationship to be a `product_definition`")); }
-    } while (0);
-    do { // convert the 'related_product_definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->related_product_definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_relationship to be a `product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_usage>(const DB& db, const LIST& params, product_definition_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<assembly_component_usage>(const DB& db, const LIST& params, assembly_component_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to assembly_component_usage"); }    do { // convert the 'reference_designator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::assembly_component_usage, 1>::aux_is_derived[0] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->reference_designator, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to assembly_component_usage to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<assigned_requirement>(const DB& db, const LIST& params, assigned_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to assigned_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to assigned_requirement to be a `SET [1:1] OF product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<compound_representation_item>(const DB& db, const LIST& params, compound_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to compound_representation_item"); }    do { // convert the 'item_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::compound_representation_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->item_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to compound_representation_item to be a `compound_item_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<atomic_formula>(const DB& db, const LIST& params, atomic_formula* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to atomic_formula"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<attribute_assertion>(const DB& db, const LIST& params, attribute_assertion* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_language_assignment>(const DB& db, const LIST& params, attribute_language_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to attribute_language_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to attribute_language_assignment to be a `SET [1:?] OF attribute_language_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<attribute_value_assignment>(const DB& db, const LIST& params, attribute_value_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_value_assignment"); }    do { // convert the 'attribute_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->attribute_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_value_assignment to be a `label`")); }
-    } while (0);
-    do { // convert the 'attribute_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->attribute_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_value_assignment to be a `attribute_type`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_value_assignment to be a `attribute_value_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<auxiliary_geometric_representation_item>(const DB& db, const LIST& params, auxiliary_geometric_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<placement>(const DB& db, const LIST& params, placement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to placement"); }    do { // convert the 'location' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::placement, 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 1 to placement to be a `cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<axis1_placement>(const DB& db, const LIST& params, axis1_placement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<placement*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis1_placement"); }    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 2 to axis1_placement to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<axis2_placement_2d>(const DB& db, const LIST& params, axis2_placement_2d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<placement*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis2_placement_2d"); }    do { // convert the 'ref_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->ref_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_2d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<axis2_placement_3d>(const DB& db, const LIST& params, axis2_placement_3d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<placement*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to axis2_placement_3d"); }    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 2 to axis2_placement_3d to be a `direction`")); }
-    } while (0);
-    do { // convert the 'ref_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->ref_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to axis2_placement_3d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve>(const DB& db, const LIST& params, curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_curve>(const DB& db, const LIST& params, bounded_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_curve>(const DB& db, const LIST& params, b_spline_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to b_spline_curve"); }    do { // convert the 'degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 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 1 to b_spline_curve to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'control_points_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->control_points_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_curve to be a `LIST [2:?] OF cartesian_point`")); }
-    } while (0);
-    do { // convert the 'curve_form' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->curve_form, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_curve to be a `b_spline_curve_form`")); }
-    } while (0);
-    do { // convert the 'closed_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->closed_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_curve to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_curve to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_curve_with_knots>(const DB& db, const LIST& params, b_spline_curve_with_knots* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to b_spline_curve_with_knots"); }    do { // convert the 'knot_multiplicities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knot_multiplicities, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_curve_with_knots to be a `LIST [2:?] OF INTEGER`")); }
-    } while (0);
-    do { // convert the 'knots' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knots, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_curve_with_knots to be a `LIST [2:?] OF parameter_value`")); }
-    } while (0);
-    do { // convert the 'knot_spec' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knot_spec, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_curve_with_knots to be a `knot_type`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface>(const DB& db, const LIST& params, surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_surface>(const DB& db, const LIST& params, bounded_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_surface>(const DB& db, const LIST& params, b_spline_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to b_spline_surface"); }    do { // convert the 'u_degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->u_degree, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_surface to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'v_degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->v_degree, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_surface to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'surface_form' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->surface_form, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_surface to be a `b_spline_surface_form`")); }
-    } while (0);
-    do { // convert the 'u_closed' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->u_closed, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_surface to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'v_closed' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->v_closed, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_surface to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[5] = true; break; }
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_surface to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<b_spline_surface_with_knots>(const DB& db, const LIST& params, b_spline_surface_with_knots* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to b_spline_surface_with_knots"); }    do { // convert the 'u_multiplicities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_multiplicities, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
-    } while (0);
-    do { // convert the 'v_multiplicities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_multiplicities, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
-    } while (0);
-    do { // convert the 'u_knots' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_knots, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
-    } while (0);
-    do { // convert the 'v_knots' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_knots, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
-    } while (0);
-    do { // convert the 'knot_spec' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->knot_spec, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to b_spline_surface_with_knots to be a `knot_type`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition>(const DB& db, const LIST& params, product_definition* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::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 product_definition to be a `text`")); }
-    } while (0);
-    do { // convert the 'formation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->formation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition to be a `product_definition_formation`")); }
-    } while (0);
-    do { // convert the 'frame_of_reference' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->frame_of_reference, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition to be a `product_definition_context`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_software_definition>(const DB& db, const LIST& params, rule_software_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_software_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_definition>(const DB& db, const LIST& params, rule_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<back_chaining_rule>(const DB& db, const LIST& params, back_chaining_rule* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to back_chaining_rule"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<back_chaining_rule_body>(const DB& db, const LIST& params, back_chaining_rule_body* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<colour>(const DB& db, const LIST& params, colour* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<background_colour>(const DB& db, const LIST& params, background_colour* in)
-{
-    size_t base = GenericFill(db, params, static_cast<colour*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to background_colour"); }    do { // convert the 'presentation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->presentation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to background_colour to be a `area_or_view`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<beveled_sheet_representation>(const DB& db, const LIST& params, beveled_sheet_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to beveled_sheet_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bezier_curve>(const DB& db, const LIST& params, bezier_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to bezier_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bezier_surface>(const DB& db, const LIST& params, bezier_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to bezier_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<generic_expression>(const DB& db, const LIST& params, generic_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<binary_generic_expression>(const DB& db, const LIST& params, binary_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to binary_generic_expression"); }    do { // convert the 'operands' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operands, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to binary_generic_expression to be a `LIST [2:2] OF generic_expression`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<binary_numeric_expression>(const DB& db, const LIST& params, binary_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<binary_representation_item>(const DB& db, const LIST& params, binary_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to binary_representation_item"); }    do { // convert the 'binary_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::binary_representation_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->binary_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to binary_representation_item to be a `BINARY`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<block>(const DB& db, const LIST& params, block* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to block"); }    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 1 to block to be a `axis2_placement_3d`")); }
-    } while (0);
-    do { // convert the 'x' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->x, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to block to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'y' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->y, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to block to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'z' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->z, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to block to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<expression>(const DB& db, const LIST& params, expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_expression>(const DB& db, const LIST& params, boolean_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_literal>(const DB& db, const LIST& params, boolean_literal* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to boolean_literal"); }    do { // convert the 'the_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->the_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to boolean_literal to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<boolean_representation_item>(const DB& db, const LIST& params, boolean_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boolean_result>(const DB& db, const LIST& params, boolean_result* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boolean_result"); }    do { // convert the 'operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operator_, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to boolean_result to be a `boolean_operator`")); }
-    } while (0);
-    do { // convert the 'first_operand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->first_operand, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to boolean_result to be a `boolean_operand`")); }
-    } while (0);
-    do { // convert the 'second_operand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->second_operand, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boolean_result to be a `boolean_operand`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_curve>(const DB& db, const LIST& params, composite_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve"); }    do { // convert the 'segments' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 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 1 to composite_curve to be a `LIST [1:?] OF composite_curve_segment`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_curve_on_surface>(const DB& db, const LIST& params, composite_curve_on_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_on_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boundary_curve>(const DB& db, const LIST& params, boundary_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_curve_on_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to boundary_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<bounded_pcurve>(const DB& db, const LIST& params, bounded_pcurve* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bounded_surface_curve>(const DB& db, const LIST& params, bounded_surface_curve* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<founded_item>(const DB& db, const LIST& params, founded_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<box_domain>(const DB& db, const LIST& params, box_domain* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to box_domain"); }    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 box_domain to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'xlength' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->xlength, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to box_domain to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'ylength' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ylength, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to box_domain to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'zlength' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->zlength, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to box_domain to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<half_space_solid>(const DB& db, const LIST& params, half_space_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to half_space_solid"); }    do { // convert the 'base_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->base_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to half_space_solid to be a `surface`")); }
-    } while (0);
-    do { // convert the 'agreement_flag' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->agreement_flag, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to half_space_solid to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<boxed_half_space>(const DB& db, const LIST& params, boxed_half_space* in)
-{
-    size_t base = GenericFill(db, params, static_cast<half_space_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boxed_half_space"); }    do { // convert the 'enclosure' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->enclosure, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boxed_half_space to be a `box_domain`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_context>(const DB& db, const LIST& params, breakdown_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_element_group_assignment>(const DB& db, const LIST& params, breakdown_element_group_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to breakdown_element_group_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to breakdown_element_group_assignment to be a `SET [1:1] OF product_definition_or_breakdown_element_usage`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<breakdown_element_realization>(const DB& db, const LIST& params, breakdown_element_realization* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_element_usage>(const DB& db, const LIST& params, breakdown_element_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_element_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<breakdown_of>(const DB& db, const LIST& params, breakdown_of* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_of"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_model>(const DB& db, const LIST& params, solid_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_model"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<manifold_solid_brep>(const DB& db, const LIST& params, manifold_solid_brep* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to manifold_solid_brep"); }    do { // convert the 'outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::manifold_solid_brep, 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 1 to manifold_solid_brep to be a `closed_shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<brep_with_voids>(const DB& db, const LIST& params, brep_with_voids* in)
-{
-    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to brep_with_voids"); }    do { // convert the 'voids' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->voids, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to brep_with_voids to be a `SET [1:?] OF oriented_closed_shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<bytes_representation_item>(const DB& db, const LIST& params, bytes_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<binary_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to bytes_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<date>(const DB& db, const LIST& params, date* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to date"); }    do { // convert the 'year_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->year_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date to be a `year_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<calendar_date>(const DB& db, const LIST& params, calendar_date* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to calendar_date"); }    do { // convert the 'day_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->day_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to calendar_date to be a `day_in_month_number`")); }
-    } while (0);
-    do { // convert the 'month_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->month_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to calendar_date to be a `month_in_year_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_image>(const DB& db, const LIST& params, camera_image* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_image_3d_with_scale>(const DB& db, const LIST& params, camera_image_3d_with_scale* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_image*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image_3d_with_scale"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model>(const DB& db, const LIST& params, camera_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to camera_model"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3>(const DB& db, const LIST& params, camera_model_d3* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_model_d3"); }    do { // convert the 'view_reference_system' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->view_reference_system, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3 to be a `axis2_placement_3d`")); }
-    } while (0);
-    do { // convert the 'perspective_of_volume' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->perspective_of_volume, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to camera_model_d3 to be a `view_volume`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_multi_clipping>(const DB& db, const LIST& params, camera_model_d3_multi_clipping* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_multi_clipping"); }    do { // convert the 'shape_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->shape_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_multi_clipping to be a `SET [1:?] OF camera_model_d3_multi_clipping_interection_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_multi_clipping_intersection>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_intersection* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_intersection"); }    do { // convert the 'shape_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->shape_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_intersection to be a `SET [2:?] OF camera_model_d3_multi_clipping_interection_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_multi_clipping_union>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_union* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_union"); }    do { // convert the 'shape_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->shape_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_union to be a `SET [2:?] OF camera_model_d3_multi_clipping_union_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_d3_with_hlhsr>(const DB& db, const LIST& params, camera_model_d3_with_hlhsr* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_with_hlhsr"); }    do { // convert the 'hidden_line_surface_removal' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->hidden_line_surface_removal, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_with_hlhsr to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_model_with_light_sources>(const DB& db, const LIST& params, camera_model_with_light_sources* in)
-{
-    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_with_light_sources"); }    do { // convert the 'sources' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sources, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_with_light_sources to be a `SET [1:?] OF light_source`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_map>(const DB& db, const LIST& params, representation_map* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_map"); }    do { // convert the 'mapping_origin' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->mapping_origin, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_map to be a `representation_item`")); }
-    } while (0);
-    do { // convert the 'mapped_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->mapped_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_map to be a `representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<camera_usage>(const DB& db, const LIST& params, camera_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<capacitance_measure_with_unit>(const DB& db, const LIST& params, capacitance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to capacitance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<capacitance_unit>(const DB& db, const LIST& params, capacitance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to capacitance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point>(const DB& db, const LIST& params, point* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to point"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_point>(const DB& db, const LIST& params, cartesian_point* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cartesian_point"); }    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 1 to cartesian_point to be a `LIST [1:3] OF length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_transformation_operator>(const DB& db, const LIST& params, cartesian_transformation_operator* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator"); }    do { // convert the 'axis1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 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 cartesian_transformation_operator to be a `direction`")); }
-    } while (0);
-    do { // convert the 'axis2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 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 cartesian_transformation_operator to be a `direction`")); }
-    } while (0);
-    do { // convert the 'local_origin' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->local_origin, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cartesian_transformation_operator to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 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 cartesian_transformation_operator to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_transformation_operator_2d>(const DB& db, const LIST& params, cartesian_transformation_operator_2d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator_2d"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cartesian_transformation_operator_3d>(const DB& db, const LIST& params, cartesian_transformation_operator_3d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to cartesian_transformation_operator_3d"); }    do { // convert the 'axis3' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        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 cartesian_transformation_operator_3d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_approval>(const DB& db, const LIST& params, cc_design_approval* in)
-{
-    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_approval"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_approval to be a `SET [1:?] OF approved_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_certification>(const DB& db, const LIST& params, cc_design_certification* in)
-{
-    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_certification"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_certification to be a `SET [1:?] OF certified_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_contract>(const DB& db, const LIST& params, cc_design_contract* in)
-{
-    size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_contract"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_contract to be a `SET [1:?] OF contracted_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_date_and_time_assignment>(const DB& db, const LIST& params, cc_design_date_and_time_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_date_and_time_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_date_and_time_assignment to be a `SET [1:?] OF date_time_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_person_and_organization_assignment>(const DB& db, const LIST& params, cc_design_person_and_organization_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_person_and_organization_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_person_and_organization_assignment to be a `SET [1:?] OF cc_person_organization_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_security_classification>(const DB& db, const LIST& params, cc_design_security_classification* in)
-{
-    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_security_classification"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_security_classification to be a `SET [1:?] OF cc_classified_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cc_design_specification_reference>(const DB& db, const LIST& params, cc_design_specification_reference* in)
-{
-    size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_specification_reference"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_specification_reference to be a `SET [1:?] OF cc_specified_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<celsius_temperature_measure_with_unit>(const DB& db, const LIST& params, celsius_temperature_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to celsius_temperature_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<centre_of_symmetry>(const DB& db, const LIST& params, centre_of_symmetry* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to centre_of_symmetry"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<change>(const DB& db, const LIST& params, change* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change to be a `SET [1:?] OF work_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<change_request>(const DB& db, const LIST& params, change_request* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change_request"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change_request to be a `SET [1:?] OF change_request_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_style_outline>(const DB& db, const LIST& params, character_glyph_style_outline* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_outline"); }    do { // convert the 'outline_style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->outline_style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_outline to be a `curve_style`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_style_stroke>(const DB& db, const LIST& params, character_glyph_style_stroke* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_stroke"); }    do { // convert the 'stroke_style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->stroke_style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_stroke to be a `curve_style`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_representation>(const DB& db, const LIST& params, symbol_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to symbol_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_character_glyph_symbol>(const DB& db, const LIST& params, generic_character_glyph_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to generic_character_glyph_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_symbol>(const DB& db, const LIST& params, character_glyph_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_character_glyph_symbol*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to character_glyph_symbol"); }    do { // convert the 'character_box' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->character_box, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to character_glyph_symbol to be a `planar_extent`")); }
-    } while (0);
-    do { // convert the 'baseline_ratio' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->baseline_ratio, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to character_glyph_symbol to be a `ratio_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_symbol_outline>(const DB& db, const LIST& params, character_glyph_symbol_outline* in)
-{
-    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_outline"); }    do { // convert the 'outlines' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->outlines, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_outline to be a `SET [1:?] OF annotation_fill_area`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<character_glyph_symbol_stroke>(const DB& db, const LIST& params, character_glyph_symbol_stroke* in)
-{
-    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_stroke"); }    do { // convert the 'strokes' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->strokes, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_stroke to be a `SET [1:?] OF curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<general_property>(const DB& db, const LIST& params, general_property* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_property"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[2] = 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 2 to general_property to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_column_header>(const DB& db, const LIST& params, characteristic_data_column_header* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_column_header"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<general_property_relationship>(const DB& db, const LIST& params, general_property_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to general_property_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::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 general_property_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::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 general_property_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_property' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_property, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property_relationship to be a `general_property`")); }
-    } while (0);
-    do { // convert the 'related_property' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_property, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to general_property_relationship to be a `general_property`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_column_header_link>(const DB& db, const LIST& params, characteristic_data_column_header_link* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_column_header_link"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_table_header>(const DB& db, const LIST& params, characteristic_data_table_header* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_table_header"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_data_table_header_decomposition>(const DB& db, const LIST& params, characteristic_data_table_header_decomposition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_table_header_decomposition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<group>(const DB& db, const LIST& params, group* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to group"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 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 group to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 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 group to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characteristic_type>(const DB& db, const LIST& params, characteristic_type* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characteristic_type"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<characterized_class>(const DB& db, const LIST& params, characterized_class* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<characterized_object>(const DB& db, const LIST& params, characterized_object* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characterized_object"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 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 characterized_object to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 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 characterized_object to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conic>(const DB& db, const LIST& params, conic* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conic"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conic, 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 1 to conic to be a `axis2_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<circle>(const DB& db, const LIST& params, circle* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to circle"); }    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 2 to circle to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<circular_runout_tolerance>(const DB& db, const LIST& params, circular_runout_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to circular_runout_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_by_extension>(const DB& db, const LIST& params, class_by_extension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_extension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_by_intension>(const DB& db, const LIST& params, class_by_intension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_intension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_system>(const DB& db, const LIST& params, class_system* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_system"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<effectivity_context_assignment>(const DB& db, const LIST& params, effectivity_context_assignment* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to effectivity_context_assignment"); }    do { // convert the 'assigned_effectivity_assignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->assigned_effectivity_assignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_context_assignment to be a `effectivity_assignment`")); }
-    } while (0);
-    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to effectivity_context_assignment to be a `effectivity_context_role`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<class_usage_effectivity_context_assignment>(const DB& db, const LIST& params, class_usage_effectivity_context_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to class_usage_effectivity_context_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to class_usage_effectivity_context_assignment to be a `SET [1:?] OF class_usage_effectivity_context_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<topological_representation_item>(const DB& db, const LIST& params, topological_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to topological_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<connected_face_set>(const DB& db, const LIST& params, connected_face_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_face_set"); }    do { // convert the 'cfs_faces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::connected_face_set, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->cfs_faces, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_face_set to be a `SET [1:?] OF face`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<closed_shell>(const DB& db, const LIST& params, closed_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to closed_shell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<coaxiality_tolerance>(const DB& db, const LIST& params, coaxiality_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to coaxiality_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<colour_specification>(const DB& db, const LIST& params, colour_specification* in)
-{
-    size_t base = GenericFill(db, params, static_cast<colour*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to colour_specification"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::colour_specification, 1>::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 colour_specification to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<colour_rgb>(const DB& db, const LIST& params, colour_rgb* in)
-{
-    size_t base = GenericFill(db, params, static_cast<colour_specification*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to colour_rgb"); }    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 colour_rgb to be a `REAL`")); }
-    } 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 colour_rgb to be a `REAL`")); }
-    } 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 colour_rgb to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-/*
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<common_datum>(const DB& db, const LIST& params, common_datum* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<comparison_expression>(const DB& db, const LIST& params, comparison_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_clause>(const DB& db, const LIST& params, complex_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_conjunctive_clause>(const DB& db, const LIST& params, complex_conjunctive_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_conjunctive_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_disjunctive_clause>(const DB& db, const LIST& params, complex_disjunctive_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_disjunctive_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<modified_solid>(const DB& db, const LIST& params, modified_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to modified_solid"); }    do { // convert the 'rationale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->rationale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to modified_solid to be a `text`")); }
-    } while (0);
-    do { // convert the 'base_solid' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->base_solid, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to modified_solid to be a `base_solid_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shelled_solid>(const DB& db, const LIST& params, shelled_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to shelled_solid"); }    do { // convert the 'deleted_face_set' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->deleted_face_set, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shelled_solid to be a `SET [1:?] OF face_surface`")); }
-    } while (0);
-    do { // convert the 'thickness' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->thickness, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to shelled_solid to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<complex_shelled_solid>(const DB& db, const LIST& params, complex_shelled_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to complex_shelled_solid"); }    do { // convert the 'thickness_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->thickness_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to complex_shelled_solid to be a `LIST [1:?] OF length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_assembly_definition>(const DB& db, const LIST& params, composite_assembly_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_assembly_sequence_definition>(const DB& db, const LIST& params, composite_assembly_sequence_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_sequence_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<laminate_table>(const DB& db, const LIST& params, laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<part_laminate_table>(const DB& db, const LIST& params, part_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to part_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_assembly_table>(const DB& db, const LIST& params, composite_assembly_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_curve_segment>(const DB& db, const LIST& params, composite_curve_segment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_segment"); }    do { // convert the 'transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 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 composite_curve_segment to be a `transition_code`")); }
-    } while (0);
-    do { // convert the 'same_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->same_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve_segment to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'parent_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->parent_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve_segment to be a `curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<material_designation>(const DB& db, const LIST& params, material_designation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to material_designation"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 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 material_designation to be a `label`")); }
-    } while (0);
-    do { // convert the 'definitions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->definitions, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to material_designation to be a `SET [1:?] OF characterized_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_material_designation>(const DB& db, const LIST& params, composite_material_designation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<material_designation*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_material_designation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_shape_aspect>(const DB& db, const LIST& params, composite_shape_aspect* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_shape_aspect"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_sheet_representation>(const DB& db, const LIST& params, composite_sheet_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_sheet_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text>(const DB& db, const LIST& params, composite_text* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_text"); }    do { // convert the 'collected_text' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_text, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->collected_text, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_text to be a `SET [2:?] OF text_or_character`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_associated_curves>(const DB& db, const LIST& params, composite_text_with_associated_curves* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_associated_curves"); }    do { // convert the 'associated_curves' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->associated_curves, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_associated_curves to be a `SET [1:?] OF curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_blanking_box>(const DB& db, const LIST& params, composite_text_with_blanking_box* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_blanking_box"); }    do { // convert the 'blanking' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->blanking, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_blanking_box to be a `planar_box`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_delineation>(const DB& db, const LIST& params, composite_text_with_delineation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_delineation"); }    do { // convert the 'delineation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->delineation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_delineation to be a `text_delineation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<composite_text_with_extent>(const DB& db, const LIST& params, composite_text_with_extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_extent"); }    do { // convert the 'extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_extent to be a `planar_extent`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<compound_shape_representation>(const DB& db, const LIST& params, compound_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to compound_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<concentricity_tolerance>(const DB& db, const LIST& params, concentricity_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concentricity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<concept_feature_relationship>(const DB& db, const LIST& params, concept_feature_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to concept_feature_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::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 concept_feature_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::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 concept_feature_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_product_concept_feature' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_product_concept_feature, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to concept_feature_relationship to be a `product_concept_feature`")); }
-    } while (0);
-    do { // convert the 'related_product_concept_feature' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_product_concept_feature, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to concept_feature_relationship to be a `product_concept_feature`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<concept_feature_relationship_with_condition>(const DB& db, const LIST& params, concept_feature_relationship_with_condition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<concept_feature_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concept_feature_relationship_with_condition"); }    do { // convert the 'conditional_operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->conditional_operator, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to concept_feature_relationship_with_condition to be a `concept_feature_operator`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_feature>(const DB& db, const LIST& params, product_concept_feature* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_feature"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_concept_feature to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[2] = 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 2 to product_concept_feature to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conditional_concept_feature>(const DB& db, const LIST& params, conditional_concept_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conditional_concept_feature"); }    do { // convert the 'condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conditional_concept_feature, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conditional_concept_feature to be a `concept_feature_relationship_with_condition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conductance_measure_with_unit>(const DB& db, const LIST& params, conductance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conductance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conductance_unit>(const DB& db, const LIST& params, conductance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to conductance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item>(const DB& db, const LIST& params, configuration_item* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to configuration_item"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[2] = 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 2 to configuration_item to be a `text`")); }
-    } while (0);
-    do { // convert the 'item_concept' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->item_concept, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item to be a `product_concept`")); }
-    } while (0);
-    do { // convert the 'purpose' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[4] = true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->purpose, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to configuration_item to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configurable_item>(const DB& db, const LIST& params, configurable_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<configuration_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to configurable_item"); }    do { // convert the 'item_concept_feature' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->item_concept_feature, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to configurable_item to be a `SET [1:?] OF product_concept_feature_association`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<effectivity>(const DB& db, const LIST& params, effectivity* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_effectivity>(const DB& db, const LIST& params, product_definition_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_effectivity"); }    do { // convert the 'usage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_effectivity, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->usage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_effectivity to be a `product_definition_relationship`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_effectivity>(const DB& db, const LIST& params, configuration_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configuration_effectivity"); }    do { // convert the 'configuration' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->configuration, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_effectivity to be a `configuration_design`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item_relationship>(const DB& db, const LIST& params, configuration_item_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::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 configuration_item_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::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 configuration_item_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_configuration_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_configuration_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item_relationship to be a `configuration_item`")); }
-    } while (0);
-    do { // convert the 'related_configuration_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_configuration_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item_relationship to be a `configuration_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item_hierarchical_relationship>(const DB& db, const LIST& params, configuration_item_hierarchical_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_hierarchical_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configuration_item_revision_sequence>(const DB& db, const LIST& params, configuration_item_revision_sequence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_revision_sequence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configured_effectivity_assignment>(const DB& db, const LIST& params, configured_effectivity_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to configured_effectivity_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configured_effectivity_assignment to be a `SET [1:?] OF configured_effectivity_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<configured_effectivity_context_assignment>(const DB& db, const LIST& params, configured_effectivity_context_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configured_effectivity_context_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configured_effectivity_context_assignment to be a `SET [1:?] OF configured_effectivity_context_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conical_stepped_hole_transition>(const DB& db, const LIST& params, conical_stepped_hole_transition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_stepped_hole_transition"); }    do { // convert the 'transition_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transition_number, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conical_stepped_hole_transition to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'cone_apex_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->cone_apex_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_stepped_hole_transition to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'cone_base_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->cone_base_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_stepped_hole_transition to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<elementary_surface>(const DB& db, const LIST& params, elementary_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to elementary_surface"); }    do { // convert the 'position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::elementary_surface, 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 1 to elementary_surface to be a `axis2_placement_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conical_surface>(const DB& db, const LIST& params, conical_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_surface"); }    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 2 to conical_surface to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_surface to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<connected_edge_set>(const DB& db, const LIST& params, connected_edge_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_edge_set"); }    do { // convert the 'ces_edges' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ces_edges, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_edge_set to be a `SET [1:?] OF edge`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<connected_face_sub_set>(const DB& db, const LIST& params, connected_face_sub_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to connected_face_sub_set"); }    do { // convert the 'parent_face_set' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_face_set, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to connected_face_sub_set to be a `connected_face_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<constructive_geometry_representation>(const DB& db, const LIST& params, constructive_geometry_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to constructive_geometry_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_relationship>(const DB& db, const LIST& params, representation_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::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 representation_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::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 representation_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'rep_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->rep_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_relationship to be a `representation`")); }
-    } while (0);
-    do { // convert the 'rep_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->rep_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_relationship to be a `representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<constructive_geometry_representation_relationship>(const DB& db, const LIST& params, constructive_geometry_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to constructive_geometry_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<contact_ratio_representation>(const DB& db, const LIST& params, contact_ratio_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to contact_ratio_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<invisibility>(const DB& db, const LIST& params, invisibility* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to invisibility"); }    do { // convert the 'invisible_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::invisibility, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->invisible_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to invisibility to be a `SET [1:?] OF invisible_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<context_dependent_invisibility>(const DB& db, const LIST& params, context_dependent_invisibility* in)
-{
-    size_t base = GenericFill(db, params, static_cast<invisibility*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_invisibility"); }    do { // convert the 'presentation_context' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->presentation_context, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_invisibility to be a `invisibility_context`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<over_riding_styled_item>(const DB& db, const LIST& params, over_riding_styled_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<styled_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to over_riding_styled_item"); }    do { // convert the 'over_ridden_style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->over_ridden_style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to over_riding_styled_item to be a `styled_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<context_dependent_over_riding_styled_item>(const DB& db, const LIST& params, context_dependent_over_riding_styled_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<over_riding_styled_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to context_dependent_over_riding_styled_item"); }    do { // convert the 'style_context' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->style_context, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to context_dependent_over_riding_styled_item to be a `LIST [1:?] OF style_context_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<context_dependent_unit>(const DB& db, const LIST& params, context_dependent_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_unit"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_unit, 1>::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 1 to context_dependent_unit to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<conversion_based_unit>(const DB& db, const LIST& params, conversion_based_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to conversion_based_unit"); }    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 1 to conversion_based_unit to be a `label`")); }
-    } while (0);
-    do { // convert the 'conversion_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->conversion_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conversion_based_unit to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<csg_shape_representation>(const DB& db, const LIST& params, csg_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to csg_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<csg_solid>(const DB& db, const LIST& params, csg_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to csg_solid"); }    do { // convert the 'tree_root_expression' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tree_root_expression, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to csg_solid to be a `csg_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<currency>(const DB& db, const LIST& params, currency* in)
-{
-    size_t base = GenericFill(db, params, static_cast<context_dependent_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<currency_measure_with_unit>(const DB& db, const LIST& params, currency_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_bounded_surface>(const DB& db, const LIST& params, curve_bounded_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_bounded_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_bounded_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'boundaries' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->boundaries, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_bounded_surface to be a `SET [1:?] OF boundary_curve`")); }
-    } while (0);
-    do { // convert the 'implicit_outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->implicit_outer, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_bounded_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_dimension>(const DB& db, const LIST& params, curve_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_replica>(const DB& db, const LIST& params, curve_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_replica"); }    do { // convert the 'parent_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_replica to be a `curve`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_replica to be a `cartesian_transformation_operator`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style>(const DB& db, const LIST& params, curve_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_style"); }    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 0 to curve_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'curve_font' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_font, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style to be a `curve_font_or_scaled_curve_font_select`")); }
-    } while (0);
-    do { // convert the 'curve_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style to be a `size_select`")); }
-    } while (0);
-    do { // convert the 'curve_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_style to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style_font>(const DB& db, const LIST& params, curve_style_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font"); }    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 0 to curve_style_font to be a `label`")); }
-    } while (0);
-    do { // convert the 'pattern_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pattern_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font to be a `LIST [1:?] OF curve_style_font_pattern`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style_font_and_scaling>(const DB& db, const LIST& params, curve_style_font_and_scaling* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_style_font_and_scaling"); }    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 0 to curve_style_font_and_scaling to be a `label`")); }
-    } while (0);
-    do { // convert the 'curve_font' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_font, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_and_scaling to be a `curve_style_font_select`")); }
-    } while (0);
-    do { // convert the 'curve_font_scaling' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->curve_font_scaling, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style_font_and_scaling to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_style_font_pattern>(const DB& db, const LIST& params, curve_style_font_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font_pattern"); }    do { // convert the 'visible_segment_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->visible_segment_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_pattern to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'invisible_segment_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->invisible_segment_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_pattern to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<curve_swept_solid_shape_representation>(const DB& db, const LIST& params, curve_swept_solid_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_swept_solid_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cylindrical_surface>(const DB& db, const LIST& params, cylindrical_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cylindrical_surface"); }    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 2 to cylindrical_surface to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<cylindricity_tolerance>(const DB& db, const LIST& params, cylindricity_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cylindricity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<date_representation_item>(const DB& db, const LIST& params, date_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<date_time_representation_item>(const DB& db, const LIST& params, date_time_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dated_effectivity>(const DB& db, const LIST& params, dated_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dated_effectivity"); }    do { // convert the 'effectivity_end_date' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->effectivity_end_date, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    do { // convert the 'effectivity_start_date' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_start_date, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum>(const DB& db, const LIST& params, datum* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum"); }    do { // convert the 'identification' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->identification, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_feature>(const DB& db, const LIST& params, datum_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to datum_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_feature_callout>(const DB& db, const LIST& params, datum_feature_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_feature_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_reference>(const DB& db, const LIST& params, datum_reference* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_reference"); }    do { // convert the 'precedence' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->precedence, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to datum_reference to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'referenced_datum' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->referenced_datum, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to datum_reference to be a `datum`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_target>(const DB& db, const LIST& params, datum_target* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum_target"); }    do { // convert the 'target_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_target, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->target_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum_target to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<datum_target_callout>(const DB& db, const LIST& params, datum_target_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_target_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<default_tolerance_table>(const DB& db, const LIST& params, default_tolerance_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to default_tolerance_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<default_tolerance_table_cell>(const DB& db, const LIST& params, default_tolerance_table_cell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to default_tolerance_table_cell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<defined_symbol>(const DB& db, const LIST& params, defined_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to defined_symbol"); }    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to defined_symbol to be a `defined_symbol_select`")); }
-    } while (0);
-    do { // convert the 'target' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->target, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to defined_symbol to be a `symbol_target`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<definitional_representation>(const DB& db, const LIST& params, definitional_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to definitional_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<definitional_representation_relationship>(const DB& db, const LIST& params, definitional_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<definitional_representation_relationship_with_same_context>(const DB& db, const LIST& params, definitional_representation_relationship_with_same_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship_with_same_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<degenerate_pcurve>(const DB& db, const LIST& params, degenerate_pcurve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to degenerate_pcurve"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to degenerate_pcurve to be a `surface`")); }
-    } while (0);
-    do { // convert the 'reference_to_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->reference_to_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to degenerate_pcurve to be a `definitional_representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<toroidal_surface>(const DB& db, const LIST& params, toroidal_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to toroidal_surface"); }    do { // convert the 'major_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->major_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to toroidal_surface to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'minor_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->minor_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to toroidal_surface to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<degenerate_toroidal_surface>(const DB& db, const LIST& params, degenerate_toroidal_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<toroidal_surface*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to degenerate_toroidal_surface"); }    do { // convert the 'select_outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->select_outer, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to degenerate_toroidal_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<descriptive_representation_item>(const DB& db, const LIST& params, descriptive_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to descriptive_representation_item"); }    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::descriptive_representation_item, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to descriptive_representation_item to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_context>(const DB& db, const LIST& params, product_definition_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_context"); }    do { // convert the 'life_cycle_stage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_context, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->life_cycle_stage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_context to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<design_context>(const DB& db, const LIST& params, design_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to design_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<design_make_from_relationship>(const DB& db, const LIST& params, design_make_from_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to design_make_from_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<diameter_dimension>(const DB& db, const LIST& params, diameter_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to diameter_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ratio_measure_with_unit>(const DB& db, const LIST& params, ratio_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ratio_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dielectric_constant_measure_with_unit>(const DB& db, const LIST& params, dielectric_constant_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dielectric_constant_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_callout>(const DB& db, const LIST& params, dimension_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_callout_relationship>(const DB& db, const LIST& params, draughting_callout_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draughting_callout_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::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 draughting_callout_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_draughting_callout' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_draughting_callout, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to draughting_callout_relationship to be a `draughting_callout`")); }
-    } while (0);
-    do { // convert the 'related_draughting_callout' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_draughting_callout, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to draughting_callout_relationship to be a `draughting_callout`")); }
-    } while (0);
-    return base;
-}
-
-}
-}
diff --git a/code/AssetLib/StepFile/StepFileGen3.cpp b/code/AssetLib/StepFile/StepFileGen3.cpp
deleted file mode 100644
index b3e34027e..000000000
--- a/code/AssetLib/StepFile/StepFileGen3.cpp
+++ /dev/null
@@ -1,5746 +0,0 @@
-/*
-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 "code/Importer/StepFile/StepReaderGen.h"
-
-namespace Assimp {
-using namespace StepFile;
-namespace STEP {
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_callout_component_relationship>(const DB& db, const LIST& params, dimension_callout_component_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_callout_component_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_callout_relationship>(const DB& db, const LIST& params, dimension_callout_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_callout_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve>(const DB& db, const LIST& params, dimension_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dimension_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<terminator_symbol>(const DB& db, const LIST& params, terminator_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_symbol_occurrence*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to terminator_symbol"); }    do { // convert the 'annotated_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::terminator_symbol, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->annotated_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to terminator_symbol to be a `annotation_curve_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve_terminator>(const DB& db, const LIST& params, dimension_curve_terminator* in)
-{
-    size_t base = GenericFill(db, params, static_cast<terminator_symbol*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to dimension_curve_terminator"); }    do { // convert the 'role' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->role, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to dimension_curve_terminator to be a `dimension_extent_usage`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_curve_terminator_to_projection_curve_associativity>(const DB& db, const LIST& params, dimension_curve_terminator_to_projection_curve_associativity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_occurrence_associativity*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_curve_terminator_to_projection_curve_associativity"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimension_pair>(const DB& db, const LIST& params, dimension_pair* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_pair"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<dimension_text_associativity>(const DB& db, const LIST& params, dimension_text_associativity* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_location_with_path>(const DB& db, const LIST& params, dimensional_location_with_path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimensional_location*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to dimensional_location_with_path"); }    do { // convert the 'path' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->path, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to dimensional_location_with_path to be a `shape_aspect`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dimensional_size_with_path>(const DB& db, const LIST& params, dimensional_size_with_path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimensional_size*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dimensional_size_with_path"); }    do { // convert the 'path' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->path, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dimensional_size_with_path to be a `shape_aspect`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<executed_action>(const DB& db, const LIST& params, executed_action* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to executed_action"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<directed_action>(const DB& db, const LIST& params, directed_action* in)
-{
-    size_t base = GenericFill(db, params, static_cast<executed_action*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to directed_action"); }    do { // convert the 'directive' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->directive, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to directed_action to be a `action_directive`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<directed_dimensional_location>(const DB& db, const LIST& params, directed_dimensional_location* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimensional_location*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to directed_dimensional_location"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<direction>(const DB& db, const LIST& params, direction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to direction"); }    do { // convert the 'direction_ratios' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->direction_ratios, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to direction to be a `LIST [2:3] OF REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<document_file>(const DB& db, const LIST& params, document_file* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_identifier>(const DB& db, const LIST& params, document_identifier* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_identifier"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_identifier_assignment>(const DB& db, const LIST& params, document_identifier_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_identifier_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_identifier_assignment to be a `SET [1:?] OF document_identifier_assigned_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_product_association>(const DB& db, const LIST& params, document_product_association* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to document_product_association"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::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 document_product_association to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::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 document_product_association to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_document' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_document, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to document_product_association to be a `document`")); }
-    } while (0);
-    do { // convert the 'related_product' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_product, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to document_product_association to be a `product_or_formation_or_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<document_product_equivalence>(const DB& db, const LIST& params, document_product_equivalence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<document_product_association*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to document_product_equivalence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dose_equivalent_measure_with_unit>(const DB& db, const LIST& params, dose_equivalent_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dose_equivalent_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<dose_equivalent_unit>(const DB& db, const LIST& params, dose_equivalent_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to dose_equivalent_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<double_offset_shelled_solid>(const DB& db, const LIST& params, double_offset_shelled_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to double_offset_shelled_solid"); }    do { // convert the 'thickness2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->thickness2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to double_offset_shelled_solid to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<item_defined_transformation>(const DB& db, const LIST& params, item_defined_transformation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to item_defined_transformation"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::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 item_defined_transformation to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::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 item_defined_transformation to be a `text`")); }
-    } while (0);
-    do { // convert the 'transform_item_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->transform_item_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to item_defined_transformation to be a `representation_item`")); }
-    } while (0);
-    do { // convert the 'transform_item_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->transform_item_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to item_defined_transformation to be a `representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<transformation_with_derived_angle>(const DB& db, const LIST& params, transformation_with_derived_angle* in)
-{
-    size_t base = GenericFill(db, params, static_cast<item_defined_transformation*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to transformation_with_derived_angle"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draped_defined_transformation>(const DB& db, const LIST& params, draped_defined_transformation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<transformation_with_derived_angle*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draped_defined_transformation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_annotation_occurrence>(const DB& db, const LIST& params, draughting_annotation_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_annotation_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_elements>(const DB& db, const LIST& params, draughting_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to draughting_elements"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_model>(const DB& db, const LIST& params, draughting_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_model"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<item_identified_representation_usage>(const DB& db, const LIST& params, item_identified_representation_usage* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to item_identified_representation_usage"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::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 item_identified_representation_usage to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::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 item_identified_representation_usage to be a `text`")); }
-    } while (0);
-    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to item_identified_representation_usage to be a `represented_definition`")); }
-    } while (0);
-    do { // convert the 'used_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->used_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to item_identified_representation_usage to be a `representation`")); }
-    } while (0);
-    do { // convert the 'identified_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->identified_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to item_identified_representation_usage to be a `representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_model_item_association>(const DB& db, const LIST& params, draughting_model_item_association* in)
-{
-    size_t base = GenericFill(db, params, static_cast<item_identified_representation_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to draughting_model_item_association"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<pre_defined_colour>(const DB& db, const LIST& params, pre_defined_colour* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_pre_defined_colour>(const DB& db, const LIST& params, draughting_pre_defined_colour* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_colour*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_item>(const DB& db, const LIST& params, pre_defined_item* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_item"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::pre_defined_item, 1>::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 pre_defined_item to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_curve_font>(const DB& db, const LIST& params, pre_defined_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_pre_defined_curve_font>(const DB& db, const LIST& params, draughting_pre_defined_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_curve_font*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to draughting_pre_defined_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_text_font>(const DB& db, const LIST& params, pre_defined_text_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_text_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_pre_defined_text_font>(const DB& db, const LIST& params, draughting_pre_defined_text_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_text_font*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to draughting_pre_defined_text_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_subfigure_representation>(const DB& db, const LIST& params, draughting_subfigure_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_subfigure_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_symbol_representation>(const DB& db, const LIST& params, draughting_symbol_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_symbol_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal>(const DB& db, const LIST& params, text_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to text_literal"); }    do { // convert the 'literal' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->literal, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to text_literal to be a `presentable_text`")); }
-    } while (0);
-    do { // convert the 'placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_literal to be a `axis2_placement`")); }
-    } while (0);
-    do { // convert the 'alignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->alignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to text_literal to be a `text_alignment`")); }
-    } while (0);
-    do { // convert the 'path' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->path, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to text_literal to be a `text_path`")); }
-    } while (0);
-    do { // convert the 'font' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->font, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to text_literal to be a `font_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_delineation>(const DB& db, const LIST& params, text_literal_with_delineation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_delineation"); }    do { // convert the 'delineation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal_with_delineation, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->delineation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_delineation to be a `text_delineation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<draughting_text_literal_with_delineation>(const DB& db, const LIST& params, draughting_text_literal_with_delineation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal_with_delineation*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to draughting_text_literal_with_delineation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<presentation_set>(const DB& db, const LIST& params, presentation_set* in)
-{
-    size_t base = 0;
-    return base;
-}*/ 
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_revision>(const DB& db, const LIST& params, drawing_revision* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_set*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to drawing_revision"); }    do { // convert the 'revision_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->revision_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to drawing_revision to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'drawing_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->drawing_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to drawing_revision to be a `drawing_definition`")); }
-    } while (0);
-    do { // convert the 'intended_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->intended_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to drawing_revision to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_representation>(const DB& db, const LIST& params, presentation_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_area>(const DB& db, const LIST& params, presentation_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_area"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_sheet_revision>(const DB& db, const LIST& params, drawing_sheet_revision* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to drawing_sheet_revision"); }    do { // convert the 'revision_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->revision_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to drawing_sheet_revision to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_sheet_revision_sequence>(const DB& db, const LIST& params, drawing_sheet_revision_sequence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to drawing_sheet_revision_sequence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<drawing_sheet_revision_usage>(const DB& db, const LIST& params, drawing_sheet_revision_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<area_in_set*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to drawing_sheet_revision_usage"); }    do { // convert the 'sheet_number' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sheet_number, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to drawing_sheet_revision_usage to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge>(const DB& db, const LIST& params, edge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to edge"); }    do { // convert the 'edge_start' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->edge_start, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge to be a `vertex`")); }
-    } while (0);
-    do { // convert the 'edge_end' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->edge_end, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to edge to be a `vertex`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_based_wireframe_model>(const DB& db, const LIST& params, edge_based_wireframe_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to edge_based_wireframe_model"); }    do { // convert the 'ebwm_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ebwm_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge_based_wireframe_model to be a `SET [1:?] OF connected_edge_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_based_wireframe_shape_representation>(const DB& db, const LIST& params, edge_based_wireframe_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to edge_based_wireframe_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_blended_solid>(const DB& db, const LIST& params, edge_blended_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to edge_blended_solid"); }    do { // convert the 'blended_edges' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge_blended_solid, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->blended_edges, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to edge_blended_solid to be a `LIST [1:?] OF edge_curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<edge_curve>(const DB& db, const LIST& params, edge_curve* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to edge_curve"); }    do { // convert the 'edge_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->edge_geometry, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to edge_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'same_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->same_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge_curve to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<edge_loop>(const DB& db, const LIST& params, edge_loop* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_charge_measure_with_unit>(const DB& db, const LIST& params, electric_charge_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_charge_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_charge_unit>(const DB& db, const LIST& params, electric_charge_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_charge_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_current_measure_with_unit>(const DB& db, const LIST& params, electric_current_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_current_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_current_unit>(const DB& db, const LIST& params, electric_current_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_current_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_potential_measure_with_unit>(const DB& db, const LIST& params, electric_potential_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_potential_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<electric_potential_unit>(const DB& db, const LIST& params, electric_potential_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_potential_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<elementary_brep_shape_representation>(const DB& db, const LIST& params, elementary_brep_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to elementary_brep_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ellipse>(const DB& db, const LIST& params, ellipse* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ellipse"); }    do { // convert the 'semi_axis_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_axis_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to ellipse to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_axis_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_axis_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to ellipse to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<energy_measure_with_unit>(const DB& db, const LIST& params, energy_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to energy_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<energy_unit>(const DB& db, const LIST& params, energy_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to energy_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<property_definition>(const DB& db, const LIST& params, property_definition* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to property_definition"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::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 property_definition to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 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 property_definition to be a `text`")); }
-    } while (0);
-    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to property_definition to be a `characterized_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fact_type>(const DB& db, const LIST& params, fact_type* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to fact_type"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<entity_assertion>(const DB& db, const LIST& params, entity_assertion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<fact_type*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to entity_assertion"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<enum_reference_prefix>(const DB& db, const LIST& params, enum_reference_prefix* in)
-{
-    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to enum_reference_prefix"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<evaluated_characteristic>(const DB& db, const LIST& params, evaluated_characteristic* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<evaluated_degenerate_pcurve>(const DB& db, const LIST& params, evaluated_degenerate_pcurve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<degenerate_pcurve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to evaluated_degenerate_pcurve"); }    do { // convert the 'equivalent_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->equivalent_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to evaluated_degenerate_pcurve to be a `cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<evaluation_product_definition>(const DB& db, const LIST& params, evaluation_product_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to evaluation_product_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<event_occurrence>(const DB& db, const LIST& params, event_occurrence* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to event_occurrence"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[2] = 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 2 to event_occurrence to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_feature_category>(const DB& db, const LIST& params, product_concept_feature_category* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_concept_feature_category"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<exclusive_product_concept_feature_category>(const DB& db, const LIST& params, exclusive_product_concept_feature_category* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_concept_feature_category*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to exclusive_product_concept_feature_category"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uncertainty_qualifier>(const DB& db, const LIST& params, uncertainty_qualifier* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to uncertainty_qualifier"); }    do { // convert the 'measure_name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::uncertainty_qualifier, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->measure_name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to uncertainty_qualifier to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::uncertainty_qualifier, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->description, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to uncertainty_qualifier to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<standard_uncertainty>(const DB& db, const LIST& params, standard_uncertainty* in)
-{
-    size_t base = GenericFill(db, params, static_cast<uncertainty_qualifier*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to standard_uncertainty"); }    do { // convert the 'uncertainty_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::standard_uncertainty, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->uncertainty_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to standard_uncertainty to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<expanded_uncertainty>(const DB& db, const LIST& params, expanded_uncertainty* in)
-{
-    size_t base = GenericFill(db, params, static_cast<standard_uncertainty*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to expanded_uncertainty"); }    do { // convert the 'coverage_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->coverage_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to expanded_uncertainty to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_item_relationship>(const DB& db, const LIST& params, representation_item_relationship* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_item_relationship"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::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 representation_item_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::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 representation_item_relationship to be a `text`")); }
-    } while (0);
-    do { // convert the 'relating_representation_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->relating_representation_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_item_relationship to be a `representation_item`")); }
-    } while (0);
-    do { // convert the 'related_representation_item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->related_representation_item, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_item_relationship to be a `representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_representation_item_relationship>(const DB& db, const LIST& params, explicit_procedural_representation_item_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_representation_item_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_geometric_representation_item_relationship>(const DB& db, const LIST& params, explicit_procedural_geometric_representation_item_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<explicit_procedural_representation_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_geometric_representation_item_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_representation_relationship>(const DB& db, const LIST& params, explicit_procedural_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<explicit_procedural_shape_representation_relationship>(const DB& db, const LIST& params, explicit_procedural_shape_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<explicit_procedural_representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_shape_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<expression_conversion_based_unit>(const DB& db, const LIST& params, expression_conversion_based_unit* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extension>(const DB& db, const LIST& params, extension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extent>(const DB& db, const LIST& params, extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<characterized_object*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to extent"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<external_source>(const DB& db, const LIST& params, external_source* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to external_source"); }    do { // convert the 'source_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_source, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->source_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to external_source to be a `source_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<external_class_library>(const DB& db, const LIST& params, external_class_library* in)
-{
-    size_t base = GenericFill(db, params, static_cast<external_source*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to external_class_library"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_class>(const DB& db, const LIST& params, externally_defined_class* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_colour>(const DB& db, const LIST& params, externally_defined_colour* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_context_dependent_unit>(const DB& db, const LIST& params, externally_defined_context_dependent_unit* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_conversion_based_unit>(const DB& db, const LIST& params, externally_defined_conversion_based_unit* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_currency>(const DB& db, const LIST& params, externally_defined_currency* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_item>(const DB& db, const LIST& params, externally_defined_item* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_item"); }    do { // convert the 'item_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::externally_defined_item, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->item_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to externally_defined_item to be a `source_item`")); }
-    } while (0);
-    do { // convert the 'source' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::externally_defined_item, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->source, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to externally_defined_item to be a `external_source`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_curve_font>(const DB& db, const LIST& params, externally_defined_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_dimension_definition>(const DB& db, const LIST& params, externally_defined_dimension_definition* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_general_property>(const DB& db, const LIST& params, externally_defined_general_property* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_hatch_style>(const DB& db, const LIST& params, externally_defined_hatch_style* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_marker>(const DB& db, const LIST& params, externally_defined_marker* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<picture_representation_item>(const DB& db, const LIST& params, picture_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bytes_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to picture_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_picture_representation_item>(const DB& db, const LIST& params, externally_defined_picture_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<picture_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_picture_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_representation_item>(const DB& db, const LIST& params, externally_defined_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_string>(const DB& db, const LIST& params, externally_defined_string* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_representation_item*>(in));
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_symbol>(const DB& db, const LIST& params, externally_defined_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_terminator_symbol>(const DB& db, const LIST& params, externally_defined_terminator_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_symbol*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_terminator_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_text_font>(const DB& db, const LIST& params, externally_defined_text_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_text_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<externally_defined_tile>(const DB& db, const LIST& params, externally_defined_tile* in)
-{
-    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_tile"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<externally_defined_tile_style>(const DB& db, const LIST& params, externally_defined_tile_style* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_area_solid>(const DB& db, const LIST& params, swept_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_area_solid"); }    do { // convert the 'swept_area' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_area_solid, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->swept_area, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_area_solid to be a `curve_bounded_surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_area_solid>(const DB& db, const LIST& params, extruded_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extruded_area_solid"); }    do { // convert the 'extruded_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extruded_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to extruded_area_solid to be a `direction`")); }
-    } 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 extruded_area_solid to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_face_solid>(const DB& db, const LIST& params, swept_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_face_solid"); }    do { // convert the 'swept_face' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_face_solid, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->swept_face, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_face_solid to be a `face_surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid>(const DB& db, const LIST& params, extruded_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_face_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extruded_face_solid"); }    do { // convert the 'extruded_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->extruded_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to extruded_face_solid to be a `direction`")); }
-    } while (0);
-    do { // convert the 'depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid, 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 extruded_face_solid to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid_with_trim_conditions>(const DB& db, const LIST& params, extruded_face_solid_with_trim_conditions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<extruded_face_solid*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to extruded_face_solid_with_trim_conditions"); }    do { // convert the 'first_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->first_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to extruded_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    do { // convert the 'second_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->second_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to extruded_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    do { // convert the 'first_trim_intent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->first_trim_intent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to extruded_face_solid_with_trim_conditions to be a `trim_intent`")); }
-    } while (0);
-    do { // convert the 'second_trim_intent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->second_trim_intent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to extruded_face_solid_with_trim_conditions to be a `trim_intent`")); }
-    } while (0);
-    do { // convert the 'first_offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[4] = true; break; }
-        try { GenericConvert(in->first_offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to extruded_face_solid_with_trim_conditions to be a `non_negative_length_measure`")); }
-    } while (0);
-    do { // convert the 'second_offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[5] = true; break; }
-        try { GenericConvert(in->second_offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to extruded_face_solid_with_trim_conditions to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid_with_draft_angle>(const DB& db, const LIST& params, extruded_face_solid_with_draft_angle* in)
-{
-    size_t base = GenericFill(db, params, static_cast<extruded_face_solid_with_trim_conditions*>(in));
-    if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to extruded_face_solid_with_draft_angle"); }    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to extruded_face_solid_with_draft_angle to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<extruded_face_solid_with_multiple_draft_angles>(const DB& db, const LIST& params, extruded_face_solid_with_multiple_draft_angles* in)
-{
-    size_t base = GenericFill(db, params, static_cast<extruded_face_solid_with_trim_conditions*>(in));
-    if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to extruded_face_solid_with_multiple_draft_angles"); }    do { // convert the 'draft_angles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to extruded_face_solid_with_multiple_draft_angles to be a `LIST [2:?] OF plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face>(const DB& db, const LIST& params, face* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face"); }    do { // convert the 'bounds' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face, 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 1 to face to be a `SET [1:?] OF face_bound`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_based_surface_model>(const DB& db, const LIST& params, face_based_surface_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face_based_surface_model"); }    do { // convert the 'fbsm_faces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fbsm_faces, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_based_surface_model to be a `SET [1:?] OF connected_face_set`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_bound>(const DB& db, const LIST& params, face_bound* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to face_bound"); }    do { // convert the 'bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_bound, 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 1 to face_bound to be a `loop`")); }
-    } while (0);
-    do { // convert the 'orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_bound, 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 2 to face_bound to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<face_outer_bound>(const DB& db, const LIST& params, face_outer_bound* in)
-{
-    size_t base = GenericFill(db, params, static_cast<face_bound*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to face_outer_bound"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<faceted_brep>(const DB& db, const LIST& params, faceted_brep* in)
-{
-    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to faceted_brep"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<faceted_brep_shape_representation>(const DB& db, const LIST& params, faceted_brep_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to faceted_brep_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style>(const DB& db, const LIST& params, fill_area_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style"); }    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 0 to fill_area_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'fill_styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fill_styles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style to be a `SET [1:?] OF fill_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_hatching>(const DB& db, const LIST& params, fill_area_style_hatching* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to fill_area_style_hatching"); }    do { // convert the 'hatch_line_appearance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->hatch_line_appearance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_hatching to be a `curve_style`")); }
-    } while (0);
-    do { // convert the 'start_of_next_hatch_line' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->start_of_next_hatch_line, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_hatching to be a `one_direction_repeat_factor`")); }
-    } while (0);
-    do { // convert the 'point_of_reference_hatch_line' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_of_reference_hatch_line, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to fill_area_style_hatching to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'pattern_start' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pattern_start, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to fill_area_style_hatching to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'hatch_line_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->hatch_line_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to fill_area_style_hatching to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tile_coloured_region>(const DB& db, const LIST& params, fill_area_style_tile_coloured_region* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to fill_area_style_tile_coloured_region"); }    do { // convert the 'closed_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->closed_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_coloured_region to be a `curve_or_annotation_curve_occurrence`")); }
-    } while (0);
-    do { // convert the 'region_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->region_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_tile_coloured_region to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tile_curve_with_style>(const DB& db, const LIST& params, fill_area_style_tile_curve_with_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style_tile_curve_with_style"); }    do { // convert the 'styled_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->styled_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_curve_with_style to be a `annotation_curve_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tile_symbol_with_style>(const DB& db, const LIST& params, fill_area_style_tile_symbol_with_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style_tile_symbol_with_style"); }    do { // convert the 'symbol' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->symbol, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_symbol_with_style to be a `annotation_symbol_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<fill_area_style_tiles>(const DB& db, const LIST& params, fill_area_style_tiles* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to fill_area_style_tiles"); }    do { // convert the 'tiling_pattern' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tiling_pattern, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tiles to be a `two_direction_repeat_factor`")); }
-    } while (0);
-    do { // convert the 'tiles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tiles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_tiles to be a `SET [1:?] OF fill_area_style_tile_shape_select`")); }
-    } while (0);
-    do { // convert the 'tiling_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tiling_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to fill_area_style_tiles to be a `positive_ratio_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_representation_relationship>(const DB& db, const LIST& params, shape_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<flat_pattern_ply_representation_relationship>(const DB& db, const LIST& params, flat_pattern_ply_representation_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to flat_pattern_ply_representation_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<flatness_tolerance>(const DB& db, const LIST& params, flatness_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to flatness_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<force_measure_with_unit>(const DB& db, const LIST& params, force_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to force_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<force_unit>(const DB& db, const LIST& params, force_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to force_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<forward_chaining_rule>(const DB& db, const LIST& params, forward_chaining_rule* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to forward_chaining_rule"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<forward_chaining_rule_premise>(const DB& db, const LIST& params, forward_chaining_rule_premise* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<frequency_measure_with_unit>(const DB& db, const LIST& params, frequency_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to frequency_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<frequency_unit>(const DB& db, const LIST& params, frequency_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to frequency_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<func>(const DB& db, const LIST& params, func* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to func"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<functional_breakdown_context>(const DB& db, const LIST& params, functional_breakdown_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_context*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to functional_breakdown_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<functional_element_usage>(const DB& db, const LIST& params, functional_element_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_element_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to functional_element_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<general_material_property>(const DB& db, const LIST& params, general_material_property* in)
-{
-    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_material_property"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_generic_expression>(const DB& db, const LIST& params, simple_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_literal>(const DB& db, const LIST& params, generic_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<generic_variable>(const DB& db, const LIST& params, generic_variable* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_generic_expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_alignment>(const DB& db, const LIST& params, geometric_alignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_alignment"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_set>(const DB& db, const LIST& params, geometric_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometric_set"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_set, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->elements, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to geometric_set to be a `SET [1:?] OF geometric_set_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_curve_set>(const DB& db, const LIST& params, geometric_curve_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_set*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometric_curve_set"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_intersection>(const DB& db, const LIST& params, geometric_intersection* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_intersection"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_item_specific_usage>(const DB& db, const LIST& params, geometric_item_specific_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<item_identified_representation_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_item_specific_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<geometric_model_element_relationship>(const DB& db, const LIST& params, geometric_model_element_relationship* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_context>(const DB& db, const LIST& params, representation_context* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_context"); }    do { // convert the 'context_identifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_context, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->context_identifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_context to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'context_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_context, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->context_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_context to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_representation_context>(const DB& db, const LIST& params, geometric_representation_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometric_representation_context"); }    do { // convert the 'coordinate_space_dimension' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->coordinate_space_dimension, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to geometric_representation_context to be a `dimension_count`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometric_tolerance_with_defined_unit>(const DB& db, const LIST& params, geometric_tolerance_with_defined_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_tolerance_with_defined_unit"); }    do { // convert the 'unit_size' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->unit_size, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to geometric_tolerance_with_defined_unit to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrical_tolerance_callout>(const DB& db, const LIST& params, geometrical_tolerance_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometrical_tolerance_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrically_bounded_2d_wireframe_representation>(const DB& db, const LIST& params, geometrically_bounded_2d_wireframe_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_2d_wireframe_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrically_bounded_surface_shape_representation>(const DB& db, const LIST& params, geometrically_bounded_surface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_surface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<geometrically_bounded_wireframe_shape_representation>(const DB& db, const LIST& params, geometrically_bounded_wireframe_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_wireframe_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<global_assignment>(const DB& db, const LIST& params, global_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to global_assignment"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<global_uncertainty_assigned_context>(const DB& db, const LIST& params, global_uncertainty_assigned_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to global_uncertainty_assigned_context"); }    do { // convert the 'uncertainty' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->uncertainty, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to global_uncertainty_assigned_context to be a `SET [1:?] OF uncertainty_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<global_unit_assigned_context>(const DB& db, const LIST& params, global_unit_assigned_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to global_unit_assigned_context"); }    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 2 to global_unit_assigned_context to be a `SET [1:?] OF unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ground_fact>(const DB& db, const LIST& params, ground_fact* in)
-{
-    size_t base = GenericFill(db, params, static_cast<atomic_formula*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ground_fact"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<hardness_representation>(const DB& db, const LIST& params, hardness_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to hardness_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<hidden_element_over_riding_styled_item>(const DB& db, const LIST& params, hidden_element_over_riding_styled_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<context_dependent_over_riding_styled_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to hidden_element_over_riding_styled_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<hyperbola>(const DB& db, const LIST& params, hyperbola* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to hyperbola"); }    do { // convert the 'semi_axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to hyperbola to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_imag_axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_imag_axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to hyperbola to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<illuminance_measure_with_unit>(const DB& db, const LIST& params, illuminance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to illuminance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<illuminance_unit>(const DB& db, const LIST& params, illuminance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to illuminance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<included_text_block>(const DB& db, const LIST& params, included_text_block* in)
-{
-    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to included_text_block"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<inclusion_product_concept_feature>(const DB& db, const LIST& params, inclusion_product_concept_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conditional_concept_feature*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to inclusion_product_concept_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_selected_elements>(const DB& db, const LIST& params, user_selected_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to user_selected_elements"); }    do { // convert the 'picked_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::user_selected_elements, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->picked_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to user_selected_elements to be a `SET [1:?] OF representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<indirectly_selected_elements>(const DB& db, const LIST& params, indirectly_selected_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<user_selected_elements*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to indirectly_selected_elements"); }    do { // convert the 'indirectly_picked_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->indirectly_picked_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to indirectly_selected_elements to be a `SET [1:?] OF representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<indirectly_selected_shape_elements>(const DB& db, const LIST& params, indirectly_selected_shape_elements* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<inductance_measure_with_unit>(const DB& db, const LIST& params, inductance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to inductance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<inductance_unit>(const DB& db, const LIST& params, inductance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to inductance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<information_right>(const DB& db, const LIST& params, information_right* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to information_right"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<information_usage_right>(const DB& db, const LIST& params, information_usage_right* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to information_usage_right"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<instance_usage_context_assignment>(const DB& db, const LIST& params, instance_usage_context_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to instance_usage_context_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to instance_usage_context_assignment to be a `SET [1:?] OF instance_usage_context_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<instanced_feature>(const DB& db, const LIST& params, instanced_feature* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<literal_number>(const DB& db, const LIST& params, literal_number* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to literal_number"); }    do { // convert the 'the_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::literal_number, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->the_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to literal_number to be a `NUMBER`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<int_literal>(const DB& db, const LIST& params, int_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<literal_number*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to int_literal"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<integer_representation_item>(const DB& db, const LIST& params, integer_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_curve>(const DB& db, const LIST& params, surface_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to surface_curve"); }    do { // convert the 'curve_3d' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->curve_3d, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'associated_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->associated_geometry, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_curve to be a `LIST [1:2] OF pcurve_or_surface`")); }
-    } while (0);
-    do { // convert the 'master_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->master_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_curve to be a `preferred_surface_curve_representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<intersection_curve>(const DB& db, const LIST& params, intersection_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to intersection_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<interval_expression>(const DB& db, const LIST& params, interval_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<iso4217_currency>(const DB& db, const LIST& params, iso4217_currency* in)
-{
-    size_t base = GenericFill(db, params, static_cast<currency*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to iso4217_currency"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<known_source>(const DB& db, const LIST& params, known_source* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<laid_defined_transformation>(const DB& db, const LIST& params, laid_defined_transformation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<transformation_with_derived_angle*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laid_defined_transformation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<language>(const DB& db, const LIST& params, language* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to language"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_curve>(const DB& db, const LIST& params, leader_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to leader_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_directed_callout>(const DB& db, const LIST& params, leader_directed_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to leader_directed_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_directed_dimension>(const DB& db, const LIST& params, leader_directed_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<leader_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to leader_directed_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<leader_terminator>(const DB& db, const LIST& params, leader_terminator* in)
-{
-    size_t base = GenericFill(db, params, static_cast<terminator_symbol*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to leader_terminator"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<length_measure_with_unit>(const DB& db, const LIST& params, length_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to length_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<length_unit>(const DB& db, const LIST& params, length_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to length_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source>(const DB& db, const LIST& params, light_source* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to light_source"); }    do { // convert the 'light_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::light_source, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->light_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to light_source to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_ambient>(const DB& db, const LIST& params, light_source_ambient* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to light_source_ambient"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_directional>(const DB& db, const LIST& params, light_source_directional* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to light_source_directional"); }    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 2 to light_source_directional to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_positional>(const DB& db, const LIST& params, light_source_positional* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to light_source_positional"); }    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 light_source_positional to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'constant_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->constant_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to light_source_positional to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'distance_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to light_source_positional to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<light_source_spot>(const DB& db, const LIST& params, light_source_spot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to light_source_spot"); }    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 light_source_spot to be a `cartesian_point`")); }
-    } while (0);
-    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 3 to light_source_spot to be a `direction`")); }
-    } while (0);
-    do { // convert the 'concentration_exponent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->concentration_exponent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to light_source_spot to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'constant_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->constant_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to light_source_spot to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'distance_attenuation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance_attenuation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to light_source_spot to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'spread_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->spread_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to light_source_spot to be a `positive_plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<line>(const DB& db, const LIST& params, line* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to line"); }    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 1 to line to be a `cartesian_point`")); }
-    } 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 2 to line to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<line_profile_tolerance>(const DB& db, const LIST& params, line_profile_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to line_profile_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<linear_dimension>(const DB& db, const LIST& params, linear_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to linear_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_clause>(const DB& db, const LIST& params, simple_clause* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to simple_clause"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<literal_conjunction>(const DB& db, const LIST& params, literal_conjunction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to literal_conjunction"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<literal_disjunction>(const DB& db, const LIST& params, literal_disjunction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<simple_clause*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to literal_disjunction"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<logical_literal>(const DB& db, const LIST& params, logical_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_literal*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to logical_literal"); }    do { // convert the 'lit_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->lit_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to logical_literal to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<logical_representation_item>(const DB&, const LIST& params, logical_representation_item* )
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<loop>(const DB& db, const LIST& params, loop* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to loop"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<loss_tangent_measure_with_unit>(const DB& db, const LIST& params, loss_tangent_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to loss_tangent_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<lot_effectivity>(const DB& db, const LIST& params, lot_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to lot_effectivity"); }    do { // convert the 'effectivity_lot_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_lot_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to lot_effectivity to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'effectivity_lot_size' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_lot_size, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to lot_effectivity to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_flux_measure_with_unit>(const DB& db, const LIST& params, luminous_flux_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to luminous_flux_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_flux_unit>(const DB& db, const LIST& params, luminous_flux_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to luminous_flux_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_intensity_measure_with_unit>(const DB& db, const LIST& params, luminous_intensity_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to luminous_intensity_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<luminous_intensity_unit>(const DB& db, const LIST& params, luminous_intensity_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to luminous_intensity_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_density_measure_with_unit>(const DB& db, const LIST& params, magnetic_flux_density_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to magnetic_flux_density_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_density_unit>(const DB& db, const LIST& params, magnetic_flux_density_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to magnetic_flux_density_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_measure_with_unit>(const DB& db, const LIST& params, magnetic_flux_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to magnetic_flux_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<magnetic_flux_unit>(const DB& db, const LIST& params, magnetic_flux_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to magnetic_flux_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<make_from_usage_option>(const DB& db, const LIST& params, make_from_usage_option* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to make_from_usage_option"); }    do { // convert the 'ranking' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ranking, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to make_from_usage_option to be a `INTEGER`")); }
-    } while (0);
-    do { // convert the 'ranking_rationale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ranking_rationale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to make_from_usage_option to be a `text`")); }
-    } while (0);
-    do { // convert the 'quantity' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->quantity, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to make_from_usage_option to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<manifold_subsurface_shape_representation>(const DB& db, const LIST& params, manifold_subsurface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to manifold_subsurface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<manifold_surface_shape_representation>(const DB& db, const LIST& params, manifold_surface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to manifold_surface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mass_measure_with_unit>(const DB& db, const LIST& params, mass_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to mass_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mass_unit>(const DB& db, const LIST& params, mass_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to mass_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<material_property>(const DB& db, const LIST& params, material_property* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to material_property"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<property_definition_representation>(const DB& db, const LIST& params, property_definition_representation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to property_definition_representation"); }    do { // convert the 'definition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition_representation, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->definition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to property_definition_representation to be a `represented_definition`")); }
-    } while (0);
-    do { // convert the 'used_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition_representation, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->used_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to property_definition_representation to be a `representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<material_property_representation>(const DB& db, const LIST& params, material_property_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to material_property_representation"); }    do { // convert the 'dependent_environment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->dependent_environment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to material_property_representation to be a `data_environment`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<measure_representation_item>(const DB& db, const LIST& params, measure_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_context>(const DB& db, const LIST& params, product_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_context"); }    do { // convert the 'discipline_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_context, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->discipline_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_context to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_context>(const DB& db, const LIST& params, mechanical_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_context*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_and_draughting_relationship>(const DB& db, const LIST& params, mechanical_design_and_draughting_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship_with_same_context*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to mechanical_design_and_draughting_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_geometric_presentation_area>(const DB& db, const LIST& params, mechanical_design_geometric_presentation_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_geometric_presentation_area"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_geometric_presentation_representation>(const DB& db, const LIST& params, mechanical_design_geometric_presentation_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_geometric_presentation_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_presentation_representation_with_draughting>(const DB& db, const LIST& params, mechanical_design_presentation_representation_with_draughting* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_presentation_representation_with_draughting"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_shaded_presentation_area>(const DB& db, const LIST& params, mechanical_design_shaded_presentation_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_shaded_presentation_area"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<mechanical_design_shaded_presentation_representation>(const DB& db, const LIST& params, mechanical_design_shaded_presentation_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_shaded_presentation_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<min_and_major_ply_orientation_basis>(const DB& db, const LIST& params, min_and_major_ply_orientation_basis* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<modified_geometric_tolerance>(const DB& db, const LIST& params, modified_geometric_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to modified_geometric_tolerance"); }    do { // convert the 'modifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->modifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to modified_geometric_tolerance to be a `limit_condition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<modified_solid_with_placed_configuration>(const DB& db, const LIST& params, modified_solid_with_placed_configuration* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to modified_solid_with_placed_configuration"); }    do { // convert the 'placing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid_with_placed_configuration, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->placing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to modified_solid_with_placed_configuration to be a `axis2_placement_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<moments_of_inertia_representation>(const DB& db, const LIST& params, moments_of_inertia_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to moments_of_inertia_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<multi_language_attribute_assignment>(const DB& db, const LIST& params, multi_language_attribute_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<attribute_value_assignment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to multi_language_attribute_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to multi_language_attribute_assignment to be a `SET [1:?] OF multi_language_attribute_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<multiple_arity_boolean_expression>(const DB& db, const LIST& params, multiple_arity_boolean_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<multiple_arity_generic_expression>(const DB& db, const LIST& params, multiple_arity_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to multiple_arity_generic_expression"); }    do { // convert the 'operands' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operands, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to multiple_arity_generic_expression to be a `LIST [2:?] OF generic_expression`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<multiple_arity_numeric_expression>(const DB& db, const LIST& params, multiple_arity_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<next_assembly_usage_occurrence>(const DB& db, const LIST& params, next_assembly_usage_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to next_assembly_usage_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<non_manifold_surface_shape_representation>(const DB& db, const LIST& params, non_manifold_surface_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to non_manifold_surface_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<null_representation_item>(const DB& db, const LIST& params, null_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to null_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<numeric_expression>(const DB& db, const LIST& params, numeric_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<expression*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<offset_curve_2d>(const DB& db, const LIST& params, offset_curve_2d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to offset_curve_2d"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_curve_2d to be a `curve`")); }
-    } while (0);
-    do { // convert the 'distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_curve_2d to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_curve_2d to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<offset_curve_3d>(const DB& db, const LIST& params, offset_curve_3d* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to offset_curve_3d"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_curve_3d to be a `curve`")); }
-    } while (0);
-    do { // convert the 'distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_curve_3d to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_curve_3d to be a `LOGICAL`")); }
-    } while (0);
-    do { // convert the 'ref_direction' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ref_direction, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to offset_curve_3d to be a `direction`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<offset_surface>(const DB& db, const LIST& params, offset_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to offset_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_surface to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'self_intersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->self_intersect, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_surface to be a `LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<one_direction_repeat_factor>(const DB& db, const LIST& params, one_direction_repeat_factor* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to one_direction_repeat_factor"); }    do { // convert the 'repeat_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::one_direction_repeat_factor, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->repeat_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to one_direction_repeat_factor to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<open_shell>(const DB& db, const LIST& params, open_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to open_shell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ordinal_date>(const DB& db, const LIST& params, ordinal_date* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ordinal_date"); }    do { // convert the 'day_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->day_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to ordinal_date to be a `day_in_year_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<projection_directed_callout>(const DB& db, const LIST& params, projection_directed_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to projection_directed_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ordinate_dimension>(const DB& db, const LIST& params, ordinate_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<projection_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ordinate_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<organizational_address>(const DB& db, const LIST& params, organizational_address* in)
-{
-    size_t base = GenericFill(db, params, static_cast<address*>(in));
-    if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to organizational_address"); }    do { // convert the 'organizations' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->organizations, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to organizational_address to be a `SET [1:?] OF organization`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        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 13 to organizational_address to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_closed_shell>(const DB& db, const LIST& params, oriented_closed_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<closed_shell*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_closed_shell"); }    do { // convert the 'closed_shell_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->closed_shell_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_closed_shell to be a `closed_shell`")); }
-    } while (0);
-    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 3 to oriented_closed_shell to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_edge>(const DB& db, const LIST& params, oriented_edge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to oriented_edge"); }    do { // convert the 'edge_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->edge_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_edge to be a `edge`")); }
-    } while (0);
-    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 4 to oriented_edge to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_face>(const DB& db, const LIST& params, oriented_face* in)
-{
-    size_t base = GenericFill(db, params, static_cast<face*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_face"); }    do { // convert the 'face_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->face_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_face to be a `face`")); }
-    } while (0);
-    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 3 to oriented_face to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_open_shell>(const DB& db, const LIST& params, oriented_open_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<open_shell*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_open_shell"); }    do { // convert the 'open_shell_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->open_shell_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_open_shell to be a `open_shell`")); }
-    } while (0);
-    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 3 to oriented_open_shell to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<path>(const DB& db, const LIST& params, path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to path"); }    do { // convert the 'edge_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::path, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->edge_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to path to be a `LIST [1:?] OF oriented_edge`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_path>(const DB& db, const LIST& params, oriented_path* in)
-{
-    size_t base = GenericFill(db, params, static_cast<path*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_path"); }    do { // convert the 'path_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->path_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_path to be a `path`")); }
-    } while (0);
-    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 3 to oriented_path to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<oriented_surface>(const DB& db, const LIST& params, oriented_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to oriented_surface"); }    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 1 to oriented_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<outer_boundary_curve>(const DB& db, const LIST& params, outer_boundary_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<boundary_curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to outer_boundary_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<package_product_concept_feature>(const DB& db, const LIST& params, package_product_concept_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to package_product_concept_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parabola>(const DB& db, const LIST& params, parabola* in)
-{
-    size_t base = GenericFill(db, params, static_cast<conic*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to parabola"); }    do { // convert the 'focal_dist' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->focal_dist, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to parabola to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parallel_offset>(const DB& db, const LIST& params, parallel_offset* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to parallel_offset"); }    do { // convert the 'offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to parallel_offset to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parallelism_tolerance>(const DB& db, const LIST& params, parallelism_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to parallelism_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<parametric_representation_context>(const DB& db, const LIST& params, parametric_representation_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to parametric_representation_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<partial_document_with_structured_text_representation_assignment>(const DB& db, const LIST& params, partial_document_with_structured_text_representation_assignment* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pcurve>(const DB& db, const LIST& params, pcurve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<curve*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to pcurve"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to pcurve to be a `surface`")); }
-    } while (0);
-    do { // convert the 'reference_to_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->reference_to_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to pcurve to be a `definitional_representation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<percentage_laminate_definition>(const DB& db, const LIST& params, percentage_laminate_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_laminate_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<zone_structural_makeup>(const DB& db, const LIST& params, zone_structural_makeup* in)
-{
-    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to zone_structural_makeup"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<percentage_laminate_table>(const DB& db, const LIST& params, percentage_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<percentage_ply_definition>(const DB& db, const LIST& params, percentage_ply_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_ply_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<perpendicular_to>(const DB& db, const LIST& params, perpendicular_to* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to perpendicular_to"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<perpendicularity_tolerance>(const DB& db, const LIST& params, perpendicularity_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to perpendicularity_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<person_and_organization_address>(const DB& db, const LIST& params, person_and_organization_address* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<personal_address>(const DB& db, const LIST& params, personal_address* in)
-{
-    size_t base = GenericFill(db, params, static_cast<address*>(in));
-    if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to personal_address"); }    do { // convert the 'people' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->people, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to personal_address to be a `SET [1:?] OF person`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        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 13 to personal_address to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<physical_breakdown_context>(const DB& db, const LIST& params, physical_breakdown_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_context*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to physical_breakdown_context"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<physical_element_usage>(const DB& db, const LIST& params, physical_element_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<breakdown_element_usage*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to physical_element_usage"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_view>(const DB& db, const LIST& params, presentation_view* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_view"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<picture_representation>(const DB& db, const LIST& params, picture_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_view*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to picture_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<placed_datum_target_feature>(const DB& db, const LIST& params, placed_datum_target_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<datum_target*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to placed_datum_target_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<placed_feature>(const DB& db, const LIST& params, placed_feature* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to placed_feature"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<planar_extent>(const DB& db, const LIST& params, planar_extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to planar_extent"); }    do { // convert the 'size_in_x' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::planar_extent, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->size_in_x, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to planar_extent to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'size_in_y' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::planar_extent, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->size_in_y, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to planar_extent to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<planar_box>(const DB& db, const LIST& params, planar_box* in)
-{
-    size_t base = GenericFill(db, params, static_cast<planar_extent*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to planar_box"); }    do { // convert the 'placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to planar_box to be a `axis2_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<plane>(const DB& db, const LIST& params, plane* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to plane"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<plane_angle_measure_with_unit>(const DB& db, const LIST& params, plane_angle_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to plane_angle_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<plane_angle_unit>(const DB& db, const LIST& params, plane_angle_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to plane_angle_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ply_laminate_definition>(const DB& db, const LIST& params, ply_laminate_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ply_laminate_sequence_definition>(const DB& db, const LIST& params, ply_laminate_sequence_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_sequence_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ply_laminate_table>(const DB& db, const LIST& params, ply_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<point_and_vector>(const DB& db, const LIST& params, point_and_vector* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_on_curve>(const DB& db, const LIST& params, point_on_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to point_on_curve"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_on_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'point_parameter' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_parameter, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_on_curve to be a `parameter_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_on_surface>(const DB& db, const LIST& params, point_on_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to point_on_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_on_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'point_parameter_u' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_parameter_u, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_on_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'point_parameter_v' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_parameter_v, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to point_on_surface to be a `parameter_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<point_path>(const DB& db, const LIST& params, point_path* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_replica>(const DB& db, const LIST& params, point_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<point*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to point_replica"); }    do { // convert the 'parent_pt' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_pt, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_replica to be a `point`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_replica to be a `cartesian_transformation_operator`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<point_style>(const DB& db, const LIST& params, point_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to point_style"); }    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 0 to point_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'marker' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->marker, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_style to be a `marker_select`")); }
-    } while (0);
-    do { // convert the 'marker_size' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->marker_size, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_style to be a `size_select`")); }
-    } while (0);
-    do { // convert the 'marker_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->marker_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to point_style to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<polar_complex_number_literal>(const DB& db, const LIST& params, polar_complex_number_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_literal*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to polar_complex_number_literal"); }    do { // convert the 'radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::polar_complex_number_literal, 2>::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 0 to polar_complex_number_literal to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::polar_complex_number_literal, 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 1 to polar_complex_number_literal to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<poly_loop>(const DB& db, const LIST& params, poly_loop* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to poly_loop"); }    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 poly_loop to be a `LIST [3:?] OF cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<polyline>(const DB& db, const LIST& params, polyline* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to polyline"); }    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 1 to polyline to be a `LIST [2:?] OF cartesian_point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<position_tolerance>(const DB& db, const LIST& params, position_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to position_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<positioned_sketch>(const DB& db, const LIST& params, positioned_sketch* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to positioned_sketch"); }    do { // convert the 'sketch_basis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sketch_basis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to positioned_sketch to be a `sketch_basis_select`")); }
-    } while (0);
-    do { // convert the 'auxiliary_elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->auxiliary_elements, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to positioned_sketch to be a `SET [0:?] OF auxiliary_geometric_representation_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<power_measure_with_unit>(const DB& db, const LIST& params, power_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to power_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<power_unit>(const DB& db, const LIST& params, power_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to power_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_symbol>(const DB& db, const LIST& params, pre_defined_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_dimension_symbol>(const DB& db, const LIST& params, pre_defined_dimension_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_dimension_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_geometrical_tolerance_symbol>(const DB& db, const LIST& params, pre_defined_geometrical_tolerance_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_geometrical_tolerance_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_marker>(const DB& db, const LIST& params, pre_defined_marker* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_marker"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<pre_defined_point_marker_symbol>(const DB& db, const LIST& params, pre_defined_point_marker_symbol* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_surface_condition_symbol>(const DB& db, const LIST& params, pre_defined_surface_condition_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_surface_condition_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_surface_side_style>(const DB& db, const LIST& params, pre_defined_surface_side_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_surface_side_style"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_terminator_symbol>(const DB& db, const LIST& params, pre_defined_terminator_symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_terminator_symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pre_defined_tile>(const DB& db, const LIST& params, pre_defined_tile* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_tile"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<predefined_picture_representation_item>(const DB& db, const LIST& params, predefined_picture_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<picture_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to predefined_picture_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_style_assignment>(const DB& db, const LIST& params, presentation_style_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to presentation_style_assignment"); }    do { // convert the 'styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::presentation_style_assignment, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->styles, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to presentation_style_assignment to be a `SET [1:?] OF presentation_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<presentation_style_by_context>(const DB& db, const LIST& params, presentation_style_by_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<presentation_style_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to presentation_style_by_context"); }    do { // convert the 'style_context' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_context, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to presentation_style_by_context to be a `style_context_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pressure_measure_with_unit>(const DB& db, const LIST& params, pressure_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to pressure_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<pressure_unit>(const DB& db, const LIST& params, pressure_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pressure_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_representation>(const DB& db, const LIST& params, procedural_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to procedural_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_representation_sequence>(const DB& db, const LIST& params, procedural_representation_sequence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to procedural_representation_sequence"); }    do { // convert the 'elements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->elements, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to procedural_representation_sequence to be a `LIST [1:?] OF representation_item`")); }
-    } while (0);
-    do { // convert the 'suppressed_items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->suppressed_items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to procedural_representation_sequence to be a `SET [0:?] OF representation_item`")); }
-    } while (0);
-    do { // convert the 'rationale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->rationale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to procedural_representation_sequence to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<procedural_shape_representation>(const DB& db, const LIST& params, procedural_shape_representation* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<procedural_shape_representation_sequence>(const DB& db, const LIST& params, procedural_shape_representation_sequence* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_category>(const DB& db, const LIST& params, product_category* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_category"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_category, 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 product_category to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_category, 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 product_category to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<product_class>(const DB& db, const LIST& params, product_class* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_context>(const DB& db, const LIST& params, product_concept_context* in)
-{
-    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_context"); }    do { // convert the 'market_segment_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->market_segment_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_concept_context to be a `label`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_concept_feature_category_usage>(const DB& db, const LIST& params, product_concept_feature_category_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_concept_feature_category_usage"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature_category_usage to be a `SET [1:?] OF category_usage_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_element_relationship>(const DB& db, const LIST& params, product_definition_element_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_element_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_formation>(const DB& db, const LIST& params, product_definition_formation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_formation"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_formation to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 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 product_definition_formation to be a `text`")); }
-    } while (0);
-    do { // convert the 'of_product' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->of_product, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_formation to be a `product`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_formation_with_specified_source>(const DB& db, const LIST& params, product_definition_formation_with_specified_source* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_formation*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition_formation_with_specified_source"); }    do { // convert the 'make_or_buy' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->make_or_buy, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_formation_with_specified_source to be a `source`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_group_assignment>(const DB& db, const LIST& params, product_definition_group_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_group_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_group_assignment to be a `SET [1:1] OF product_definition_or_product_definition_relationship`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_shape>(const DB& db, const LIST& params, product_definition_shape* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_shape"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_definition_with_associated_documents>(const DB& db, const LIST& params, product_definition_with_associated_documents* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_with_associated_documents"); }    do { // convert the 'documentation_ids' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->documentation_ids, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_with_associated_documents to be a `SET [1:?] OF document`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<product_identification>(const DB& db, const LIST& params, product_identification* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_material_composition_relationship>(const DB& db, const LIST& params, product_material_composition_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to product_material_composition_relationship"); }    do { // convert the 'class' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->class_, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to product_material_composition_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'constituent_amount' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->constituent_amount, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to product_material_composition_relationship to be a `SET [1:?] OF characterized_product_composition_value`")); }
-    } while (0);
-    do { // convert the 'composition_basis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->composition_basis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to product_material_composition_relationship to be a `label`")); }
-    } while (0);
-    do { // convert the 'determination_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->determination_method, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to product_material_composition_relationship to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<product_related_product_category>(const DB& db, const LIST& params, product_related_product_category* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_category*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_related_product_category"); }    do { // convert the 'products' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->products, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_related_product_category to be a `SET [1:?] OF product`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<product_specification>(const DB& db, const LIST& params, product_specification* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tolerance_zone_definition>(const DB& db, const LIST& params, tolerance_zone_definition* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tolerance_zone_definition"); }    do { // convert the 'zone' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::tolerance_zone_definition, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->zone, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to tolerance_zone_definition to be a `tolerance_zone`")); }
-    } while (0);
-    do { // convert the 'boundaries' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::tolerance_zone_definition, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->boundaries, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to tolerance_zone_definition to be a `SET [1:?] OF shape_aspect`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<projected_zone_definition>(const DB& db, const LIST& params, projected_zone_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<tolerance_zone_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to projected_zone_definition"); }    do { // convert the 'projection_end' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projection_end, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to projected_zone_definition to be a `shape_aspect`")); }
-    } while (0);
-    do { // convert the 'projected_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projected_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to projected_zone_definition to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<projection_curve>(const DB& db, const LIST& params, projection_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to projection_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<promissory_usage_occurrence>(const DB& db, const LIST& params, promissory_usage_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to promissory_usage_occurrence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<qualified_representation_item>(const DB& db, const LIST& params, qualified_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to qualified_representation_item"); }    do { // convert the 'qualifiers' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->qualifiers, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to qualified_representation_item to be a `SET [1:?] OF value_qualifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<qualitative_uncertainty>(const DB& db, const LIST& params, qualitative_uncertainty* in)
-{
-    size_t base = GenericFill(db, params, static_cast<uncertainty_qualifier*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to qualitative_uncertainty"); }    do { // convert the 'uncertainty_value' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->uncertainty_value, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to qualitative_uncertainty to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<quantified_assembly_component_usage>(const DB& db, const LIST& params, quantified_assembly_component_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to quantified_assembly_component_usage"); }    do { // convert the 'quantity' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->quantity, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to quantified_assembly_component_usage to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<quasi_uniform_curve>(const DB& db, const LIST& params, quasi_uniform_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to quasi_uniform_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<quasi_uniform_surface>(const DB& db, const LIST& params, quasi_uniform_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to quasi_uniform_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<radioactivity_measure_with_unit>(const DB& db, const LIST& params, radioactivity_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to radioactivity_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<radioactivity_unit>(const DB& db, const LIST& params, radioactivity_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to radioactivity_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<radius_dimension>(const DB& db, const LIST& params, radius_dimension* in)
-{
-    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to radius_dimension"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<range_characteristic>(const DB& db, const LIST& params, range_characteristic* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ratio_unit>(const DB& db, const LIST& params, ratio_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to ratio_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rational_b_spline_curve>(const DB& db, const LIST& params, rational_b_spline_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to rational_b_spline_curve"); }    do { // convert the 'weights_data' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->weights_data, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to rational_b_spline_curve to be a `LIST [2:?] OF REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rational_b_spline_surface>(const DB& db, const LIST& params, rational_b_spline_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to rational_b_spline_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<rational_representation_item>(const DB& db, const LIST& params, rational_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<real_literal>(const DB& db, const LIST& params, real_literal* in)
-{
-    size_t base = GenericFill(db, params, static_cast<literal_number*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to real_literal"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<real_representation_item>(const DB& db, const LIST& params, real_representation_item* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rectangular_composite_surface>(const DB& db, const LIST& params, rectangular_composite_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to rectangular_composite_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rectangular_trimmed_surface>(const DB& db, const LIST& params, rectangular_trimmed_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to rectangular_trimmed_surface"); }    do { // convert the 'basis_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to rectangular_trimmed_surface to be a `surface`")); }
-    } while (0);
-    do { // convert the 'u1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'u2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'v1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'v2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to rectangular_trimmed_surface to be a `parameter_value`")); }
-    } while (0);
-    do { // convert the 'usense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->usense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to rectangular_trimmed_surface to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'vsense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->vsense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to rectangular_trimmed_surface to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<referenced_modified_datum>(const DB& db, const LIST& params, referenced_modified_datum* in)
-{
-    size_t base = GenericFill(db, params, static_cast<datum_reference*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to referenced_modified_datum"); }    do { // convert the 'modifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->modifier, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to referenced_modified_datum to be a `limit_condition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<relative_event_occurrence>(const DB& db, const LIST& params, relative_event_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<event_occurrence*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to relative_event_occurrence"); }    do { // convert the 'base_event' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->base_event, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to relative_event_occurrence to be a `event_occurrence`")); }
-    } while (0);
-    do { // convert the 'offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to relative_event_occurrence to be a `time_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<rep_item_group>(const DB& db, const LIST& params, rep_item_group* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<reparametrised_composite_curve_segment>(const DB& db, const LIST& params, reparametrised_composite_curve_segment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<composite_curve_segment*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to reparametrised_composite_curve_segment"); }    do { // convert the 'param_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->param_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to reparametrised_composite_curve_segment to be a `parameter_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<representation_relationship_with_transformation>(const DB& db, const LIST& params, representation_relationship_with_transformation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to representation_relationship_with_transformation"); }    do { // convert the 'transformation_operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation_operator, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to representation_relationship_with_transformation to be a `transformation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_assigned_object>(const DB& db, const LIST& params, requirement_assigned_object* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to requirement_assigned_object"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to requirement_assigned_object to be a `SET [1:1] OF requirement_assigned_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<requirement_assignment>(const DB& db, const LIST& params, requirement_assignment* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_source>(const DB& db, const LIST& params, requirement_source* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to requirement_source"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<requirement_view_definition_relationship>(const DB& db, const LIST& params, requirement_view_definition_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to requirement_view_definition_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<resistance_measure_with_unit>(const DB& db, const LIST& params, resistance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to resistance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<resistance_unit>(const DB& db, const LIST& params, resistance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to resistance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<revolved_area_solid>(const DB& db, const LIST& params, revolved_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to revolved_area_solid"); }    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 revolved_area_solid to be a `axis1_placement`")); }
-    } 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 revolved_area_solid to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<revolved_face_solid>(const DB& db, const LIST& params, revolved_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_face_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to revolved_face_solid"); }    do { // convert the 'axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::revolved_face_solid, 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 revolved_face_solid to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::revolved_face_solid, 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 revolved_face_solid to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<revolved_face_solid_with_trim_conditions>(const DB& db, const LIST& params, revolved_face_solid_with_trim_conditions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<revolved_face_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to revolved_face_solid_with_trim_conditions"); }    do { // convert the 'first_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->first_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to revolved_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    do { // convert the 'second_trim_condition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->second_trim_condition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to revolved_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_angular_wedge>(const DB& db, const LIST& params, right_angular_wedge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to right_angular_wedge"); }    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 1 to right_angular_wedge to be a `axis2_placement_3d`")); }
-    } while (0);
-    do { // convert the 'x' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->x, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_angular_wedge to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'y' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->y, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_angular_wedge to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'z' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->z, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to right_angular_wedge to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'ltx' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->ltx, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to right_angular_wedge to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_circular_cone>(const DB& db, const LIST& params, right_circular_cone* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to right_circular_cone"); }    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 1 to right_circular_cone to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'height' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->height, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_circular_cone to be a `positive_length_measure`")); }
-    } 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 3 to right_circular_cone to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'semi_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to right_circular_cone to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_circular_cylinder>(const DB& db, const LIST& params, right_circular_cylinder* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to right_circular_cylinder"); }    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 1 to right_circular_cylinder to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'height' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->height, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_circular_cylinder to be a `positive_length_measure`")); }
-    } 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 3 to right_circular_cylinder to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<right_to_usage_association>(const DB& db, const LIST& params, right_to_usage_association* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to right_to_usage_association"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<roundness_tolerance>(const DB& db, const LIST& params, roundness_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to roundness_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<row_representation_item>(const DB& db, const LIST& params, row_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to row_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<row_value>(const DB& db, const LIST& params, row_value* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to row_value"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<row_variable>(const DB& db, const LIST& params, row_variable* in)
-{
-    size_t base = GenericFill(db, params, static_cast<abstract_variable*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_action>(const DB& db, const LIST& params, rule_action* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to rule_action"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_condition>(const DB& db, const LIST& params, rule_condition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<atomic_formula*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to rule_condition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_set>(const DB& db, const LIST& params, rule_set* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_set"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_set_group>(const DB& db, const LIST& params, rule_set_group* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_set_group"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_superseded_assignment>(const DB& db, const LIST& params, rule_superseded_assignment* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to rule_superseded_assignment"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to rule_superseded_assignment to be a `SET [1:?] OF rule_superseded_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<rule_supersedence>(const DB& db, const LIST& params, rule_supersedence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<rule_action*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to rule_supersedence"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_curve_swept_area_solid>(const DB& db, const LIST& params, surface_curve_swept_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to surface_curve_swept_area_solid"); }    do { // convert the 'directrix' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::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 2 to surface_curve_swept_area_solid to be a `curve`")); }
-    } while (0);
-    do { // convert the 'start_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->start_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_curve_swept_area_solid to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'end_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->end_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_curve_swept_area_solid to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'reference_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->reference_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to surface_curve_swept_area_solid to be a `surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<ruled_surface_swept_area_solid>(const DB& db, const LIST& params, ruled_surface_swept_area_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_curve_swept_area_solid*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to ruled_surface_swept_area_solid"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<runout_zone_definition>(const DB& db, const LIST& params, runout_zone_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<tolerance_zone_definition*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to runout_zone_definition"); }    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 2 to runout_zone_definition to be a `runout_zone_orientation`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<runout_zone_orientation>(const DB& db, const LIST& params, runout_zone_orientation* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to runout_zone_orientation"); }    do { // convert the 'angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::runout_zone_orientation, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to runout_zone_orientation to be a `measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<runout_zone_orientation_reference_direction>(const DB& db, const LIST& params, runout_zone_orientation_reference_direction* in)
-{
-    size_t base = GenericFill(db, params, static_cast<runout_zone_orientation*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to runout_zone_orientation_reference_direction"); }    do { // convert the 'orientation_defining_relationship' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->orientation_defining_relationship, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to runout_zone_orientation_reference_direction to be a `shape_aspect_relationship`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<satisfied_requirement>(const DB& db, const LIST& params, satisfied_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfied_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to satisfied_requirement to be a `SET [1:1] OF product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<satisfies_requirement>(const DB& db, const LIST& params, satisfies_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfies_requirement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<satisfying_item>(const DB& db, const LIST& params, satisfying_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfying_item"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to satisfying_item to be a `SET [1:1] OF requirement_satisfaction_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<scalar_variable>(const DB& db, const LIST& params, scalar_variable* in)
-{
-    size_t base = GenericFill(db, params, static_cast<abstract_variable*>(in));
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<scattering_parameter>(const DB& db, const LIST& params, scattering_parameter* in)
-{
-    size_t base = GenericFill(db, params, static_cast<polar_complex_number_literal*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to scattering_parameter"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<sculptured_solid>(const DB& db, const LIST& params, sculptured_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to sculptured_solid"); }    do { // convert the 'sculpturing_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sculpturing_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to sculptured_solid to be a `generalized_surface_select`")); }
-    } while (0);
-    do { // convert the 'positive_side' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->positive_side, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to sculptured_solid to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<seam_curve>(const DB& db, const LIST& params, seam_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_curve*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to seam_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<serial_numbered_effectivity>(const DB& db, const LIST& params, serial_numbered_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to serial_numbered_effectivity"); }    do { // convert the 'effectivity_start_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_start_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to serial_numbered_effectivity to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'effectivity_end_id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->effectivity_end_id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to serial_numbered_effectivity to be a `identifier`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect_associativity>(const DB& db, const LIST& params, shape_aspect_associativity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_associativity"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_aspect_deriving_relationship>(const DB& db, const LIST& params, shape_aspect_deriving_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_deriving_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_definition_representation>(const DB& db, const LIST& params, shape_definition_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<property_definition_representation*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shape_definition_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_dimension_representation>(const DB& db, const LIST& params, shape_dimension_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_dimension_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_feature_definition>(const DB& db, const LIST& params, shape_feature_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<characterized_object*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shape_feature_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shape_representation_with_parameters>(const DB& db, const LIST& params, shape_representation_with_parameters* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_representation_with_parameters"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shell_based_surface_model>(const DB& db, const LIST& params, shell_based_surface_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shell_based_surface_model"); }    do { // convert the 'sbsm_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sbsm_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shell_based_surface_model to be a `SET [1:?] OF shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shell_based_wireframe_model>(const DB& db, const LIST& params, shell_based_wireframe_model* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shell_based_wireframe_model"); }    do { // convert the 'sbwm_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sbwm_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shell_based_wireframe_model to be a `SET [1:?] OF shell`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<shell_based_wireframe_shape_representation>(const DB& db, const LIST& params, shell_based_wireframe_shape_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shell_based_wireframe_shape_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<si_absorbed_dose_unit>(const DB& db, const LIST& params, si_absorbed_dose_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_capacitance_unit>(const DB& db, const LIST& params, si_capacitance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_conductance_unit>(const DB& db, const LIST& params, si_conductance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_dose_equivalent_unit>(const DB& db, const LIST& params, si_dose_equivalent_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_electric_charge_unit>(const DB& db, const LIST& params, si_electric_charge_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_electric_potential_unit>(const DB& db, const LIST& params, si_electric_potential_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_energy_unit>(const DB& db, const LIST& params, si_energy_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_force_unit>(const DB& db, const LIST& params, si_force_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_frequency_unit>(const DB& db, const LIST& params, si_frequency_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_illuminance_unit>(const DB& db, const LIST& params, si_illuminance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_inductance_unit>(const DB& db, const LIST& params, si_inductance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_magnetic_flux_density_unit>(const DB& db, const LIST& params, si_magnetic_flux_density_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_magnetic_flux_unit>(const DB& db, const LIST& params, si_magnetic_flux_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_power_unit>(const DB& db, const LIST& params, si_power_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_pressure_unit>(const DB& db, const LIST& params, si_pressure_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_radioactivity_unit>(const DB& db, const LIST& params, si_radioactivity_unit* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_resistance_unit>(const DB& db, const LIST& params, si_resistance_unit* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<si_unit>(const DB& db, const LIST& params, si_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to si_unit"); }    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 1 to si_unit to be a `si_prefix`")); }
-    } 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 2 to si_unit to be a `si_unit_name`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<simple_boolean_expression>(const DB& db, const LIST& params, simple_boolean_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<simple_numeric_expression>(const DB& db, const LIST& params, simple_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<slash_expression>(const DB& db, const LIST& params, slash_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<binary_numeric_expression*>(in));
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<smeared_material_definition>(const DB& db, const LIST& params, smeared_material_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to smeared_material_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_angle_measure_with_unit>(const DB& db, const LIST& params, solid_angle_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to solid_angle_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_angle_unit>(const DB& db, const LIST& params, solid_angle_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_angle_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_curve_font>(const DB& db, const LIST& params, solid_curve_font* in)
-{
-    size_t base = GenericFill(db, params, static_cast<pre_defined_curve_font*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_curve_font"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_replica>(const DB& db, const LIST& params, solid_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to solid_replica"); }    do { // convert the 'parent_solid' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_solid, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to solid_replica to be a `solid_model`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to solid_replica to be a `cartesian_transformation_operator_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_chamfered_edges>(const DB& db, const LIST& params, solid_with_chamfered_edges* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to solid_with_chamfered_edges"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_angle_based_chamfer>(const DB& db, const LIST& params, solid_with_angle_based_chamfer* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_angle_based_chamfer"); }    do { // convert the 'offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_angle_based_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'left_offset' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->left_offset, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_angle_based_chamfer to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'offset_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_angle_based_chamfer to be a `positive_plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_shape_element_pattern>(const DB& db, const LIST& params, solid_with_shape_element_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_shape_element_pattern"); }    do { // convert the 'replicated_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_shape_element_pattern, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->replicated_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_shape_element_pattern to be a `modified_solid_with_placed_configuration`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_circular_pattern>(const DB& db, const LIST& params, solid_with_circular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_shape_element_pattern*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_circular_pattern"); }    do { // convert the 'replicate_count' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->replicate_count, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_circular_pattern to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'angular_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->angular_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_circular_pattern to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'radial_alignment' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->radial_alignment, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_circular_pattern to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'reference_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->reference_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_circular_pattern to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_depression>(const DB& db, const LIST& params, solid_with_depression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_depression"); }    do { // convert the 'depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_depression, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->depth, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_depression to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_pocket>(const DB& db, const LIST& params, solid_with_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_pocket"); }    do { // convert the 'floor_blend_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_pocket, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->floor_blend_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_pocket to be a `non_negative_length_measure`")); }
-    } while (0);
-    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_pocket, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_pocket to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_circular_pocket>(const DB& db, const LIST& params, solid_with_circular_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_circular_pocket"); }    do { // convert the 'pocket_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pocket_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_circular_pocket to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_protrusion>(const DB& db, const LIST& params, solid_with_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_protrusion"); }    do { // convert the 'protrusion_height' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_protrusion, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->protrusion_height, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'protrusion_draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_protrusion, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->protrusion_draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_protrusion to be a `plane_angle_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_circular_protrusion>(const DB& db, const LIST& params, solid_with_circular_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_circular_protrusion"); }    do { // convert the 'protrusion_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_circular_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_hole>(const DB& db, const LIST& params, solid_with_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_hole"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_stepped_round_hole>(const DB& db, const LIST& params, solid_with_stepped_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_hole*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_stepped_round_hole"); }    do { // convert the 'segments' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_stepped_round_hole, 1>::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 5 to solid_with_stepped_round_hole to be a `positive_integer`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_conical_bottom_round_hole>(const DB& db, const LIST& params, solid_with_conical_bottom_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_conical_bottom_round_hole"); }    do { // convert the 'semi_apex_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->semi_apex_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_conical_bottom_round_hole to be a `positive_plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'tip_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tip_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_conical_bottom_round_hole to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_constant_radius_edge_blend>(const DB& db, const LIST& params, solid_with_constant_radius_edge_blend* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_constant_radius_edge_blend"); }    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 4 to solid_with_constant_radius_edge_blend to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_slot>(const DB& db, const LIST& params, solid_with_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_slot"); }    do { // convert the 'slot_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_slot, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->slot_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_slot to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'closed_ends' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_slot, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->closed_ends, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_slot to be a `LIST [2:2] OF LOGICAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_curved_slot>(const DB& db, const LIST& params, solid_with_curved_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_curved_slot"); }    do { // convert the 'slot_centreline' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->slot_centreline, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_curved_slot to be a `bounded_curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_double_offset_chamfer>(const DB& db, const LIST& params, solid_with_double_offset_chamfer* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_double_offset_chamfer"); }    do { // convert the 'left_offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->left_offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_double_offset_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'right_offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->right_offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_double_offset_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_flat_bottom_round_hole>(const DB& db, const LIST& params, solid_with_flat_bottom_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_flat_bottom_round_hole"); }    do { // convert the 'fillet_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fillet_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_flat_bottom_round_hole to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_general_pocket>(const DB& db, const LIST& params, solid_with_general_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_general_pocket"); }    do { // convert the 'profile' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->profile, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_general_pocket to be a `positioned_sketch`")); }
-    } while (0);
-    do { // convert the 'reference_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->reference_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_general_pocket to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_general_protrusion>(const DB& db, const LIST& params, solid_with_general_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_general_protrusion"); }    do { // convert the 'profile' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->profile, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_general_protrusion to be a `positioned_sketch`")); }
-    } while (0);
-    do { // convert the 'reference_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->reference_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_general_protrusion to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_groove>(const DB& db, const LIST& params, solid_with_groove* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_groove"); }    do { // convert the 'groove_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->groove_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_groove to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'groove_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->groove_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_groove to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_groove to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'floor_fillet_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->floor_fillet_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_groove to be a `non_negative_length_measure`")); }
-    } while (0);
-    do { // convert the 'external_groove' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->external_groove, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_groove to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_incomplete_circular_pattern>(const DB& db, const LIST& params, solid_with_incomplete_circular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_circular_pattern*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_incomplete_circular_pattern"); }    do { // convert the 'omitted_instances' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->omitted_instances, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_incomplete_circular_pattern to be a `SET [1:?] OF positive_integer`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_rectangular_pattern>(const DB& db, const LIST& params, solid_with_rectangular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_shape_element_pattern*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_rectangular_pattern"); }    do { // convert the 'row_count' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->row_count, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_rectangular_pattern to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'column_count' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->column_count, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_rectangular_pattern to be a `positive_integer`")); }
-    } while (0);
-    do { // convert the 'row_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[2] = true; break; }
-        try { GenericConvert(in->row_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_pattern to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'column_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[3] = true; break; }
-        try { GenericConvert(in->column_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_pattern to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_incomplete_rectangular_pattern>(const DB& db, const LIST& params, solid_with_incomplete_rectangular_pattern* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_rectangular_pattern*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_incomplete_rectangular_pattern"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_rectangular_pocket>(const DB& db, const LIST& params, solid_with_rectangular_pocket* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
-    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_rectangular_pocket"); }    do { // convert the 'pocket_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pocket_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_pocket to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'pocket_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->pocket_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_pocket to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'corner_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->corner_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_rectangular_pocket to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_rectangular_protrusion>(const DB& db, const LIST& params, solid_with_rectangular_protrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_rectangular_protrusion"); }    do { // convert the 'protrusion_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_rectangular_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'protrusion_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_protrusion to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'protrusion_corner_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->protrusion_corner_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_protrusion to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_single_offset_chamfer>(const DB& db, const LIST& params, solid_with_single_offset_chamfer* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_single_offset_chamfer"); }    do { // convert the 'offset_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_single_offset_chamfer to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_spherical_bottom_round_hole>(const DB& db, const LIST& params, solid_with_spherical_bottom_round_hole* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_spherical_bottom_round_hole"); }    do { // convert the 'sphere_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sphere_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_spherical_bottom_round_hole to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_stepped_round_hole_and_conical_transitions>(const DB& db, const LIST& params, solid_with_stepped_round_hole_and_conical_transitions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_stepped_round_hole_and_conical_transitions"); }    do { // convert the 'conical_transitions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->conical_transitions, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_stepped_round_hole_and_conical_transitions to be a `SET [1:?] OF conical_stepped_hole_transition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_straight_slot>(const DB& db, const LIST& params, solid_with_straight_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_straight_slot"); }    do { // convert the 'slot_length' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->slot_length, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_straight_slot to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_tee_section_slot>(const DB& db, const LIST& params, solid_with_tee_section_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_tee_section_slot"); }    do { // convert the 'tee_section_width' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->tee_section_width, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_tee_section_slot to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'collar_depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->collar_depth, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_tee_section_slot to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_through_depression>(const DB& db, const LIST& params, solid_with_through_depression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_through_depression"); }    do { // convert the 'exit_faces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->exit_faces, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_through_depression to be a `SET [1:?] OF face_surface`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_trapezoidal_section_slot>(const DB& db, const LIST& params, solid_with_trapezoidal_section_slot* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_trapezoidal_section_slot"); }    do { // convert the 'draft_angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->draft_angle, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_trapezoidal_section_slot to be a `plane_angle_measure`")); }
-    } while (0);
-    do { // convert the 'floor_fillet_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->floor_fillet_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_trapezoidal_section_slot to be a `non_negative_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<solid_with_variable_radius_edge_blend>(const DB& db, const LIST& params, solid_with_variable_radius_edge_blend* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to solid_with_variable_radius_edge_blend"); }    do { // convert the 'point_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->point_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to solid_with_variable_radius_edge_blend to be a `LIST [2:?] OF point`")); }
-    } while (0);
-    do { // convert the 'radius_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->radius_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to solid_with_variable_radius_edge_blend to be a `LIST [2:?] OF positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'edge_function_list' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->edge_function_list, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to solid_with_variable_radius_edge_blend to be a `LIST [1:?] OF blend_radius_variation_type`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<source_for_requirement>(const DB& db, const LIST& params, source_for_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to source_for_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to source_for_requirement to be a `SET [1:1] OF requirement_source_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<sourced_requirement>(const DB& db, const LIST& params, sourced_requirement* in)
-{
-    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to sourced_requirement"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to sourced_requirement to be a `SET [1:1] OF product_definition`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<specification_definition>(const DB& db, const LIST& params, specification_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to specification_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<specified_higher_usage_occurrence>(const DB& db, const LIST& params, specified_higher_usage_occurrence* in)
-{
-    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
-    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to specified_higher_usage_occurrence"); }    do { // convert the 'upper_usage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->upper_usage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to specified_higher_usage_occurrence to be a `assembly_component_usage`")); }
-    } while (0);
-    do { // convert the 'next_usage' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->next_usage, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to specified_higher_usage_occurrence to be a `next_assembly_usage_occurrence`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<sphere>(const DB& db, const LIST& params, sphere* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to sphere"); }    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 sphere to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'centre' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->centre, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to sphere to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<spherical_surface>(const DB& db, const LIST& params, spherical_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to spherical_surface"); }    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 2 to spherical_surface to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<start_request>(const DB& db, const LIST& params, start_request* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to start_request"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to start_request to be a `SET [1:?] OF start_request_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<start_work>(const DB& db, const LIST& params, start_work* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to start_work"); }    do { // convert the 'items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->items, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to start_work to be a `SET [1:?] OF work_item`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<straightness_tolerance>(const DB& db, const LIST& params, straightness_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to straightness_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<structured_dimension_callout>(const DB& db, const LIST& params, structured_dimension_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to structured_dimension_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<structured_text_composition>(const DB& db, const LIST& params, structured_text_composition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to structured_text_composition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<structured_text_representation>(const DB& db, const LIST& params, structured_text_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to structured_text_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<subedge>(const DB& db, const LIST& params, subedge* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to subedge"); }    do { // convert the 'parent_edge' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_edge, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to subedge to be a `edge`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<subface>(const DB& db, const LIST& params, subface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<face*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to subface"); }    do { // convert the 'parent_face' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_face, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to subface to be a `face`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<supplied_part_relationship>(const DB& db, const LIST& params, supplied_part_relationship* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to supplied_part_relationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_condition_callout>(const DB& db, const LIST& params, surface_condition_callout* in)
-{
-    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_condition_callout"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_surface>(const DB& db, const LIST& params, swept_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_surface"); }    do { // convert the 'swept_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_surface, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->swept_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_surface to be a `curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_of_linear_extrusion>(const DB& db, const LIST& params, surface_of_linear_extrusion* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_of_linear_extrusion"); }    do { // convert the 'extrusion_axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extrusion_axis, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_of_linear_extrusion to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_of_revolution>(const DB& db, const LIST& params, surface_of_revolution* in)
-{
-    size_t base = GenericFill(db, params, static_cast<swept_surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_of_revolution"); }    do { // convert the 'axis_position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->axis_position, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_of_revolution to be a `axis1_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_patch>(const DB& db, const LIST& params, surface_patch* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to surface_patch"); }    do { // convert the 'parent_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_patch to be a `bounded_surface`")); }
-    } while (0);
-    do { // convert the 'u_transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_transition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_patch to be a `transition_code`")); }
-    } while (0);
-    do { // convert the 'v_transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_transition, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_patch to be a `transition_code`")); }
-    } while (0);
-    do { // convert the 'u_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->u_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_patch to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'v_sense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->v_sense, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_patch to be a `BOOLEAN`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_profile_tolerance>(const DB& db, const LIST& params, surface_profile_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to surface_profile_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_replica>(const DB& db, const LIST& params, surface_replica* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_replica"); }    do { // convert the 'parent_surface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->parent_surface, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_replica to be a `surface`")); }
-    } while (0);
-    do { // convert the 'transformation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->transformation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_replica to be a `cartesian_transformation_operator_3d`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_side_style>(const DB& db, const LIST& params, surface_side_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_side_style"); }    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 0 to surface_side_style to be a `label`")); }
-    } 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 1 to surface_side_style to be a `SET [1:7] OF surface_style_element_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_boundary>(const DB& db, const LIST& params, surface_style_boundary* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_boundary"); }    do { // convert the 'style_of_boundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_boundary, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_boundary to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_control_grid>(const DB& db, const LIST& params, surface_style_control_grid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_control_grid"); }    do { // convert the 'style_of_control_grid' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_control_grid, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_control_grid to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_fill_area>(const DB& db, const LIST& params, surface_style_fill_area* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_fill_area"); }    do { // convert the 'fill_area' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->fill_area, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_fill_area to be a `fill_area_style`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_parameter_line>(const DB& db, const LIST& params, surface_style_parameter_line* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_parameter_line"); }    do { // convert the 'style_of_parameter_lines' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_parameter_lines, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_parameter_line to be a `curve_or_render`")); }
-    } while (0);
-    do { // convert the 'direction_counts' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->direction_counts, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_parameter_line to be a `SET [1:2] OF direction_count_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_reflectance_ambient>(const DB& db, const LIST& params, surface_style_reflectance_ambient* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_reflectance_ambient"); }    do { // convert the 'ambient_reflectance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_reflectance_ambient, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->ambient_reflectance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_reflectance_ambient to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_reflectance_ambient_diffuse>(const DB& db, const LIST& params, surface_style_reflectance_ambient_diffuse* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_style_reflectance_ambient*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_reflectance_ambient_diffuse"); }    do { // convert the 'diffuse_reflectance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_reflectance_ambient_diffuse, 1>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->diffuse_reflectance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_reflectance_ambient_diffuse to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_reflectance_ambient_diffuse_specular>(const DB& db, const LIST& params, surface_style_reflectance_ambient_diffuse_specular* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_style_reflectance_ambient_diffuse*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to surface_style_reflectance_ambient_diffuse_specular"); }    do { // convert the 'specular_reflectance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->specular_reflectance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_style_reflectance_ambient_diffuse_specular to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'specular_exponent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->specular_exponent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_style_reflectance_ambient_diffuse_specular to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'specular_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->specular_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_style_reflectance_ambient_diffuse_specular to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_rendering>(const DB& db, const LIST& params, surface_style_rendering* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_rendering"); }    do { // convert the 'rendering_method' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_rendering, 2>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->rendering_method, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_rendering to be a `shading_surface_method`")); }
-    } while (0);
-    do { // convert the 'surface_colour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_rendering, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->surface_colour, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_rendering to be a `colour`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_rendering_with_properties>(const DB& db, const LIST& params, surface_style_rendering_with_properties* in)
-{
-    size_t base = GenericFill(db, params, static_cast<surface_style_rendering*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_style_rendering_with_properties"); }    do { // convert the 'properties' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->properties, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_style_rendering_with_properties to be a `SET [1:2] OF rendering_properties_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_segmentation_curve>(const DB& db, const LIST& params, surface_style_segmentation_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_segmentation_curve"); }    do { // convert the 'style_of_segmentation_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_segmentation_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_segmentation_curve to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_silhouette>(const DB& db, const LIST& params, surface_style_silhouette* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_silhouette"); }    do { // convert the 'style_of_silhouette' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_silhouette, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_silhouette to be a `curve_or_render`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_style_usage>(const DB& db, const LIST& params, surface_style_usage* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_usage"); }    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 0 to surface_style_usage to be a `surface_side`")); }
-    } while (0);
-    do { // convert the 'style' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_usage to be a `surface_side_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surface_texture_representation>(const DB& db, const LIST& params, surface_texture_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_texture_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<surfaced_open_shell>(const DB& db, const LIST& params, surfaced_open_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<open_shell*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surfaced_open_shell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<swept_disk_solid>(const DB& db, const LIST& params, swept_disk_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to swept_disk_solid"); }    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 1 to swept_disk_solid to be a `curve`")); }
-    } 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 2 to swept_disk_solid to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'inner_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->inner_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to swept_disk_solid to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'start_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->start_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to swept_disk_solid to be a `REAL`")); }
-    } while (0);
-    do { // convert the 'end_param' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->end_param, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to swept_disk_solid to be a `REAL`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol>(const DB& db, const LIST& params, symbol* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to symbol"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_representation_map>(const DB& db, const LIST& params, symbol_representation_map* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to symbol_representation_map"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_style>(const DB& db, const LIST& params, symbol_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to symbol_style"); }    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 0 to symbol_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'style_of_symbol' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->style_of_symbol, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to symbol_style to be a `symbol_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symbol_target>(const DB& db, const LIST& params, symbol_target* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to symbol_target"); }    do { // convert the 'placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to symbol_target to be a `axis2_placement`")); }
-    } while (0);
-    do { // convert the 'x_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->x_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to symbol_target to be a `positive_ratio_measure`")); }
-    } while (0);
-    do { // convert the 'y_scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->y_scale, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to symbol_target to be a `positive_ratio_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symmetric_shape_aspect>(const DB& db, const LIST& params, symmetric_shape_aspect* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to symmetric_shape_aspect"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<symmetry_tolerance>(const DB& db, const LIST& params, symmetry_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to symmetry_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<table_representation_item>(const DB& db, const LIST& params, table_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to table_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tactile_appearance_representation>(const DB& db, const LIST& params, tactile_appearance_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to tactile_appearance_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tagged_text_format>(const DB& db, const LIST& params, tagged_text_format* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tagged_text_format"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tagged_text_item>(const DB& db, const LIST& params, tagged_text_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tagged_text_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tangent>(const DB& db, const LIST& params, tangent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to tangent"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_associated_curves>(const DB& db, const LIST& params, text_literal_with_associated_curves* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_associated_curves"); }    do { // convert the 'associated_curves' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->associated_curves, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_associated_curves to be a `SET [1:?] OF curve`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_blanking_box>(const DB& db, const LIST& params, text_literal_with_blanking_box* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_blanking_box"); }    do { // convert the 'blanking' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->blanking, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_blanking_box to be a `planar_box`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_literal_with_extent>(const DB& db, const LIST& params, text_literal_with_extent* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_extent"); }    do { // convert the 'extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_extent to be a `planar_extent`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_string_representation>(const DB& db, const LIST& params, text_string_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_string_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style>(const DB& db, const LIST& params, text_style* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to text_style"); }    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_style, 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 text_style to be a `label`")); }
-    } while (0);
-    do { // convert the 'character_appearance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_style, 2>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->character_appearance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to text_style to be a `character_style_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style_with_box_characteristics>(const DB& db, const LIST& params, text_style_with_box_characteristics* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_box_characteristics"); }    do { // convert the 'characteristics' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->characteristics, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_box_characteristics to be a `SET [1:4] OF box_characteristic_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style_with_mirror>(const DB& db, const LIST& params, text_style_with_mirror* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_mirror"); }    do { // convert the 'mirror_placement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->mirror_placement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_mirror to be a `axis2_placement`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<text_style_with_spacing>(const DB& db, const LIST& params, text_style_with_spacing* in)
-{
-    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_spacing"); }    do { // convert the 'character_spacing' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->character_spacing, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_spacing to be a `character_spacing_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermal_resistance_measure_with_unit>(const DB& db, const LIST& params, thermal_resistance_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to thermal_resistance_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermal_resistance_unit>(const DB& db, const LIST& params, thermal_resistance_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to thermal_resistance_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermodynamic_temperature_measure_with_unit>(const DB& db, const LIST& params, thermodynamic_temperature_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to thermodynamic_temperature_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thermodynamic_temperature_unit>(const DB& db, const LIST& params, thermodynamic_temperature_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to thermodynamic_temperature_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thickened_face_solid>(const DB& db, const LIST& params, thickened_face_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickened_face_solid"); }    do { // convert the 'base_element' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->base_element, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to thickened_face_solid to be a `generalized_surface_select`")); }
-    } while (0);
-    do { // convert the 'offset1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to thickened_face_solid to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'offset2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->offset2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to thickened_face_solid to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thickness_laminate_definition>(const DB& db, const LIST& params, thickness_laminate_definition* in)
-{
-    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickness_laminate_definition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<thickness_laminate_table>(const DB& db, const LIST& params, thickness_laminate_table* in)
-{
-    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickness_laminate_table"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval>(const DB& db, const LIST& params, time_interval* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to time_interval"); }    do { // convert the 'id' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[0] = true; break; }
-        try { GenericConvert(in->id, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval to be a `identifier`")); }
-    } while (0);
-    do { // convert the 'name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[1] = true; break; }
-        try { GenericConvert(in->name, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[2] = 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 2 to time_interval to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval_based_effectivity>(const DB& db, const LIST& params, time_interval_based_effectivity* in)
-{
-    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_based_effectivity"); }    do { // convert the 'effectivity_period' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->effectivity_period, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_based_effectivity to be a `time_interval`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_interval_with_bounds>(const DB& db, const LIST& params, time_interval_with_bounds* in)
-{
-    size_t base = GenericFill(db, params, static_cast<time_interval*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to time_interval_with_bounds"); }    do { // convert the 'primary_bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->primary_bound, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to time_interval_with_bounds to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    do { // convert the 'secondary_bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->secondary_bound, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to time_interval_with_bounds to be a `date_time_or_event_occurrence`")); }
-    } while (0);
-    do { // convert the 'duration' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->duration, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to time_interval_with_bounds to be a `time_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_measure_with_unit>(const DB& db, const LIST& params, time_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<time_unit>(const DB& db, const LIST& params, time_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to time_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<tolerance_zone>(const DB& db, const LIST& params, tolerance_zone* in)
-{
-    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to tolerance_zone"); }    do { // convert the 'defining_tolerance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->defining_tolerance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to tolerance_zone to be a `SET [1:?] OF geometric_tolerance`")); }
-    } while (0);
-    do { // convert the 'form' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->form, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to tolerance_zone to be a `tolerance_zone_form`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<torus>(const DB& db, const LIST& params, torus* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to torus"); }    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 1 to torus to be a `axis1_placement`")); }
-    } while (0);
-    do { // convert the 'major_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->major_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to torus to be a `positive_length_measure`")); }
-    } while (0);
-    do { // convert the 'minor_radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->minor_radius, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to torus to be a `positive_length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<total_runout_tolerance>(const DB& db, const LIST& params, total_runout_tolerance* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to total_runout_tolerance"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<track_blended_solid>(const DB& db, const LIST& params, track_blended_solid* in)
-{
-    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to track_blended_solid"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<track_blended_solid_with_end_conditions>(const DB& db, const LIST& params, track_blended_solid_with_end_conditions* in)
-{
-    size_t base = GenericFill(db, params, static_cast<track_blended_solid*>(in));
-    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to track_blended_solid_with_end_conditions"); }    do { // convert the 'end_conditions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->end_conditions, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to track_blended_solid_with_end_conditions to be a `LIST [2:2] OF blend_end_condition_select`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<trimmed_curve>(const DB& db, const LIST& params, trimmed_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to trimmed_curve"); }    do { // convert the 'basis_curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->basis_curve, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to trimmed_curve to be a `curve`")); }
-    } while (0);
-    do { // convert the 'trim_1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->trim_1, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to trimmed_curve to be a `SET [1:2] OF trimming_select`")); }
-    } while (0);
-    do { // convert the 'trim_2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->trim_2, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to trimmed_curve to be a `SET [1:2] OF trimming_select`")); }
-    } while (0);
-    do { // convert the 'sense_agreement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->sense_agreement, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to trimmed_curve to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'master_representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->master_representation, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to trimmed_curve to be a `trimming_preference`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<two_direction_repeat_factor>(const DB& db, const LIST& params, two_direction_repeat_factor* in)
-{
-    size_t base = GenericFill(db, params, static_cast<one_direction_repeat_factor*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to two_direction_repeat_factor"); }    do { // convert the 'second_repeat_factor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->second_repeat_factor, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to two_direction_repeat_factor to be a `vector`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<unary_generic_expression>(const DB& db, const LIST& params, unary_generic_expression* in)
-{
-    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to unary_generic_expression"); }    do { // convert the 'operand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->operand, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to unary_generic_expression to be a `generic_expression`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<unary_numeric_expression>(const DB& db, const LIST& params, unary_numeric_expression* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uncertainty_assigned_representation>(const DB& db, const LIST& params, uncertainty_assigned_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to uncertainty_assigned_representation"); }    do { // convert the 'uncertainty' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->uncertainty, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to uncertainty_assigned_representation to be a `SET [1:?] OF uncertainty_measure_with_unit`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uncertainty_measure_with_unit>(const DB& db, const LIST& params, uncertainty_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to uncertainty_measure_with_unit"); }    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 uncertainty_measure_with_unit to be a `label`")); }
-    } while (0);
-    do { // convert the 'description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        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 uncertainty_measure_with_unit to be a `text`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uniform_curve>(const DB& db, const LIST& params, uniform_curve* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
-    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to uniform_curve"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uniform_resource_identifier>(const DB& db, const LIST& params, uniform_resource_identifier* in)
-{
-    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to uniform_resource_identifier"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<uniform_surface>(const DB& db, const LIST& params, uniform_surface* in)
-{
-    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
-    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to uniform_surface"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<usage_association>(const DB& db, const LIST& params, usage_association* in)
-{
-    size_t base = GenericFill(db, params, static_cast<action_method_relationship*>(in));
-    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to usage_association"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<user_defined_curve_font>(const DB& db, const LIST& params, user_defined_curve_font* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_defined_marker>(const DB& db, const LIST& params, user_defined_marker* in)
-{
-    size_t base = 0;
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_defined_terminator_symbol>(const DB& db, const LIST& params, user_defined_terminator_symbol* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<user_selected_shape_elements>(const DB& db, const LIST& params, user_selected_shape_elements* in)
-{
-    size_t base = GenericFill(db, params, static_cast<user_selected_elements*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to user_selected_shape_elements"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<value_range>(const DB& db, const LIST& params, value_range* in)
-{
-    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to value_range"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<value_representation_item>(const DB& db, const LIST& params, value_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to value_representation_item"); }    do { // convert the 'value_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->value_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to value_representation_item to be a `measure_value`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<variable_semantics>(const DB& db, const LIST& params, variable_semantics* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<variational_representation_item>(const DB& db, const LIST& params, variational_representation_item* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to variational_representation_item"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vector>(const DB& db, const LIST& params, vector* in)
-{
-    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to vector"); }    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 1 to vector to be a `direction`")); }
-    } 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 2 to vector to be a `length_measure`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-/*template <> size_t GenericFill<vector_style>(const DB& db, const LIST& params, vector_style* in)
-{
-    size_t base = 0;
-    return base;
-}*/
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<velocity_measure_with_unit>(const DB& db, const LIST& params, velocity_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to velocity_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<velocity_unit>(const DB& db, const LIST& params, velocity_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to velocity_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex>(const DB& db, const LIST& params, vertex* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to vertex"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex_loop>(const DB& db, const LIST& params, vertex_loop* in)
-{
-    size_t base = GenericFill(db, params, static_cast<loop*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to vertex_loop"); }    do { // convert the 'loop_vertex' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->loop_vertex, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vertex_loop to be a `vertex`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex_point>(const DB& db, const LIST& params, vertex_point* in)
-{
-    size_t base = 0;
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to vertex_point"); }    do { // convert the 'vertex_geometry' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->vertex_geometry, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to vertex_point to be a `point`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<vertex_shell>(const DB& db, const LIST& params, vertex_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to vertex_shell"); }    do { // convert the 'vertex_shell_extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->vertex_shell_extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vertex_shell to be a `vertex_loop`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<view_volume>(const DB& db, const LIST& params, view_volume* in)
-{
-    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
-    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to view_volume"); }    do { // convert the 'projection_type' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projection_type, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to view_volume to be a `central_or_parallel`")); }
-    } while (0);
-    do { // convert the 'projection_point' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->projection_point, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to view_volume to be a `cartesian_point`")); }
-    } while (0);
-    do { // convert the 'view_plane_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->view_plane_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to view_volume to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'front_plane_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->front_plane_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to view_volume to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'front_plane_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->front_plane_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to view_volume to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'back_plane_distance' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->back_plane_distance, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to view_volume to be a `length_measure`")); }
-    } while (0);
-    do { // convert the 'back_plane_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->back_plane_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to view_volume to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'view_volume_sides_clipping' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->view_volume_sides_clipping, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to view_volume to be a `BOOLEAN`")); }
-    } while (0);
-    do { // convert the 'view_window' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->view_window, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to view_volume to be a `planar_box`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<visual_appearance_representation>(const DB& db, const LIST& params, visual_appearance_representation* in)
-{
-    size_t base = GenericFill(db, params, static_cast<representation*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to visual_appearance_representation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<volume_measure_with_unit>(const DB& db, const LIST& params, volume_measure_with_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to volume_measure_with_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<volume_unit>(const DB& db, const LIST& params, volume_unit* in)
-{
-    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
-    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to volume_unit"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<week_of_year_and_day_date>(const DB& db, const LIST& params, week_of_year_and_day_date* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to week_of_year_and_day_date"); }    do { // convert the 'week_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->week_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to week_of_year_and_day_date to be a `week_in_year_number`")); }
-    } while (0);
-    do { // convert the 'day_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert(in->day_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to week_of_year_and_day_date to be a `day_in_week_number`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<wire_shell>(const DB& db, const LIST& params, wire_shell* in)
-{
-    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to wire_shell"); }    do { // convert the 'wire_shell_extent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->wire_shell_extent, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to wire_shell to be a `SET [1:?] OF loop`")); }
-    } while (0);
-    return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<year_month>(const DB& db, const LIST& params, year_month* in)
-{
-    size_t base = GenericFill(db, params, static_cast<date*>(in));
-    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to year_month"); }    do { // convert the 'month_component' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert(in->month_component, arg, db); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to year_month to be a `month_in_year_number`")); }
-    } while (0);
-    return base;
-}
-
-}
-}
diff --git a/code/AssetLib/StepFile/StepFileImporter.cpp b/code/AssetLib/StepFile/StepFileImporter.cpp
deleted file mode 100644
index f536ec90e..000000000
--- a/code/AssetLib/StepFile/StepFileImporter.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-
-#include "StepFileImporter.h"
-#include "../../Importer/STEPParser/STEPFileReader.h"
-#include <assimp/importerdesc.h>
-#include <assimp/DefaultIOSystem.h>
-
-namespace Assimp {
-namespace StepFile {
-
-using namespace STEP;
-
-static const aiImporterDesc desc = { "StepFile Importer",
-                                "",
-                                "",
-                                "",
-                                0,
-                                0,
-                                0,
-                                0,
-                                0,
-                                "stp" };
-
-StepFileImporter::StepFileImporter()
-: BaseImporter() {
-
-}
-
-StepFileImporter::~StepFileImporter() {
-
-}
-
-bool StepFileImporter::CanRead(const std::string& file, IOSystem* pIOHandler, bool checkSig) const {
-    const std::string &extension = GetExtension(file);
-    if ( extension == "stp" || extension == "step" ) {
-        return true;
-    } else if ((!extension.length() || checkSig) && pIOHandler) {
-        const char* tokens[] = { "ISO-10303-21" };
-        const bool found(SearchFileHeaderForToken(pIOHandler, file, tokens, 1));
-        return found;
-    }
-
-    return false;
-}
-
-const aiImporterDesc *StepFileImporter::GetInfo() const {
-    return &desc;
-}
-
-static const std::string mode = "rb";
-static const std::string StepFileSchema = "CONFIG_CONTROL_DESIGN";
-
-void StepFileImporter::InternReadFile(const std::string &file, aiScene*, IOSystem* pIOHandler) {
-    // Read file into memory
-    std::shared_ptr<IOStream> fileStream(pIOHandler->Open(file, mode));
-    if (!fileStream.get()) {
-        throw DeadlyImportError("Failed to open file " + file + ".");
-    }
-
-    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(fileStream));
-    const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();
-    if (!head.fileSchema.size() || head.fileSchema != StepFileSchema) {
-        DeadlyImportError("Unrecognized file schema: " + head.fileSchema);
-    }
-}
-
-} // Namespace StepFile
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_STEP_IMPORTER
-
diff --git a/code/AssetLib/StepFile/StepReaderGen.h b/code/AssetLib/StepFile/StepReaderGen.h
deleted file mode 100644
index c45220a83..000000000
--- a/code/AssetLib/StepFile/StepReaderGen.h
+++ /dev/null
@@ -1,7291 +0,0 @@
-/*
-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_STEPFILE_READER_GEN_H
-#define INCLUDED_STEPFILE_READER_GEN_H
-
-#include "code/Step/STEPFile.h"
-
-#ifdef _WIN32
-#    pragma warning( disable : 4512 )
-#endif // _WIN32
-namespace Assimp {
-namespace StepFile {
-	using namespace STEP;
-	using namespace STEP::EXPRESS;
-	
-	
-	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
-		
-	};
-	
-
-	// ******************************************************************************
-	// StepFile Custom data types
-	// ******************************************************************************
-
-
-    // C++ wrapper type for absorbed_dose_measure
-    typedef REAL absorbed_dose_measure;
-    // C++ wrapper type for acceleration_measure
-    typedef REAL acceleration_measure;
-    // C++ wrapper type for action_items
-    typedef SELECT action_items;
-    // C++ wrapper type for action_method_items
-    typedef SELECT action_method_items;
-    // C++ wrapper type for action_request_item
-    typedef SELECT action_request_item;
-    // C++ wrapper type for ahead_or_behind
-    typedef ENUMERATION ahead_or_behind;
-    // C++ wrapper type for amount_of_substance_measure
-    typedef REAL amount_of_substance_measure;
-    // C++ wrapper type for angle_direction_reference_select
-    typedef SELECT angle_direction_reference_select;
-    // C++ wrapper type for angle_direction_reference_with_a2p3d_select
-    typedef SELECT angle_direction_reference_with_a2p3d_select;
-    // C++ wrapper type for angle_relator
-    typedef ENUMERATION angle_relator;
-    // C++ wrapper type for annotation_plane_element
-    typedef SELECT annotation_plane_element;
-    // C++ wrapper type for annotation_representation_select
-    typedef SELECT annotation_representation_select;
-    // C++ wrapper type for annotation_symbol_occurrence_item
-    typedef SELECT annotation_symbol_occurrence_item;
-    // C++ wrapper type for annotation_text_occurrence_item
-    typedef SELECT annotation_text_occurrence_item;
-    // C++ wrapper type for approval_item
-    typedef SELECT approval_item;
-    // C++ wrapper type for approved_item
-    typedef SELECT approved_item;
-    // C++ wrapper type for area_measure
-    typedef REAL area_measure;
-    // C++ wrapper type for area_or_view
-    typedef SELECT area_or_view;
-    // C++ wrapper type for attribute_classification_item
-    typedef SELECT attribute_classification_item;
-    // C++ wrapper type for attribute_language_item
-    typedef SELECT attribute_language_item;
-    // C++ wrapper type for attribute_type
-    typedef SELECT attribute_type;
-    // C++ wrapper type for axis2_placement
-    typedef SELECT axis2_placement;
-    // C++ wrapper type for b_spline_curve_form
-    typedef ENUMERATION b_spline_curve_form;
-    // C++ wrapper type for b_spline_surface_form
-    typedef ENUMERATION b_spline_surface_form;
-    // C++ wrapper type for base_solid_select
-    typedef SELECT base_solid_select;
-    // C++ wrapper type for blend_end_condition_select
-    typedef SELECT blend_end_condition_select;
-    // C++ wrapper type for blend_radius_variation_type
-    typedef ENUMERATION blend_radius_variation_type;
-    // C++ wrapper type for boolean_operand
-    typedef SELECT boolean_operand;
-    // C++ wrapper type for boolean_operator
-    typedef ENUMERATION boolean_operator;
-    // C++ wrapper type for box_characteristic_select
-    typedef SELECT box_characteristic_select;
-    // C++ wrapper type for box_height
-    typedef REAL box_height;
-    // C++ wrapper type for box_rotate_angle
-    typedef REAL box_rotate_angle;
-    // C++ wrapper type for box_slant_angle
-    typedef REAL box_slant_angle;
-    // C++ wrapper type for box_width
-    typedef REAL box_width;
-    // C++ wrapper type for camera_model_d3_multi_clipping_interection_select
-    typedef SELECT camera_model_d3_multi_clipping_interection_select;
-    // C++ wrapper type for camera_model_d3_multi_clipping_union_select
-    typedef SELECT camera_model_d3_multi_clipping_union_select;
-    // C++ wrapper type for capacitance_measure
-    typedef REAL capacitance_measure;
-    // C++ wrapper type for category_usage_item
-    typedef SELECT category_usage_item;
-    // C++ wrapper type for cc_classified_item
-    typedef SELECT cc_classified_item;
-    // C++ wrapper type for cc_person_organization_item
-    typedef SELECT cc_person_organization_item;
-    // C++ wrapper type for cc_specified_item
-    typedef SELECT cc_specified_item;
-    // C++ wrapper type for celsius_temperature_measure
-    typedef REAL celsius_temperature_measure;
-    // C++ wrapper type for central_or_parallel
-    typedef ENUMERATION central_or_parallel;
-    // C++ wrapper type for certification_item
-    typedef SELECT certification_item;
-    // C++ wrapper type for certified_item
-    typedef SELECT certified_item;
-    // C++ wrapper type for change_request_item
-    typedef SELECT change_request_item;
-    // C++ wrapper type for character_spacing_select
-    typedef SELECT character_spacing_select;
-    // C++ wrapper type for character_style_select
-    typedef SELECT character_style_select;
-    // C++ wrapper type for characterized_action_definition
-    typedef SELECT characterized_action_definition;
-    // C++ wrapper type for characterized_definition
-    typedef SELECT characterized_definition;
-    // C++ wrapper type for characterized_material_property
-    typedef SELECT characterized_material_property;
-    // C++ wrapper type for characterized_product_composition_value
-    typedef SELECT characterized_product_composition_value;
-    // C++ wrapper type for characterized_product_definition
-    typedef SELECT characterized_product_definition;
-    // C++ wrapper type for class_usage_effectivity_context_item
-    typedef SELECT class_usage_effectivity_context_item;
-    // C++ wrapper type for classification_item
-    typedef SELECT classification_item;
-    // C++ wrapper type for classified_item
-    typedef SELECT classified_item;
-    // C++ wrapper type for compound_item_definition
-    typedef SELECT compound_item_definition;
-    // C++ wrapper type for conductance_measure
-    typedef REAL conductance_measure;
-    // C++ wrapper type for configuration_design_item
-    typedef SELECT configuration_design_item;
-    // C++ wrapper type for configured_effectivity_context_item
-    typedef SELECT configured_effectivity_context_item;
-    // C++ wrapper type for configured_effectivity_item
-    typedef SELECT configured_effectivity_item;
-    // C++ wrapper type for constructive_geometry_representation_or_shape_represenation
-    typedef SELECT constructive_geometry_representation_or_shape_represenation;
-    // C++ wrapper type for context_dependent_measure
-    typedef REAL context_dependent_measure;
-    // C++ wrapper type for contract_item
-    typedef SELECT contract_item;
-    // C++ wrapper type for contracted_item
-    typedef SELECT contracted_item;
-    // C++ wrapper type for count_measure
-    typedef NUMBER count_measure;
-    // C++ wrapper type for csg_primitive
-    typedef SELECT csg_primitive;
-    // C++ wrapper type for csg_select
-    typedef SELECT csg_select;
-    // C++ wrapper type for curve_font_or_scaled_curve_font_select
-    typedef SELECT curve_font_or_scaled_curve_font_select;
-    // C++ wrapper type for curve_on_surface
-    typedef SELECT curve_on_surface;
-    // C++ wrapper type for curve_or_annotation_curve_occurrence
-    typedef SELECT curve_or_annotation_curve_occurrence;
-    // C++ wrapper type for curve_or_render
-    typedef SELECT curve_or_render;
-    // C++ wrapper type for curve_style_font_select
-    typedef SELECT curve_style_font_select;
-    // C++ wrapper type for date_and_time_item
-    typedef SELECT date_and_time_item;
-    // C++ wrapper type for date_item
-    typedef SELECT date_item;
-    // C++ wrapper type for date_time_item
-    typedef SELECT date_time_item;
-    // C++ wrapper type for date_time_or_event_occurrence
-    typedef SELECT date_time_or_event_occurrence;
-    // C++ wrapper type for date_time_select
-    typedef SELECT date_time_select;
-    // C++ wrapper type for day_in_month_number
-    typedef INTEGER day_in_month_number;
-    // C++ wrapper type for day_in_week_number
-    typedef INTEGER day_in_week_number;
-    // C++ wrapper type for day_in_year_number
-    typedef INTEGER day_in_year_number;
-    // C++ wrapper type for defined_symbol_select
-    typedef SELECT defined_symbol_select;
-    // C++ wrapper type for derived_property_select
-    typedef SELECT derived_property_select;
-    // C++ wrapper type for description_attribute_select
-    typedef SELECT description_attribute_select;
-    // C++ wrapper type for descriptive_measure
-    typedef STRING descriptive_measure;
-    // C++ wrapper type for dimension_count
-    typedef INTEGER dimension_count;
-    // C++ wrapper type for dimension_extent_usage
-    typedef ENUMERATION dimension_extent_usage;
-    // C++ wrapper type for dimensional_characteristic
-    typedef SELECT dimensional_characteristic;
-    // C++ wrapper type for direction_count_select
-    typedef SELECT direction_count_select;
-    // C++ wrapper type for document_identifier_assigned_item
-    typedef SELECT document_identifier_assigned_item;
-    // C++ wrapper type for document_reference_item
-    typedef SELECT document_reference_item;
-    // C++ wrapper type for dose_equivalent_measure
-    typedef REAL dose_equivalent_measure;
-    // C++ wrapper type for draughting_callout_element
-    typedef SELECT draughting_callout_element;
-    // C++ wrapper type for draughting_model_item_association_select
-    typedef SELECT draughting_model_item_association_select;
-    // C++ wrapper type for draughting_model_item_select
-    typedef SELECT draughting_model_item_select;
-    // C++ wrapper type for draughting_titled_item
-    typedef SELECT draughting_titled_item;
-    // C++ wrapper type for effectivity_item
-    typedef SELECT effectivity_item;
-    // C++ wrapper type for electric_charge_measure
-    typedef REAL electric_charge_measure;
-    // C++ wrapper type for electric_current_measure
-    typedef REAL electric_current_measure;
-    // C++ wrapper type for electric_potential_measure
-    typedef REAL electric_potential_measure;
-    // C++ wrapper type for energy_measure
-    typedef REAL energy_measure;
-    // C++ wrapper type for event_occurrence_item
-    typedef SELECT event_occurrence_item;
-    // C++ wrapper type for external_identification_item
-    typedef SELECT external_identification_item;
-    // C++ wrapper type for fill_area_style_tile_shape_select
-    typedef SELECT fill_area_style_tile_shape_select;
-    // C++ wrapper type for fill_style_select
-    typedef SELECT fill_style_select;
-    // C++ wrapper type for font_select
-    typedef SELECT font_select;
-    // C++ wrapper type for force_measure
-    typedef REAL force_measure;
-    // C++ wrapper type for founded_item_select
-    typedef SELECT founded_item_select;
-    // C++ wrapper type for frequency_measure
-    typedef REAL frequency_measure;
-    // C++ wrapper type for generalized_surface_select
-    typedef SELECT generalized_surface_select;
-    // C++ wrapper type for geometric_item_specific_usage_select
-    typedef SELECT geometric_item_specific_usage_select;
-    // C++ wrapper type for geometric_set_select
-    typedef SELECT geometric_set_select;
-    // C++ wrapper type for groupable_item
-    typedef SELECT groupable_item;
-    // C++ wrapper type for hour_in_day
-    typedef INTEGER hour_in_day;
-    // C++ wrapper type for id_attribute_select
-    typedef SELECT id_attribute_select;
-    // C++ wrapper type for identification_item
-    typedef SELECT identification_item;
-    // C++ wrapper type for identifier
-    typedef STRING identifier;
-    // C++ wrapper type for illuminance_measure
-    typedef REAL illuminance_measure;
-    // C++ wrapper type for inductance_measure
-    typedef REAL inductance_measure;
-    // C++ wrapper type for instance_usage_context_select
-    typedef SELECT instance_usage_context_select;
-    // C++ wrapper type for invisibility_context
-    typedef SELECT invisibility_context;
-    // C++ wrapper type for invisible_item
-    typedef SELECT invisible_item;
-    // C++ wrapper type for ir_usage_item
-    typedef SELECT ir_usage_item;
-    // C++ wrapper type for knot_type
-    typedef ENUMERATION knot_type;
-    // C++ wrapper type for label
-    typedef STRING label;
-    // C++ wrapper type for layered_item
-    typedef SELECT layered_item;
-    // C++ wrapper type for length_measure
-    typedef REAL length_measure;
-    // C++ wrapper type for limit_condition
-    typedef ENUMERATION limit_condition;
-    // C++ wrapper type for list_of_reversible_topology_item
-    typedef ListOf< SELECT, 0, 0 > list_of_reversible_topology_item;
-    // C++ wrapper type for luminous_flux_measure
-    typedef REAL luminous_flux_measure;
-    // C++ wrapper type for luminous_intensity_measure
-    typedef REAL luminous_intensity_measure;
-    // C++ wrapper type for magnetic_flux_density_measure
-    typedef REAL magnetic_flux_density_measure;
-    // C++ wrapper type for magnetic_flux_measure
-    typedef REAL magnetic_flux_measure;
-    // C++ wrapper type for marker_select
-    typedef SELECT marker_select;
-    // C++ wrapper type for marker_type
-    typedef ENUMERATION marker_type;
-    // C++ wrapper type for mass_measure
-    typedef REAL mass_measure;
-    // C++ wrapper type for measure_value
-    typedef SELECT measure_value;
-    // C++ wrapper type for mechanical_design_and_draughting_relationship_select
-    typedef SELECT mechanical_design_and_draughting_relationship_select;
-    // C++ wrapper type for mechanical_design_geometric_presentation_area_items
-    typedef SELECT mechanical_design_geometric_presentation_area_items;
-    // C++ wrapper type for mechanical_design_geometric_presentation_representation_items
-    typedef SELECT mechanical_design_geometric_presentation_representation_items;
-    // C++ wrapper type for message
-    typedef STRING message;
-    // C++ wrapper type for minute_in_hour
-    typedef INTEGER minute_in_hour;
-    // C++ wrapper type for month_in_year_number
-    typedef INTEGER month_in_year_number;
-    // C++ wrapper type for multi_language_attribute_item
-    typedef SELECT multi_language_attribute_item;
-    // C++ wrapper type for name_attribute_select
-    typedef SELECT name_attribute_select;
-    // C++ wrapper type for name_item
-    typedef SELECT name_item;
-    // C++ wrapper type for non_negative_length_measure
-    typedef REAL non_negative_length_measure;
-    // C++ wrapper type for nonnegative_integer
-    typedef INTEGER nonnegative_integer;
-    // C++ wrapper type for null_style
-    typedef ENUMERATION null_style;
-    // C++ wrapper type for numeric_measure
-    typedef NUMBER numeric_measure;
-    // C++ wrapper type for organization_item
-    typedef SELECT organization_item;
-    // C++ wrapper type for orientation_basis_select
-    typedef SELECT orientation_basis_select;
-    // C++ wrapper type for parameter_value
-    typedef REAL parameter_value;
-    // C++ wrapper type for pcurve_or_surface
-    typedef SELECT pcurve_or_surface;
-    // C++ wrapper type for person_and_organization_item
-    typedef SELECT person_and_organization_item;
-    // C++ wrapper type for person_organization_select
-    typedef SELECT person_organization_select;
-    // C++ wrapper type for picture_representation_item_select
-    typedef SELECT picture_representation_item_select;
-    // C++ wrapper type for plane_angle_measure
-    typedef REAL plane_angle_measure;
-    // C++ wrapper type for plane_or_planar_box
-    typedef SELECT plane_or_planar_box;
-    // C++ wrapper type for point_and_vector_member
-    typedef SELECT point_and_vector_member;
-    // C++ wrapper type for point_and_vector_members
-    typedef ListOf< SELECT, 2, 3 > point_and_vector_members;
-    // C++ wrapper type for positive_integer
-    typedef INTEGER positive_integer;
-    // C++ wrapper type for positive_length_measure
-    typedef REAL positive_length_measure;
-    // C++ wrapper type for positive_plane_angle_measure
-    typedef REAL positive_plane_angle_measure;
-    // C++ wrapper type for positive_ratio_measure
-    typedef REAL positive_ratio_measure;
-    // C++ wrapper type for power_measure
-    typedef REAL power_measure;
-    // C++ wrapper type for preferred_surface_curve_representation
-    typedef ENUMERATION preferred_surface_curve_representation;
-    // C++ wrapper type for presentable_text
-    typedef STRING presentable_text;
-    // C++ wrapper type for presentation_representation_select
-    typedef SELECT presentation_representation_select;
-    // C++ wrapper type for presentation_size_assignment_select
-    typedef SELECT presentation_size_assignment_select;
-    // C++ wrapper type for presentation_style_select
-    typedef SELECT presentation_style_select;
-    // C++ wrapper type for presented_item_select
-    //typedef SELECT presented_item_select;
-    // C++ wrapper type for pressure_measure
-    typedef REAL pressure_measure;
-    // C++ wrapper type for product_definition_or_assembly_relationship
-    typedef SELECT product_definition_or_assembly_relationship;
-    // C++ wrapper type for product_definition_or_breakdown_element_usage
-    typedef SELECT product_definition_or_breakdown_element_usage;
-    // C++ wrapper type for product_definition_or_product_definition_relationship
-    typedef SELECT product_definition_or_product_definition_relationship;
-    // C++ wrapper type for product_or_formation_or_definition
-    typedef SELECT product_or_formation_or_definition;
-    // C++ wrapper type for project_item
-    typedef SELECT project_item;
-    // C++ wrapper type for radioactivity_measure
-    typedef REAL radioactivity_measure;
-    // C++ wrapper type for ratio_measure
-    typedef REAL ratio_measure;
-    // C++ wrapper type for rendering_properties_select
-    typedef SELECT rendering_properties_select;
-    // C++ wrapper type for represented_definition
-    typedef SELECT represented_definition;
-    // C++ wrapper type for requirement_assigned_item
-    typedef SELECT requirement_assigned_item;
-    // C++ wrapper type for requirement_satisfaction_item
-    typedef SELECT requirement_satisfaction_item;
-    // C++ wrapper type for requirement_source_item
-    typedef SELECT requirement_source_item;
-    // C++ wrapper type for resistance_measure
-    typedef REAL resistance_measure;
-    // C++ wrapper type for reversible_topology
-    typedef SELECT reversible_topology;
-    // C++ wrapper type for reversible_topology_item
-    typedef SELECT reversible_topology_item;
-    // C++ wrapper type for role_select
-    typedef SELECT role_select;
-    // C++ wrapper type for rule_superseded_item
-    typedef SELECT rule_superseded_item;
-    // C++ wrapper type for second_in_minute
-    typedef REAL second_in_minute;
-    // C++ wrapper type for security_classification_item
-    typedef SELECT security_classification_item;
-    // C++ wrapper type for set_of_reversible_topology_item
-    typedef ListOf< SELECT, 0, 0 > set_of_reversible_topology_item;
-    // C++ wrapper type for shading_curve_method
-    typedef ENUMERATION shading_curve_method;
-    // C++ wrapper type for shading_surface_method
-    typedef ENUMERATION shading_surface_method;
-    // C++ wrapper type for shape_definition
-    typedef SELECT shape_definition;
-    // C++ wrapper type for shell
-    typedef SELECT shell;
-    // C++ wrapper type for si_prefix
-    typedef ENUMERATION si_prefix;
-    // C++ wrapper type for si_unit_name
-    typedef ENUMERATION si_unit_name;
-    // C++ wrapper type for size_select
-    typedef SELECT size_select;
-    // C++ wrapper type for sketch_basis_select
-    typedef SELECT sketch_basis_select;
-    // C++ wrapper type for solid_angle_measure
-    typedef REAL solid_angle_measure;
-    // C++ wrapper type for source
-    typedef ENUMERATION source;
-    // C++ wrapper type for source_item
-    typedef SELECT source_item;
-    // C++ wrapper type for start_request_item
-    typedef SELECT start_request_item;
-    // C++ wrapper type for string_representation_item_select
-    typedef SELECT string_representation_item_select;
-    // C++ wrapper type for style_context_select
-    typedef SELECT style_context_select;
-    // C++ wrapper type for surface_side
-    typedef ENUMERATION surface_side;
-    // C++ wrapper type for surface_side_style_select
-    typedef SELECT surface_side_style_select;
-    // C++ wrapper type for surface_style_element_select
-    typedef SELECT surface_style_element_select;
-    // C++ wrapper type for symbol_style_select
-    typedef SELECT symbol_style_select;
-    // C++ wrapper type for text
-    typedef STRING text;
-    // C++ wrapper type for text_alignment
-    typedef STRING text_alignment;
-    // C++ wrapper type for text_delineation
-    typedef STRING text_delineation;
-    // C++ wrapper type for text_or_character
-    typedef SELECT text_or_character;
-    // C++ wrapper type for text_path
-    typedef ENUMERATION text_path;
-    // C++ wrapper type for text_string_representation_item
-    typedef SELECT text_string_representation_item;
-    // C++ wrapper type for thermodynamic_temperature_measure
-    typedef REAL thermodynamic_temperature_measure;
-    // C++ wrapper type for time_interval_item
-    typedef SELECT time_interval_item;
-    // C++ wrapper type for time_measure
-    typedef REAL time_measure;
-    // C++ wrapper type for tolerance_method_definition
-    typedef SELECT tolerance_method_definition;
-    // C++ wrapper type for transformation
-    typedef SELECT transformation;
-    // C++ wrapper type for transition_code
-    typedef ENUMERATION transition_code;
-    // C++ wrapper type for trim_condition_select
-    typedef SELECT trim_condition_select;
-    // C++ wrapper type for trim_intent
-    typedef ENUMERATION trim_intent;
-    // C++ wrapper type for trimming_preference
-    typedef ENUMERATION trimming_preference;
-    // C++ wrapper type for trimming_select
-    typedef SELECT trimming_select;
-    // C++ wrapper type for u_direction_count
-    typedef INTEGER u_direction_count;
-    // C++ wrapper type for unit
-    typedef SELECT unit;
-    // C++ wrapper type for v_direction_count
-    typedef INTEGER v_direction_count;
-    // C++ wrapper type for value_qualifier
-    typedef SELECT value_qualifier;
-    // C++ wrapper type for vector_or_direction
-    typedef SELECT vector_or_direction;
-    // C++ wrapper type for velocity_measure
-    typedef REAL velocity_measure;
-    // C++ wrapper type for volume_measure
-    typedef REAL volume_measure;
-    // C++ wrapper type for week_in_year_number
-    typedef INTEGER week_in_year_number;
-    // C++ wrapper type for work_item
-    typedef SELECT work_item;
-    // C++ wrapper type for year_number
-    typedef INTEGER year_number;
-
-
-	// ******************************************************************************
-	// StepFile Entities
-	// ******************************************************************************
-
-	struct measure_with_unit;
-	struct absorbed_dose_measure_with_unit;
-	struct derived_unit;
-	struct absorbed_dose_unit;
-	//struct abstract_variable;
-	struct acceleration_measure_with_unit;
-	struct acceleration_unit;
-	struct action;
-	struct action_assignment;
-	typedef NotImplemented action_directive; // (not currently used by Assimp)
-	struct action_method;
-	struct action_method_assignment;
-	struct action_method_relationship;
-	typedef NotImplemented action_method_role; // (not currently used by Assimp)
-	typedef NotImplemented action_property; // (not currently used by Assimp)
-	typedef NotImplemented action_property_representation; // (not currently used by Assimp)
-	typedef NotImplemented action_relationship; // (not currently used by Assimp)
-	struct action_request_assignment;
-	typedef NotImplemented action_request_solution; // (not currently used by Assimp)
-	typedef NotImplemented action_request_status; // (not currently used by Assimp)
-	typedef NotImplemented action_status; // (not currently used by Assimp)
-	struct address;
-	struct representation;
-	struct shape_representation;
-	struct advanced_brep_shape_representation;
-	struct face_surface;
-	struct advanced_face;
-	typedef NotImplemented alternate_product_relationship; // (not currently used by Assimp)
-	struct amount_of_substance_measure_with_unit;
-	struct named_unit;
-	struct amount_of_substance_unit;
-	struct angle_direction_reference;
-	struct representation_item;
-	struct geometric_representation_item;
-	struct draughting_callout;
-	struct dimension_curve_directed_callout;
-	struct angular_dimension;
-	struct shape_aspect_relationship;
-	struct dimensional_location;
-	struct angular_location;
-	struct dimensional_size;
-	struct angular_size;
-	struct geometric_tolerance;
-	struct geometric_tolerance_with_datum_reference;
-	struct angularity_tolerance;
-	struct styled_item;
-	struct annotation_occurrence;
-	struct annotation_curve_occurrence;
-	struct annotation_fill_area;
-	struct annotation_fill_area_occurrence;
-	struct annotation_occurrence_relationship;
-	struct annotation_occurrence_associativity;
-	struct annotation_plane;
-	struct annotation_symbol_occurrence;
-	struct annotation_subfigure_occurrence;
-	struct mapped_item;
-	struct annotation_symbol;
-	struct annotation_text;
-	struct annotation_text_character;
-	struct annotation_text_occurrence;
-	struct shape_aspect;
-	struct derived_shape_aspect;
-	struct apex;
-	typedef NotImplemented application_context; // (not currently used by Assimp)
-	struct application_context_element;
-	typedef NotImplemented application_protocol_definition; // (not currently used by Assimp)
-	struct applied_action_assignment;
-	struct applied_action_method_assignment;
-	struct applied_action_request_assignment;
-	struct approval_assignment;
-	struct applied_approval_assignment;
-	struct attribute_classification_assignment;
-	struct applied_attribute_classification_assignment;
-	struct certification_assignment;
-	struct applied_certification_assignment;
-	struct classification_assignment;
-	struct applied_classification_assignment;
-	struct contract_assignment;
-	struct applied_contract_assignment;
-	struct date_and_time_assignment;
-	struct applied_date_and_time_assignment;
-	struct date_assignment;
-	struct applied_date_assignment;
-	struct document_reference;
-	struct applied_document_reference;
-	struct document_usage_constraint_assignment;
-	struct applied_document_usage_constraint_assignment;
-	struct effectivity_assignment;
-	struct applied_effectivity_assignment;
-	struct event_occurrence_assignment;
-	struct applied_event_occurrence_assignment;
-	struct identification_assignment;
-	struct external_identification_assignment;
-	struct applied_external_identification_assignment;
-	struct group_assignment;
-	struct applied_group_assignment;
-	struct applied_identification_assignment;
-	struct name_assignment;
-	struct applied_name_assignment;
-	struct organization_assignment;
-	struct applied_organization_assignment;
-	struct organizational_project_assignment;
-	struct applied_organizational_project_assignment;
-	struct person_and_organization_assignment;
-	struct applied_person_and_organization_assignment;
-	//struct presented_item;
-	struct applied_presented_item;
-	struct security_classification_assignment;
-	struct applied_security_classification_assignment;
-	struct time_interval_assignment;
-	struct applied_time_interval_assignment;
-	struct applied_usage_right;
-	typedef NotImplemented approval; // (not currently used by Assimp)
-	typedef NotImplemented approval_date_time; // (not currently used by Assimp)
-	typedef NotImplemented approval_person_organization; // (not currently used by Assimp)
-	typedef NotImplemented approval_relationship; // (not currently used by Assimp)
-	typedef NotImplemented approval_role; // (not currently used by Assimp)
-	typedef NotImplemented approval_status; // (not currently used by Assimp)
-	struct area_in_set;
-	struct area_measure_with_unit;
-	struct area_unit;
-	struct product_definition_relationship;
-	struct product_definition_usage;
-	struct assembly_component_usage;
-	typedef NotImplemented assembly_component_usage_substitute; // (not currently used by Assimp)
-	struct assigned_requirement;
-	struct compound_representation_item;
-	struct atomic_formula;
-	struct attribute_assertion;
-	struct attribute_language_assignment;
-	struct attribute_value_assignment;
-	typedef NotImplemented attribute_value_role; // (not currently used by Assimp)
-	struct auxiliary_geometric_representation_item;
-	struct placement;
-	struct axis1_placement;
-	struct axis2_placement_2d;
-	struct axis2_placement_3d;
-	struct curve;
-	struct bounded_curve;
-	struct b_spline_curve;
-	struct b_spline_curve_with_knots;
-	struct surface;
-	struct bounded_surface;
-	struct b_spline_surface;
-	struct b_spline_surface_with_knots;
-	struct product_definition;
-	struct rule_software_definition;
-	struct rule_definition;
-	struct back_chaining_rule;
-	struct back_chaining_rule_body;
-	struct colour;
-	struct background_colour;
-	struct beveled_sheet_representation;
-	struct bezier_curve;
-	struct bezier_surface;
-	struct generic_expression;
-	struct binary_generic_expression;
-	struct binary_numeric_expression;
-	struct binary_representation_item;
-	struct block;
-	struct expression;
-	struct boolean_expression;
-	struct boolean_literal;
-	struct boolean_representation_item;
-	struct boolean_result;
-	struct composite_curve;
-	struct composite_curve_on_surface;
-	struct boundary_curve;
-	struct bounded_pcurve;
-	struct bounded_surface_curve;
-	struct founded_item;
-	struct box_domain;
-	struct half_space_solid;
-	struct boxed_half_space;
-	struct breakdown_context;
-	struct breakdown_element_group_assignment;
-	struct breakdown_element_realization;
-	struct breakdown_element_usage;
-	struct breakdown_of;
-	struct solid_model;
-	struct manifold_solid_brep;
-	struct brep_with_voids;
-	struct bytes_representation_item;
-	struct date;
-	struct calendar_date;
-	struct camera_image;
-	struct camera_image_3d_with_scale;
-	struct camera_model;
-	struct camera_model_d3;
-	struct camera_model_d3_multi_clipping;
-	struct camera_model_d3_multi_clipping_intersection;
-	struct camera_model_d3_multi_clipping_union;
-	struct camera_model_d3_with_hlhsr;
-	struct camera_model_with_light_sources;
-	struct representation_map;
-	struct camera_usage;
-	struct capacitance_measure_with_unit;
-	struct capacitance_unit;
-	struct point;
-	struct cartesian_point;
-	struct cartesian_transformation_operator;
-	struct cartesian_transformation_operator_2d;
-	struct cartesian_transformation_operator_3d;
-	struct cc_design_approval;
-	struct cc_design_certification;
-	struct cc_design_contract;
-	struct cc_design_date_and_time_assignment;
-	struct cc_design_person_and_organization_assignment;
-	struct cc_design_security_classification;
-	struct cc_design_specification_reference;
-	struct celsius_temperature_measure_with_unit;
-	struct centre_of_symmetry;
-	typedef NotImplemented certification; // (not currently used by Assimp)
-	typedef NotImplemented certification_type; // (not currently used by Assimp)
-	struct change;
-	struct change_request;
-	typedef NotImplemented character_glyph_font_usage; // (not currently used by Assimp)
-	struct character_glyph_style_outline;
-	struct character_glyph_style_stroke;
-	struct symbol_representation;
-	struct generic_character_glyph_symbol;
-	struct character_glyph_symbol;
-	struct character_glyph_symbol_outline;
-	struct character_glyph_symbol_stroke;
-	struct general_property;
-	struct characteristic_data_column_header;
-	struct general_property_relationship;
-	struct characteristic_data_column_header_link;
-	struct characteristic_data_table_header;
-	struct characteristic_data_table_header_decomposition;
-	struct group;
-	struct characteristic_type;
-	struct characterized_class;
-	struct characterized_object;
-	struct conic;
-	struct circle;
-	struct circular_runout_tolerance;
-	typedef NotImplemented class_t; // (not currently used by Assimp)
-	struct class_by_extension;
-	struct class_by_intension;
-	struct class_system;
-	struct effectivity_context_assignment;
-	struct class_usage_effectivity_context_assignment;
-	typedef NotImplemented classification_role; // (not currently used by Assimp)
-	struct topological_representation_item;
-	struct connected_face_set;
-	struct closed_shell;
-	struct coaxiality_tolerance;
-	struct colour_specification;
-	struct colour_rgb;
-	struct common_datum;
-	struct comparison_expression;
-	struct complex_clause;
-	struct complex_conjunctive_clause;
-	struct complex_disjunctive_clause;
-	struct modified_solid;
-	struct shelled_solid;
-	struct complex_shelled_solid;
-	struct composite_assembly_definition;
-	struct composite_assembly_sequence_definition;
-	struct laminate_table;
-	struct part_laminate_table;
-	struct composite_assembly_table;
-	struct composite_curve_segment;
-	struct material_designation;
-	struct composite_material_designation;
-	struct composite_shape_aspect;
-	struct composite_sheet_representation;
-	struct composite_text;
-	struct composite_text_with_associated_curves;
-	struct composite_text_with_blanking_box;
-	struct composite_text_with_delineation;
-	struct composite_text_with_extent;
-	struct compound_shape_representation;
-	struct concentricity_tolerance;
-	typedef NotImplemented concept_feature_operator; // (not currently used by Assimp)
-	struct concept_feature_relationship;
-	struct concept_feature_relationship_with_condition;
-	struct product_concept_feature;
-	struct conditional_concept_feature;
-	struct conductance_measure_with_unit;
-	struct conductance_unit;
-	struct configuration_item;
-	struct configurable_item;
-	typedef NotImplemented configuration_design; // (not currently used by Assimp)
-	struct effectivity;
-	struct product_definition_effectivity;
-	struct configuration_effectivity;
-	struct configuration_item_relationship;
-	struct configuration_item_hierarchical_relationship;
-	struct configuration_item_revision_sequence;
-	struct configured_effectivity_assignment;
-	struct configured_effectivity_context_assignment;
-	struct conical_stepped_hole_transition;
-	struct elementary_surface;
-	struct conical_surface;
-	struct connected_edge_set;
-	struct connected_face_sub_set;
-	struct constructive_geometry_representation;
-	struct representation_relationship;
-	struct constructive_geometry_representation_relationship;
-	struct contact_ratio_representation;
-	struct invisibility;
-	struct context_dependent_invisibility;
-	struct over_riding_styled_item;
-	struct context_dependent_over_riding_styled_item;
-	typedef NotImplemented context_dependent_shape_representation; // (not currently used by Assimp)
-	struct context_dependent_unit;
-	typedef NotImplemented contract; // (not currently used by Assimp)
-	typedef NotImplemented contract_relationship; // (not currently used by Assimp)
-	typedef NotImplemented contract_type; // (not currently used by Assimp)
-	struct conversion_based_unit;
-	typedef NotImplemented coordinated_universal_time_offset; // (not currently used by Assimp)
-	struct csg_shape_representation;
-	struct csg_solid;
-	struct currency;
-	struct currency_measure_with_unit;
-	struct curve_bounded_surface;
-	struct curve_dimension;
-	struct curve_replica;
-	struct curve_style;
-	struct curve_style_font;
-	struct curve_style_font_and_scaling;
-	struct curve_style_font_pattern;
-	typedef NotImplemented curve_style_rendering; // (not currently used by Assimp)
-	struct curve_swept_solid_shape_representation;
-	struct cylindrical_surface;
-	struct cylindricity_tolerance;
-	typedef NotImplemented data_environment; // (not currently used by Assimp)
-	typedef NotImplemented date_and_time; // (not currently used by Assimp)
-	struct date_representation_item;
-	typedef NotImplemented date_role; // (not currently used by Assimp)
-	struct date_time_representation_item;
-	typedef NotImplemented date_time_role; // (not currently used by Assimp)
-	struct dated_effectivity;
-	struct datum;
-	struct datum_feature;
-	struct datum_feature_callout;
-	struct datum_reference;
-	struct datum_target;
-	struct datum_target_callout;
-	struct default_tolerance_table;
-	struct default_tolerance_table_cell;
-	struct defined_symbol;
-	struct definitional_representation;
-	struct definitional_representation_relationship;
-	struct definitional_representation_relationship_with_same_context;
-	struct degenerate_pcurve;
-	struct toroidal_surface;
-	struct degenerate_toroidal_surface;
-	typedef NotImplemented derived_unit_element; // (not currently used by Assimp)
-	typedef NotImplemented description_attribute; // (not currently used by Assimp)
-	struct descriptive_representation_item;
-	struct product_definition_context;
-	struct design_context;
-	struct design_make_from_relationship;
-	struct diameter_dimension;
-	struct ratio_measure_with_unit;
-	struct dielectric_constant_measure_with_unit;
-	struct dimension_callout;
-	struct draughting_callout_relationship;
-	struct dimension_callout_component_relationship;
-	struct dimension_callout_relationship;
-	struct dimension_curve;
-	struct terminator_symbol;
-	struct dimension_curve_terminator;
-	struct dimension_curve_terminator_to_projection_curve_associativity;
-	struct dimension_pair;
-	typedef NotImplemented dimension_related_tolerance_zone_element; // (not currently used by Assimp)
-	struct dimension_text_associativity;
-	typedef NotImplemented dimensional_characteristic_representation; // (not currently used by Assimp)
-	typedef NotImplemented dimensional_exponents; // (not currently used by Assimp)
-	struct dimensional_location_with_path;
-	struct dimensional_size_with_path;
-	struct executed_action;
-	struct directed_action;
-	struct directed_dimensional_location;
-	struct direction;
-	typedef NotImplemented document; // (not currently used by Assimp)
-	struct document_file;
-	struct document_identifier;
-	struct document_identifier_assignment;
-	struct document_product_association;
-	struct document_product_equivalence;
-	typedef NotImplemented document_relationship; // (not currently used by Assimp)
-	typedef NotImplemented document_representation_type; // (not currently used by Assimp)
-	typedef NotImplemented document_type; // (not currently used by Assimp)
-	typedef NotImplemented document_usage_constraint; // (not currently used by Assimp)
-	typedef NotImplemented document_usage_role; // (not currently used by Assimp)
-	struct dose_equivalent_measure_with_unit;
-	struct dose_equivalent_unit;
-	struct double_offset_shelled_solid;
-	struct item_defined_transformation;
-	struct transformation_with_derived_angle;
-	struct draped_defined_transformation;
-	struct draughting_annotation_occurrence;
-	struct draughting_elements;
-	struct draughting_model;
-	struct item_identified_representation_usage;
-	struct draughting_model_item_association;
-	struct pre_defined_colour;
-	struct draughting_pre_defined_colour;
-	struct pre_defined_item;
-	struct pre_defined_curve_font;
-	struct draughting_pre_defined_curve_font;
-	struct pre_defined_text_font;
-	struct draughting_pre_defined_text_font;
-	struct draughting_subfigure_representation;
-	struct draughting_symbol_representation;
-	struct text_literal;
-	struct text_literal_with_delineation;
-	struct draughting_text_literal_with_delineation;
-	typedef NotImplemented draughting_title; // (not currently used by Assimp)
-	typedef NotImplemented drawing_definition; // (not currently used by Assimp)
-	struct presentation_set;
-	struct drawing_revision;
-	typedef NotImplemented drawing_revision_sequence; // (not currently used by Assimp)
-	struct presentation_representation;
-	struct presentation_area;
-	struct drawing_sheet_revision;
-	struct drawing_sheet_revision_sequence;
-	struct drawing_sheet_revision_usage;
-	struct edge;
-	struct edge_based_wireframe_model;
-	struct edge_based_wireframe_shape_representation;
-	struct edge_blended_solid;
-	struct edge_curve;
-	struct edge_loop;
-	typedef NotImplemented effectivity_context_role; // (not currently used by Assimp)
-	typedef NotImplemented effectivity_relationship; // (not currently used by Assimp)
-	struct electric_charge_measure_with_unit;
-	struct electric_charge_unit;
-	struct electric_current_measure_with_unit;
-	struct electric_current_unit;
-	struct electric_potential_measure_with_unit;
-	struct electric_potential_unit;
-	struct elementary_brep_shape_representation;
-	struct ellipse;
-	struct energy_measure_with_unit;
-	struct energy_unit;
-	struct property_definition;
-	struct fact_type;
-	struct entity_assertion;
-	struct enum_reference_prefix;
-	typedef NotImplemented environment; // (not currently used by Assimp)
-	struct evaluated_characteristic;
-	struct evaluated_degenerate_pcurve;
-	struct evaluation_product_definition;
-	struct event_occurrence;
-	typedef NotImplemented event_occurrence_relationship; // (not currently used by Assimp)
-	typedef NotImplemented event_occurrence_role; // (not currently used by Assimp)
-	struct product_concept_feature_category;
-	struct exclusive_product_concept_feature_category;
-	struct uncertainty_qualifier;
-	struct standard_uncertainty;
-	struct expanded_uncertainty;
-	struct representation_item_relationship;
-	struct explicit_procedural_representation_item_relationship;
-	struct explicit_procedural_geometric_representation_item_relationship;
-	struct explicit_procedural_representation_relationship;
-	struct explicit_procedural_shape_representation_relationship;
-	struct expression_conversion_based_unit;
-	struct extension;
-	struct extent;
-	struct external_source;
-	struct external_class_library;
-	typedef NotImplemented external_source_relationship; // (not currently used by Assimp)
-	struct externally_defined_class;
-	struct externally_defined_colour;
-	struct externally_defined_context_dependent_unit;
-	struct externally_defined_conversion_based_unit;
-	struct externally_defined_currency;
-	struct externally_defined_item;
-	struct externally_defined_curve_font;
-	struct externally_defined_dimension_definition;
-	struct externally_defined_general_property;
-	struct externally_defined_hatch_style;
-	typedef NotImplemented externally_defined_item_relationship; // (not currently used by Assimp)
-	struct externally_defined_marker;
-	struct picture_representation_item;
-	struct externally_defined_picture_representation_item;
-	struct externally_defined_representation_item;
-	struct externally_defined_string;
-	struct externally_defined_symbol;
-	struct externally_defined_terminator_symbol;
-	struct externally_defined_text_font;
-	struct externally_defined_tile;
-	struct externally_defined_tile_style;
-	struct swept_area_solid;
-	struct extruded_area_solid;
-	struct swept_face_solid;
-	struct extruded_face_solid;
-	struct extruded_face_solid_with_trim_conditions;
-	struct extruded_face_solid_with_draft_angle;
-	struct extruded_face_solid_with_multiple_draft_angles;
-	struct face;
-	struct face_based_surface_model;
-	struct face_bound;
-	struct face_outer_bound;
-	struct faceted_brep;
-	struct faceted_brep_shape_representation;
-	struct fill_area_style;
-	typedef NotImplemented fill_area_style_colour; // (not currently used by Assimp)
-	struct fill_area_style_hatching;
-	struct fill_area_style_tile_coloured_region;
-	struct fill_area_style_tile_curve_with_style;
-	struct fill_area_style_tile_symbol_with_style;
-	struct fill_area_style_tiles;
-	struct shape_representation_relationship;
-	struct flat_pattern_ply_representation_relationship;
-	struct flatness_tolerance;
-	struct force_measure_with_unit;
-	struct force_unit;
-	struct forward_chaining_rule;
-	struct forward_chaining_rule_premise;
-	struct frequency_measure_with_unit;
-	struct frequency_unit;
-	struct func;
-	struct functional_breakdown_context;
-	struct functional_element_usage;
-	typedef NotImplemented functionally_defined_transformation; // (not currently used by Assimp)
-	struct general_material_property;
-	typedef NotImplemented general_property_association; // (not currently used by Assimp)
-	struct simple_generic_expression;
-	struct generic_literal;
-	struct generic_variable;
-	struct geometric_alignment;
-	struct geometric_set;
-	struct geometric_curve_set;
-	struct geometric_intersection;
-	struct geometric_item_specific_usage;
-	struct geometric_model_element_relationship;
-	struct representation_context;
-	struct geometric_representation_context;
-	typedef NotImplemented geometric_tolerance_relationship; // (not currently used by Assimp)
-	struct geometric_tolerance_with_defined_unit;
-	struct geometrical_tolerance_callout;
-	struct geometrically_bounded_2d_wireframe_representation;
-	struct geometrically_bounded_surface_shape_representation;
-	struct geometrically_bounded_wireframe_shape_representation;
-	struct global_assignment;
-	struct global_uncertainty_assigned_context;
-	struct global_unit_assigned_context;
-	struct ground_fact;
-	typedef NotImplemented group_relationship; // (not currently used by Assimp)
-	struct hardness_representation;
-	struct hidden_element_over_riding_styled_item;
-	struct hyperbola;
-	typedef NotImplemented id_attribute; // (not currently used by Assimp)
-	typedef NotImplemented identification_role; // (not currently used by Assimp)
-	struct illuminance_measure_with_unit;
-	struct illuminance_unit;
-	struct included_text_block;
-	struct inclusion_product_concept_feature;
-	struct user_selected_elements;
-	struct indirectly_selected_elements;
-	struct indirectly_selected_shape_elements;
-	struct inductance_measure_with_unit;
-	struct inductance_unit;
-	struct information_right;
-	struct information_usage_right;
-	struct instance_usage_context_assignment;
-	struct instanced_feature;
-	struct literal_number;
-	struct int_literal;
-	struct integer_representation_item;
-	struct surface_curve;
-	struct intersection_curve;
-	struct interval_expression;
-	struct iso4217_currency;
-	struct known_source;
-	struct laid_defined_transformation;
-	struct language;
-	struct leader_curve;
-	struct leader_directed_callout;
-	struct leader_directed_dimension;
-	struct leader_terminator;
-	struct length_measure_with_unit;
-	struct length_unit;
-	struct light_source;
-	struct light_source_ambient;
-	struct light_source_directional;
-	struct light_source_positional;
-	struct light_source_spot;
-	typedef NotImplemented limits_and_fits; // (not currently used by Assimp)
-	struct line;
-	struct line_profile_tolerance;
-	struct linear_dimension;
-	struct simple_clause;
-	struct literal_conjunction;
-	struct literal_disjunction;
-	typedef NotImplemented local_time; // (not currently used by Assimp)
-	struct logical_literal;
-	struct logical_representation_item;
-	struct loop;
-	struct loss_tangent_measure_with_unit;
-	struct lot_effectivity;
-	struct luminous_flux_measure_with_unit;
-	struct luminous_flux_unit;
-	struct luminous_intensity_measure_with_unit;
-	struct luminous_intensity_unit;
-	struct magnetic_flux_density_measure_with_unit;
-	struct magnetic_flux_density_unit;
-	struct magnetic_flux_measure_with_unit;
-	struct magnetic_flux_unit;
-	struct make_from_usage_option;
-	struct manifold_subsurface_shape_representation;
-	struct manifold_surface_shape_representation;
-	struct mass_measure_with_unit;
-	struct mass_unit;
-	typedef NotImplemented material_designation_characterization; // (not currently used by Assimp)
-	struct material_property;
-	struct property_definition_representation;
-	struct material_property_representation;
-	typedef NotImplemented measure_qualification; // (not currently used by Assimp)
-	struct measure_representation_item;
-	struct product_context;
-	struct mechanical_context;
-	struct mechanical_design_and_draughting_relationship;
-	struct mechanical_design_geometric_presentation_area;
-	struct mechanical_design_geometric_presentation_representation;
-	struct mechanical_design_presentation_representation_with_draughting;
-	struct mechanical_design_shaded_presentation_area;
-	struct mechanical_design_shaded_presentation_representation;
-	struct min_and_major_ply_orientation_basis;
-	struct modified_geometric_tolerance;
-	struct modified_solid_with_placed_configuration;
-	struct moments_of_inertia_representation;
-	struct multi_language_attribute_assignment;
-	struct multiple_arity_boolean_expression;
-	struct multiple_arity_generic_expression;
-	struct multiple_arity_numeric_expression;
-	typedef NotImplemented name_attribute; // (not currently used by Assimp)
-	struct next_assembly_usage_occurrence;
-	struct non_manifold_surface_shape_representation;
-	struct null_representation_item;
-	struct numeric_expression;
-	typedef NotImplemented object_role; // (not currently used by Assimp)
-	struct offset_curve_2d;
-	struct offset_curve_3d;
-	struct offset_surface;
-	struct one_direction_repeat_factor;
-	struct open_shell;
-	struct ordinal_date;
-	struct projection_directed_callout;
-	struct ordinate_dimension;
-	typedef NotImplemented organization; // (not currently used by Assimp)
-	typedef NotImplemented organization_relationship; // (not currently used by Assimp)
-	typedef NotImplemented organization_role; // (not currently used by Assimp)
-	struct organizational_address;
-	typedef NotImplemented organizational_project; // (not currently used by Assimp)
-	typedef NotImplemented organizational_project_relationship; // (not currently used by Assimp)
-	typedef NotImplemented organizational_project_role; // (not currently used by Assimp)
-	struct oriented_closed_shell;
-	struct oriented_edge;
-	struct oriented_face;
-	struct oriented_open_shell;
-	struct path;
-	struct oriented_path;
-	struct oriented_surface;
-	struct outer_boundary_curve;
-	struct package_product_concept_feature;
-	struct parabola;
-	struct parallel_offset;
-	struct parallelism_tolerance;
-	struct parametric_representation_context;
-	struct partial_document_with_structured_text_representation_assignment;
-	struct pcurve;
-	struct percentage_laminate_definition;
-	struct zone_structural_makeup;
-	struct percentage_laminate_table;
-	struct percentage_ply_definition;
-	struct perpendicular_to;
-	struct perpendicularity_tolerance;
-	typedef NotImplemented person; // (not currently used by Assimp)
-	typedef NotImplemented person_and_organization; // (not currently used by Assimp)
-	struct person_and_organization_address;
-	typedef NotImplemented person_and_organization_role; // (not currently used by Assimp)
-	struct personal_address;
-	struct physical_breakdown_context;
-	struct physical_element_usage;
-	struct presentation_view;
-	struct picture_representation;
-	struct placed_datum_target_feature;
-	struct placed_feature;
-	struct planar_extent;
-	struct planar_box;
-	struct plane;
-	struct plane_angle_measure_with_unit;
-	struct plane_angle_unit;
-	typedef NotImplemented plus_minus_tolerance; // (not currently used by Assimp)
-	struct ply_laminate_definition;
-	struct ply_laminate_sequence_definition;
-	struct ply_laminate_table;
-	struct point_and_vector;
-	struct point_on_curve;
-	struct point_on_surface;
-	struct point_path;
-	struct point_replica;
-	struct point_style;
-	struct polar_complex_number_literal;
-	struct poly_loop;
-	struct polyline;
-	struct position_tolerance;
-	struct positioned_sketch;
-	struct power_measure_with_unit;
-	struct power_unit;
-	struct pre_defined_symbol;
-	struct pre_defined_dimension_symbol;
-	struct pre_defined_geometrical_tolerance_symbol;
-	struct pre_defined_marker;
-	struct pre_defined_point_marker_symbol;
-	struct pre_defined_surface_condition_symbol;
-	struct pre_defined_surface_side_style;
-	struct pre_defined_terminator_symbol;
-	struct pre_defined_tile;
-	typedef NotImplemented precision_qualifier; // (not currently used by Assimp)
-	struct predefined_picture_representation_item;
-	typedef NotImplemented presentation_layer_assignment; // (not currently used by Assimp)
-	typedef NotImplemented presentation_size; // (not currently used by Assimp)
-	struct presentation_style_assignment;
-	struct presentation_style_by_context;
-	typedef NotImplemented presented_item_representation; // (not currently used by Assimp)
-	struct pressure_measure_with_unit;
-	struct pressure_unit;
-	struct procedural_representation;
-	struct procedural_representation_sequence;
-	struct procedural_shape_representation;
-	struct procedural_shape_representation_sequence;
-	typedef NotImplemented product; // (not currently used by Assimp)
-	struct product_category;
-	struct product_class;
-	typedef NotImplemented product_concept; // (not currently used by Assimp)
-	struct product_concept_context;
-	typedef NotImplemented product_concept_feature_association; // (not currently used by Assimp)
-	struct product_concept_feature_category_usage;
-	typedef NotImplemented product_concept_relationship; // (not currently used by Assimp)
-	typedef NotImplemented product_definition_context_association; // (not currently used by Assimp)
-	typedef NotImplemented product_definition_context_role; // (not currently used by Assimp)
-	struct product_definition_element_relationship;
-	struct product_definition_formation;
-	typedef NotImplemented product_definition_formation_relationship; // (not currently used by Assimp)
-	struct product_definition_formation_with_specified_source;
-	struct product_definition_group_assignment;
-	typedef NotImplemented product_definition_occurrence_relationship; // (not currently used by Assimp)
-	struct product_definition_shape;
-	typedef NotImplemented product_definition_substitute; // (not currently used by Assimp)
-	struct product_definition_with_associated_documents;
-	struct product_identification;
-	struct product_material_composition_relationship;
-	struct product_related_product_category;
-	struct product_specification;
-	struct tolerance_zone_definition;
-	struct projected_zone_definition;
-	struct projection_curve;
-	struct promissory_usage_occurrence;
-	typedef NotImplemented property_definition_relationship; // (not currently used by Assimp)
-	struct qualified_representation_item;
-	struct qualitative_uncertainty;
-	struct quantified_assembly_component_usage;
-	struct quasi_uniform_curve;
-	struct quasi_uniform_surface;
-	struct radioactivity_measure_with_unit;
-	struct radioactivity_unit;
-	struct radius_dimension;
-	struct range_characteristic;
-	struct ratio_unit;
-	struct rational_b_spline_curve;
-	struct rational_b_spline_surface;
-	struct rational_representation_item;
-	struct real_literal;
-	struct real_representation_item;
-	struct rectangular_composite_surface;
-	struct rectangular_trimmed_surface;
-	struct referenced_modified_datum;
-	struct relative_event_occurrence;
-	struct rep_item_group;
-	struct reparametrised_composite_curve_segment;
-	struct representation_relationship_with_transformation;
-	struct requirement_assigned_object;
-	struct requirement_assignment;
-	struct requirement_source;
-	struct requirement_view_definition_relationship;
-	struct resistance_measure_with_unit;
-	struct resistance_unit;
-	struct revolved_area_solid;
-	struct revolved_face_solid;
-	struct revolved_face_solid_with_trim_conditions;
-	struct right_angular_wedge;
-	struct right_circular_cone;
-	struct right_circular_cylinder;
-	struct right_to_usage_association;
-	typedef NotImplemented role_association; // (not currently used by Assimp)
-	struct roundness_tolerance;
-	struct row_representation_item;
-	struct row_value;
-	struct row_variable;
-	struct rule_action;
-	struct rule_condition;
-	struct rule_set;
-	struct rule_set_group;
-	struct rule_superseded_assignment;
-	struct rule_supersedence;
-	struct surface_curve_swept_area_solid;
-	struct ruled_surface_swept_area_solid;
-	struct runout_zone_definition;
-	struct runout_zone_orientation;
-	struct runout_zone_orientation_reference_direction;
-	struct satisfied_requirement;
-	struct satisfies_requirement;
-	struct satisfying_item;
-	struct scalar_variable;
-	struct scattering_parameter;
-	struct sculptured_solid;
-	struct seam_curve;
-	typedef NotImplemented security_classification; // (not currently used by Assimp)
-	typedef NotImplemented security_classification_level; // (not currently used by Assimp)
-	struct serial_numbered_effectivity;
-	struct shape_aspect_associativity;
-	struct shape_aspect_deriving_relationship;
-	struct shape_definition_representation;
-	struct shape_dimension_representation;
-	struct shape_feature_definition;
-	struct shape_representation_with_parameters;
-	struct shell_based_surface_model;
-	struct shell_based_wireframe_model;
-	struct shell_based_wireframe_shape_representation;
-	struct si_absorbed_dose_unit;
-	struct si_capacitance_unit;
-	struct si_conductance_unit;
-	struct si_dose_equivalent_unit;
-	struct si_electric_charge_unit;
-	struct si_electric_potential_unit;
-	struct si_energy_unit;
-	struct si_force_unit;
-	struct si_frequency_unit;
-	struct si_illuminance_unit;
-	struct si_inductance_unit;
-	struct si_magnetic_flux_density_unit;
-	struct si_magnetic_flux_unit;
-	struct si_power_unit;
-	struct si_pressure_unit;
-	struct si_radioactivity_unit;
-	struct si_resistance_unit;
-	struct si_unit;
-	struct simple_boolean_expression;
-	struct simple_numeric_expression;
-	struct slash_expression;
-	struct smeared_material_definition;
-	struct solid_angle_measure_with_unit;
-	struct solid_angle_unit;
-	struct solid_curve_font;
-	struct solid_replica;
-	struct solid_with_chamfered_edges;
-	struct solid_with_angle_based_chamfer;
-	struct solid_with_shape_element_pattern;
-	struct solid_with_circular_pattern;
-	struct solid_with_depression;
-	struct solid_with_pocket;
-	struct solid_with_circular_pocket;
-	struct solid_with_protrusion;
-	struct solid_with_circular_protrusion;
-	struct solid_with_hole;
-	struct solid_with_stepped_round_hole;
-	struct solid_with_conical_bottom_round_hole;
-	struct solid_with_constant_radius_edge_blend;
-	struct solid_with_slot;
-	struct solid_with_curved_slot;
-	struct solid_with_double_offset_chamfer;
-	struct solid_with_flat_bottom_round_hole;
-	struct solid_with_general_pocket;
-	struct solid_with_general_protrusion;
-	struct solid_with_groove;
-	struct solid_with_incomplete_circular_pattern;
-	struct solid_with_rectangular_pattern;
-	struct solid_with_incomplete_rectangular_pattern;
-	struct solid_with_rectangular_pocket;
-	struct solid_with_rectangular_protrusion;
-	struct solid_with_single_offset_chamfer;
-	struct solid_with_spherical_bottom_round_hole;
-	struct solid_with_stepped_round_hole_and_conical_transitions;
-	struct solid_with_straight_slot;
-	struct solid_with_tee_section_slot;
-	struct solid_with_through_depression;
-	struct solid_with_trapezoidal_section_slot;
-	struct solid_with_variable_radius_edge_blend;
-	struct source_for_requirement;
-	struct sourced_requirement;
-	struct specification_definition;
-	struct specified_higher_usage_occurrence;
-	struct sphere;
-	struct spherical_surface;
-	struct start_request;
-	struct start_work;
-	struct straightness_tolerance;
-	struct structured_dimension_callout;
-	struct structured_text_composition;
-	struct structured_text_representation;
-	struct subedge;
-	struct subface;
-	struct supplied_part_relationship;
-	struct surface_condition_callout;
-	struct swept_surface;
-	struct surface_of_linear_extrusion;
-	struct surface_of_revolution;
-	struct surface_patch;
-	struct surface_profile_tolerance;
-	typedef NotImplemented surface_rendering_properties; // (not currently used by Assimp)
-	struct surface_replica;
-	struct surface_side_style;
-	struct surface_style_boundary;
-	struct surface_style_control_grid;
-	struct surface_style_fill_area;
-	struct surface_style_parameter_line;
-	struct surface_style_reflectance_ambient;
-	struct surface_style_reflectance_ambient_diffuse;
-	struct surface_style_reflectance_ambient_diffuse_specular;
-	struct surface_style_rendering;
-	struct surface_style_rendering_with_properties;
-	struct surface_style_segmentation_curve;
-	struct surface_style_silhouette;
-	typedef NotImplemented surface_style_transparent; // (not currently used by Assimp)
-	struct surface_style_usage;
-	struct surface_texture_representation;
-	struct surfaced_open_shell;
-	struct swept_disk_solid;
-	struct symbol;
-	typedef NotImplemented symbol_colour; // (not currently used by Assimp)
-	struct symbol_representation_map;
-	struct symbol_style;
-	struct symbol_target;
-	struct symmetric_shape_aspect;
-	struct symmetry_tolerance;
-	struct table_representation_item;
-	struct tactile_appearance_representation;
-	struct tagged_text_format;
-	struct tagged_text_item;
-	struct tangent;
-	typedef NotImplemented text_font; // (not currently used by Assimp)
-	typedef NotImplemented text_font_family; // (not currently used by Assimp)
-	typedef NotImplemented text_font_in_family; // (not currently used by Assimp)
-	struct text_literal_with_associated_curves;
-	struct text_literal_with_blanking_box;
-	struct text_literal_with_extent;
-	struct text_string_representation;
-	struct text_style;
-	typedef NotImplemented text_style_for_defined_font; // (not currently used by Assimp)
-	struct text_style_with_box_characteristics;
-	struct text_style_with_mirror;
-	struct text_style_with_spacing;
-	struct thermal_resistance_measure_with_unit;
-	struct thermal_resistance_unit;
-	struct thermodynamic_temperature_measure_with_unit;
-	struct thermodynamic_temperature_unit;
-	struct thickened_face_solid;
-	struct thickness_laminate_definition;
-	struct thickness_laminate_table;
-	struct time_interval;
-	struct time_interval_based_effectivity;
-	typedef NotImplemented time_interval_relationship; // (not currently used by Assimp)
-	typedef NotImplemented time_interval_role; // (not currently used by Assimp)
-	struct time_interval_with_bounds;
-	struct time_measure_with_unit;
-	struct time_unit;
-	typedef NotImplemented tolerance_value; // (not currently used by Assimp)
-	struct tolerance_zone;
-	typedef NotImplemented tolerance_zone_form; // (not currently used by Assimp)
-	struct torus;
-	struct total_runout_tolerance;
-	struct track_blended_solid;
-	struct track_blended_solid_with_end_conditions;
-	struct trimmed_curve;
-	struct two_direction_repeat_factor;
-	typedef NotImplemented type_qualifier; // (not currently used by Assimp)
-	struct unary_generic_expression;
-	struct unary_numeric_expression;
-	struct uncertainty_assigned_representation;
-	struct uncertainty_measure_with_unit;
-	struct uniform_curve;
-	struct uniform_resource_identifier;
-	struct uniform_surface;
-	struct usage_association;
-	struct user_defined_curve_font;
-	struct user_defined_marker;
-	struct user_defined_terminator_symbol;
-	struct user_selected_shape_elements;
-	struct value_range;
-	struct value_representation_item;
-	struct variable_semantics;
-	struct variational_representation_item;
-	struct vector;
-	struct vector_style;
-	struct velocity_measure_with_unit;
-	struct velocity_unit;
-	typedef NotImplemented versioned_action_request; // (not currently used by Assimp)
-	struct vertex;
-	struct vertex_loop;
-	struct vertex_point;
-	struct vertex_shell;
-	struct view_volume;
-	struct visual_appearance_representation;
-	struct volume_measure_with_unit;
-	struct volume_unit;
-	struct week_of_year_and_day_date;
-	struct wire_shell;
-	struct year_month;
-
-
-
-    // C++ wrapper for measure_with_unit
-    struct measure_with_unit :  ObjectHelper<measure_with_unit,2> { measure_with_unit() : Object("measure_with_unit") {}
-		measure_value::Out value_component;
-		unit::Out unit_component;
-    };
-
-    // C++ wrapper for absorbed_dose_measure_with_unit
-    struct absorbed_dose_measure_with_unit : measure_with_unit, ObjectHelper<absorbed_dose_measure_with_unit,0> { absorbed_dose_measure_with_unit() : Object("absorbed_dose_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for derived_unit
-    struct derived_unit :  ObjectHelper<derived_unit,1> { derived_unit() : Object("derived_unit") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > elements;
-    };
-
-    // C++ wrapper for absorbed_dose_unit
-    struct absorbed_dose_unit : derived_unit, ObjectHelper<absorbed_dose_unit,0> { absorbed_dose_unit() : Object("absorbed_dose_unit") {}
-
-    };
-
-    // C++ wrapper for abstract_variable
-    struct abstract_variable :  ObjectHelper<abstract_variable,0> { abstract_variable() : Object("abstract_variable") {}
-
-    };
-
-    // C++ wrapper for acceleration_measure_with_unit
-    struct acceleration_measure_with_unit : measure_with_unit, ObjectHelper<acceleration_measure_with_unit,0> { acceleration_measure_with_unit() : Object("acceleration_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for acceleration_unit
-    struct acceleration_unit : derived_unit, ObjectHelper<acceleration_unit,0> { acceleration_unit() : Object("acceleration_unit") {}
-
-    };
-
-    // C++ wrapper for action
-    struct action :  ObjectHelper<action,3> { action() : Object("action") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< action_method > chosen_method;
-    };
-
-    // C++ wrapper for action_assignment
-    struct action_assignment :  ObjectHelper<action_assignment,1> { action_assignment() : Object("action_assignment") {}
-		Lazy< action > assigned_action;
-    };
-
-    // C++ wrapper for action_method
-    struct action_method :  ObjectHelper<action_method,4> { action_method() : Object("action_method") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		text::Out consequence;
-		text::Out purpose;
-    };
-
-    // C++ wrapper for action_method_assignment
-    struct action_method_assignment :  ObjectHelper<action_method_assignment,2> { action_method_assignment() : Object("action_method_assignment") {}
-		Lazy< action_method > assigned_action_method;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for action_method_relationship
-    struct action_method_relationship :  ObjectHelper<action_method_relationship,4> { action_method_relationship() : Object("action_method_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< action_method > relating_method;
-		Lazy< action_method > related_method;
-    };
-
-    // C++ wrapper for action_request_assignment
-    struct action_request_assignment :  ObjectHelper<action_request_assignment,1> { action_request_assignment() : Object("action_request_assignment") {}
-		Lazy< NotImplemented > assigned_action_request;
-    };
-
-    // C++ wrapper for address
-    struct address :  ObjectHelper<address,12> { address() : Object("address") {}
-		Maybe< label::Out > internal_location;
-		Maybe< label::Out > street_number;
-		Maybe< label::Out > street;
-		Maybe< label::Out > postal_box;
-		Maybe< label::Out > town;
-		Maybe< label::Out > region;
-		Maybe< label::Out > postal_code;
-		Maybe< label::Out > country;
-		Maybe< label::Out > facsimile_number;
-		Maybe< label::Out > telephone_number;
-		Maybe< label::Out > electronic_mail_address;
-		Maybe< label::Out > telex_number;
-    };
-
-    // C++ wrapper for representation
-    struct representation :  ObjectHelper<representation,3> { representation() : Object("representation") {}
-		label::Out name;
-		ListOf< Lazy< representation_item >, 1, 0 > items;
-		Lazy< representation_context > context_of_items;
-    };
-
-    // C++ wrapper for shape_representation
-    struct shape_representation : representation, ObjectHelper<shape_representation,0> { shape_representation() : Object("shape_representation") {}
-
-    };
-
-    // C++ wrapper for advanced_brep_shape_representation
-    struct advanced_brep_shape_representation : shape_representation, ObjectHelper<advanced_brep_shape_representation,0> { advanced_brep_shape_representation() : Object("advanced_brep_shape_representation") {}
-
-    };
-
-    // C++ wrapper for face_surface
-    struct face_surface :  ObjectHelper<face_surface,2> { face_surface() : Object("face_surface") {}
-		Lazy< surface > face_geometry;
-		BOOLEAN::Out same_sense;
-    };
-
-    // C++ wrapper for advanced_face
-    struct advanced_face : face_surface, ObjectHelper<advanced_face,0> { advanced_face() : Object("advanced_face") {}
-
-    };
-
-    // C++ wrapper for amount_of_substance_measure_with_unit
-    struct amount_of_substance_measure_with_unit : measure_with_unit, ObjectHelper<amount_of_substance_measure_with_unit,0> { amount_of_substance_measure_with_unit() : Object("amount_of_substance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for named_unit
-    struct named_unit :  ObjectHelper<named_unit,1> { named_unit() : Object("named_unit") {}
-		Lazy< NotImplemented > dimensions;
-    };
-
-    // C++ wrapper for amount_of_substance_unit
-    struct amount_of_substance_unit : named_unit, ObjectHelper<amount_of_substance_unit,0> { amount_of_substance_unit() : Object("amount_of_substance_unit") {}
-
-    };
-
-    // C++ wrapper for angle_direction_reference
-    struct angle_direction_reference :  ObjectHelper<angle_direction_reference,0> { angle_direction_reference() : Object("angle_direction_reference") {}
-
-    };
-
-    // C++ wrapper for representation_item
-    struct representation_item :  ObjectHelper<representation_item,1> { representation_item() : Object("representation_item") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for geometric_representation_item
-    struct geometric_representation_item : representation_item, ObjectHelper<geometric_representation_item,0> { geometric_representation_item() : Object("geometric_representation_item") {}
-
-    };
-
-    // C++ wrapper for draughting_callout
-    struct draughting_callout : geometric_representation_item, ObjectHelper<draughting_callout,1> { draughting_callout() : Object("draughting_callout") {}
-		ListOf< draughting_callout_element, 1, 0 >::Out contents;
-    };
-
-    // C++ wrapper for dimension_curve_directed_callout
-    struct dimension_curve_directed_callout : draughting_callout, ObjectHelper<dimension_curve_directed_callout,0> { dimension_curve_directed_callout() : Object("dimension_curve_directed_callout") {}
-
-    };
-
-    // C++ wrapper for angular_dimension
-    struct angular_dimension : dimension_curve_directed_callout, ObjectHelper<angular_dimension,0> { angular_dimension() : Object("angular_dimension") {}
-
-    };
-
-    // C++ wrapper for shape_aspect_relationship
-    struct shape_aspect_relationship :  ObjectHelper<shape_aspect_relationship,4> { shape_aspect_relationship() : Object("shape_aspect_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< shape_aspect > relating_shape_aspect;
-		Lazy< shape_aspect > related_shape_aspect;
-    };
-
-    // C++ wrapper for dimensional_location
-    struct dimensional_location : shape_aspect_relationship, ObjectHelper<dimensional_location,0> { dimensional_location() : Object("dimensional_location") {}
-
-    };
-
-    // C++ wrapper for angular_location
-    struct angular_location : dimensional_location, ObjectHelper<angular_location,1> { angular_location() : Object("angular_location") {}
-		angle_relator::Out angle_selection;
-    };
-
-    // C++ wrapper for dimensional_size
-    struct dimensional_size :  ObjectHelper<dimensional_size,2> { dimensional_size() : Object("dimensional_size") {}
-		Lazy< shape_aspect > applies_to;
-		label::Out name;
-    };
-
-    // C++ wrapper for angular_size
-    struct angular_size : dimensional_size, ObjectHelper<angular_size,1> { angular_size() : Object("angular_size") {}
-		angle_relator::Out angle_selection;
-    };
-
-    // C++ wrapper for geometric_tolerance
-    struct geometric_tolerance :  ObjectHelper<geometric_tolerance,4> { geometric_tolerance() : Object("geometric_tolerance") {}
-		label::Out name;
-		text::Out description;
-		Lazy< measure_with_unit > magnitude;
-		Lazy< shape_aspect > toleranced_shape_aspect;
-    };
-
-    // C++ wrapper for geometric_tolerance_with_datum_reference
-    struct geometric_tolerance_with_datum_reference : geometric_tolerance, ObjectHelper<geometric_tolerance_with_datum_reference,1> { geometric_tolerance_with_datum_reference() : Object("geometric_tolerance_with_datum_reference") {}
-		ListOf< Lazy< datum_reference >, 1, 0 > datum_system;
-    };
-
-    // C++ wrapper for angularity_tolerance
-    struct angularity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<angularity_tolerance,0> { angularity_tolerance() : Object("angularity_tolerance") {}
-
-    };
-
-    // C++ wrapper for styled_item
-    struct styled_item : representation_item, ObjectHelper<styled_item,2> { styled_item() : Object("styled_item") {}
-		ListOf< Lazy< presentation_style_assignment >, 1, 0 > styles;
-		Lazy< representation_item > item;
-    };
-
-    // C++ wrapper for annotation_occurrence
-    struct annotation_occurrence : styled_item, ObjectHelper<annotation_occurrence,0> { annotation_occurrence() : Object("annotation_occurrence") {}
-
-    };
-
-    // C++ wrapper for annotation_curve_occurrence
-    struct annotation_curve_occurrence : annotation_occurrence, ObjectHelper<annotation_curve_occurrence,0> { annotation_curve_occurrence() : Object("annotation_curve_occurrence") {}
-
-    };
-
-    // C++ wrapper for annotation_fill_area
-    struct annotation_fill_area : geometric_representation_item, ObjectHelper<annotation_fill_area,1> { annotation_fill_area() : Object("annotation_fill_area") {}
-		ListOf< Lazy< curve >, 1, 0 > boundaries;
-    };
-
-    // C++ wrapper for annotation_fill_area_occurrence
-    struct annotation_fill_area_occurrence : annotation_occurrence, ObjectHelper<annotation_fill_area_occurrence,1> { annotation_fill_area_occurrence() : Object("annotation_fill_area_occurrence") {}
-		Lazy< point > fill_style_target;
-    };
-
-    // C++ wrapper for annotation_occurrence_relationship
-    struct annotation_occurrence_relationship :  ObjectHelper<annotation_occurrence_relationship,4> { annotation_occurrence_relationship() : Object("annotation_occurrence_relationship") {}
-		label::Out name;
-		text::Out description;
-		Lazy< annotation_occurrence > relating_annotation_occurrence;
-		Lazy< annotation_occurrence > related_annotation_occurrence;
-    };
-
-    // C++ wrapper for annotation_occurrence_associativity
-    struct annotation_occurrence_associativity : annotation_occurrence_relationship, ObjectHelper<annotation_occurrence_associativity,0> { annotation_occurrence_associativity() : Object("annotation_occurrence_associativity") {}
-
-    };
-
-    // C++ wrapper for annotation_plane
-    struct annotation_plane :  ObjectHelper<annotation_plane,1> { annotation_plane() : Object("annotation_plane") {}
-		Maybe< ListOf< annotation_plane_element, 1, 0 >::Out > elements;
-    };
-
-    // C++ wrapper for annotation_symbol_occurrence
-    struct annotation_symbol_occurrence : annotation_occurrence, ObjectHelper<annotation_symbol_occurrence,0> { annotation_symbol_occurrence() : Object("annotation_symbol_occurrence") {}
-
-    };
-
-    // C++ wrapper for annotation_subfigure_occurrence
-    struct annotation_subfigure_occurrence : annotation_symbol_occurrence, ObjectHelper<annotation_subfigure_occurrence,0> { annotation_subfigure_occurrence() : Object("annotation_subfigure_occurrence") {}
-
-    };
-
-    // C++ wrapper for mapped_item
-    struct mapped_item : representation_item, ObjectHelper<mapped_item,2> { mapped_item() : Object("mapped_item") {}
-		Lazy< representation_map > mapping_source;
-		Lazy< representation_item > mapping_target;
-    };
-
-    // C++ wrapper for annotation_symbol
-    struct annotation_symbol : mapped_item, ObjectHelper<annotation_symbol,0> { annotation_symbol() : Object("annotation_symbol") {}
-
-    };
-
-    // C++ wrapper for annotation_text
-    struct annotation_text : mapped_item, ObjectHelper<annotation_text,0> { annotation_text() : Object("annotation_text") {}
-
-    };
-
-    // C++ wrapper for annotation_text_character
-    struct annotation_text_character : mapped_item, ObjectHelper<annotation_text_character,1> { annotation_text_character() : Object("annotation_text_character") {}
-		text_alignment::Out alignment;
-    };
-
-    // C++ wrapper for annotation_text_occurrence
-    struct annotation_text_occurrence : annotation_occurrence, ObjectHelper<annotation_text_occurrence,0> { annotation_text_occurrence() : Object("annotation_text_occurrence") {}
-
-    };
-
-    // C++ wrapper for shape_aspect
-    struct shape_aspect :  ObjectHelper<shape_aspect,4> { shape_aspect() : Object("shape_aspect") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< product_definition_shape > of_shape;
-		LOGICAL::Out product_definitional;
-    };
-
-    // C++ wrapper for derived_shape_aspect
-    struct derived_shape_aspect : shape_aspect, ObjectHelper<derived_shape_aspect,0> { derived_shape_aspect() : Object("derived_shape_aspect") {}
-
-    };
-
-    // C++ wrapper for apex
-    struct apex : derived_shape_aspect, ObjectHelper<apex,0> { apex() : Object("apex") {}
-
-    };
-
-    // C++ wrapper for application_context_element
-    struct application_context_element :  ObjectHelper<application_context_element,2> { application_context_element() : Object("application_context_element") {}
-		label::Out name;
-		Lazy< NotImplemented > frame_of_reference;
-    };
-
-    // C++ wrapper for applied_action_assignment
-    struct applied_action_assignment : action_assignment, ObjectHelper<applied_action_assignment,1> { applied_action_assignment() : Object("applied_action_assignment") {}
-		ListOf< action_items, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_action_method_assignment
-    struct applied_action_method_assignment : action_method_assignment, ObjectHelper<applied_action_method_assignment,1> { applied_action_method_assignment() : Object("applied_action_method_assignment") {}
-		ListOf< action_method_items, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_action_request_assignment
-    struct applied_action_request_assignment : action_request_assignment, ObjectHelper<applied_action_request_assignment,1> { applied_action_request_assignment() : Object("applied_action_request_assignment") {}
-		ListOf< action_request_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for approval_assignment
-    struct approval_assignment :  ObjectHelper<approval_assignment,1> { approval_assignment() : Object("approval_assignment") {}
-		Lazy< NotImplemented > assigned_approval;
-    };
-
-    // C++ wrapper for applied_approval_assignment
-    struct applied_approval_assignment : approval_assignment, ObjectHelper<applied_approval_assignment,1> { applied_approval_assignment() : Object("applied_approval_assignment") {}
-		ListOf< approval_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for attribute_classification_assignment
-    struct attribute_classification_assignment :  ObjectHelper<attribute_classification_assignment,3> { attribute_classification_assignment() : Object("attribute_classification_assignment") {}
-		Lazy< group > assigned_class;
-		label::Out attribute_name;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_attribute_classification_assignment
-    struct applied_attribute_classification_assignment : attribute_classification_assignment, ObjectHelper<applied_attribute_classification_assignment,1> { applied_attribute_classification_assignment() : Object("applied_attribute_classification_assignment") {}
-		ListOf< attribute_classification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for certification_assignment
-    struct certification_assignment :  ObjectHelper<certification_assignment,1> { certification_assignment() : Object("certification_assignment") {}
-		Lazy< NotImplemented > assigned_certification;
-    };
-
-    // C++ wrapper for applied_certification_assignment
-    struct applied_certification_assignment : certification_assignment, ObjectHelper<applied_certification_assignment,1> { applied_certification_assignment() : Object("applied_certification_assignment") {}
-		ListOf< certification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for classification_assignment
-    struct classification_assignment :  ObjectHelper<classification_assignment,2> { classification_assignment() : Object("classification_assignment") {}
-		Lazy< group > assigned_class;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_classification_assignment
-    struct applied_classification_assignment : classification_assignment, ObjectHelper<applied_classification_assignment,1> { applied_classification_assignment() : Object("applied_classification_assignment") {}
-		ListOf< classification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for contract_assignment
-    struct contract_assignment :  ObjectHelper<contract_assignment,1> { contract_assignment() : Object("contract_assignment") {}
-		Lazy< NotImplemented > assigned_contract;
-    };
-
-    // C++ wrapper for applied_contract_assignment
-    struct applied_contract_assignment : contract_assignment, ObjectHelper<applied_contract_assignment,1> { applied_contract_assignment() : Object("applied_contract_assignment") {}
-		ListOf< contract_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for date_and_time_assignment
-    struct date_and_time_assignment :  ObjectHelper<date_and_time_assignment,2> { date_and_time_assignment() : Object("date_and_time_assignment") {}
-		Lazy< NotImplemented > assigned_date_and_time;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_date_and_time_assignment
-    struct applied_date_and_time_assignment : date_and_time_assignment, ObjectHelper<applied_date_and_time_assignment,1> { applied_date_and_time_assignment() : Object("applied_date_and_time_assignment") {}
-		ListOf< date_and_time_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for date_assignment
-    struct date_assignment :  ObjectHelper<date_assignment,2> { date_assignment() : Object("date_assignment") {}
-		Lazy< date > assigned_date;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_date_assignment
-    struct applied_date_assignment : date_assignment, ObjectHelper<applied_date_assignment,1> { applied_date_assignment() : Object("applied_date_assignment") {}
-		ListOf< date_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for document_reference
-    struct document_reference :  ObjectHelper<document_reference,2> { document_reference() : Object("document_reference") {}
-		Lazy< NotImplemented > assigned_document;
-		label::Out source;
-    };
-
-    // C++ wrapper for applied_document_reference
-    struct applied_document_reference : document_reference, ObjectHelper<applied_document_reference,1> { applied_document_reference() : Object("applied_document_reference") {}
-		ListOf< document_reference_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for document_usage_constraint_assignment
-    struct document_usage_constraint_assignment :  ObjectHelper<document_usage_constraint_assignment,2> { document_usage_constraint_assignment() : Object("document_usage_constraint_assignment") {}
-		Lazy< NotImplemented > assigned_document_usage;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_document_usage_constraint_assignment
-    struct applied_document_usage_constraint_assignment : document_usage_constraint_assignment, ObjectHelper<applied_document_usage_constraint_assignment,1> { applied_document_usage_constraint_assignment() : Object("applied_document_usage_constraint_assignment") {}
-		ListOf< document_reference_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for effectivity_assignment
-    struct effectivity_assignment :  ObjectHelper<effectivity_assignment,1> { effectivity_assignment() : Object("effectivity_assignment") {}
-		Lazy< effectivity > assigned_effectivity;
-    };
-
-    // C++ wrapper for applied_effectivity_assignment
-    struct applied_effectivity_assignment : effectivity_assignment, ObjectHelper<applied_effectivity_assignment,1> { applied_effectivity_assignment() : Object("applied_effectivity_assignment") {}
-		ListOf< effectivity_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for event_occurrence_assignment
-    struct event_occurrence_assignment :  ObjectHelper<event_occurrence_assignment,2> { event_occurrence_assignment() : Object("event_occurrence_assignment") {}
-		Lazy< event_occurrence > assigned_event_occurrence;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_event_occurrence_assignment
-    struct applied_event_occurrence_assignment : event_occurrence_assignment, ObjectHelper<applied_event_occurrence_assignment,1> { applied_event_occurrence_assignment() : Object("applied_event_occurrence_assignment") {}
-		ListOf< event_occurrence_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for identification_assignment
-    struct identification_assignment :  ObjectHelper<identification_assignment,2> { identification_assignment() : Object("identification_assignment") {}
-		identifier::Out assigned_id;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for external_identification_assignment
-    struct external_identification_assignment : identification_assignment, ObjectHelper<external_identification_assignment,1> { external_identification_assignment() : Object("external_identification_assignment") {}
-		Lazy< external_source > source;
-    };
-
-    // C++ wrapper for applied_external_identification_assignment
-    struct applied_external_identification_assignment : external_identification_assignment, ObjectHelper<applied_external_identification_assignment,1> { applied_external_identification_assignment() : Object("applied_external_identification_assignment") {}
-		ListOf< external_identification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for group_assignment
-    struct group_assignment :  ObjectHelper<group_assignment,1> { group_assignment() : Object("group_assignment") {}
-		Lazy< group > assigned_group;
-    };
-
-    // C++ wrapper for applied_group_assignment
-    struct applied_group_assignment : group_assignment, ObjectHelper<applied_group_assignment,1> { applied_group_assignment() : Object("applied_group_assignment") {}
-		ListOf< groupable_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_identification_assignment
-    struct applied_identification_assignment : identification_assignment, ObjectHelper<applied_identification_assignment,1> { applied_identification_assignment() : Object("applied_identification_assignment") {}
-		ListOf< identification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for name_assignment
-    struct name_assignment :  ObjectHelper<name_assignment,1> { name_assignment() : Object("name_assignment") {}
-		label::Out assigned_name;
-    };
-
-    // C++ wrapper for applied_name_assignment
-    struct applied_name_assignment : name_assignment, ObjectHelper<applied_name_assignment,1> { applied_name_assignment() : Object("applied_name_assignment") {}
-		name_item::Out item;
-    };
-
-    // C++ wrapper for organization_assignment
-    struct organization_assignment :  ObjectHelper<organization_assignment,2> { organization_assignment() : Object("organization_assignment") {}
-		Lazy< NotImplemented > assigned_organization;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_organization_assignment
-    struct applied_organization_assignment : organization_assignment, ObjectHelper<applied_organization_assignment,1> { applied_organization_assignment() : Object("applied_organization_assignment") {}
-		ListOf< organization_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for organizational_project_assignment
-    struct organizational_project_assignment :  ObjectHelper<organizational_project_assignment,2> { organizational_project_assignment() : Object("organizational_project_assignment") {}
-		Lazy< NotImplemented > assigned_organizational_project;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_organizational_project_assignment
-    struct applied_organizational_project_assignment : organizational_project_assignment, ObjectHelper<applied_organizational_project_assignment,1> { applied_organizational_project_assignment() : Object("applied_organizational_project_assignment") {}
-		ListOf< project_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for person_and_organization_assignment
-    struct person_and_organization_assignment :  ObjectHelper<person_and_organization_assignment,2> { person_and_organization_assignment() : Object("person_and_organization_assignment") {}
-		Lazy< NotImplemented > assigned_person_and_organization;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_person_and_organization_assignment
-    struct applied_person_and_organization_assignment : person_and_organization_assignment, ObjectHelper<applied_person_and_organization_assignment,1> { applied_person_and_organization_assignment() : Object("applied_person_and_organization_assignment") {}
-		ListOf< person_and_organization_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for presented_item
-    struct presented_item :  ObjectHelper<presented_item,0> { presented_item() : Object("presented_item") {}
-
-    };
-
-    // C++ wrapper for applied_presented_item
-    struct applied_presented_item : presented_item, ObjectHelper<applied_presented_item,1> { applied_presented_item() : Object("applied_presented_item") {}
-		ListOf< presented_item_select, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for security_classification_assignment
-    struct security_classification_assignment :  ObjectHelper<security_classification_assignment,1> { security_classification_assignment() : Object("security_classification_assignment") {}
-		Lazy< NotImplemented > assigned_security_classification;
-    };
-
-    // C++ wrapper for applied_security_classification_assignment
-    struct applied_security_classification_assignment : security_classification_assignment, ObjectHelper<applied_security_classification_assignment,1> { applied_security_classification_assignment() : Object("applied_security_classification_assignment") {}
-		ListOf< security_classification_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for time_interval_assignment
-    struct time_interval_assignment :  ObjectHelper<time_interval_assignment,2> { time_interval_assignment() : Object("time_interval_assignment") {}
-		Lazy< time_interval > assigned_time_interval;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for applied_time_interval_assignment
-    struct applied_time_interval_assignment : time_interval_assignment, ObjectHelper<applied_time_interval_assignment,1> { applied_time_interval_assignment() : Object("applied_time_interval_assignment") {}
-		ListOf< time_interval_item, 0, 0 >::Out items;
-    };
-
-    // C++ wrapper for applied_usage_right
-    struct applied_usage_right : applied_action_assignment, ObjectHelper<applied_usage_right,0> { applied_usage_right() : Object("applied_usage_right") {}
-
-    };
-
-    // C++ wrapper for area_in_set
-    struct area_in_set :  ObjectHelper<area_in_set,2> { area_in_set() : Object("area_in_set") {}
-		Lazy< presentation_area > area;
-		Lazy< presentation_set > in_set;
-    };
-
-    // C++ wrapper for area_measure_with_unit
-    struct area_measure_with_unit : measure_with_unit, ObjectHelper<area_measure_with_unit,0> { area_measure_with_unit() : Object("area_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for area_unit
-    struct area_unit : derived_unit, ObjectHelper<area_unit,0> { area_unit() : Object("area_unit") {}
-
-    };
-
-    // C++ wrapper for product_definition_relationship
-    struct product_definition_relationship :  ObjectHelper<product_definition_relationship,5> { product_definition_relationship() : Object("product_definition_relationship") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< product_definition > relating_product_definition;
-		Lazy< product_definition > related_product_definition;
-    };
-
-    // C++ wrapper for product_definition_usage
-    struct product_definition_usage : product_definition_relationship, ObjectHelper<product_definition_usage,0> { product_definition_usage() : Object("product_definition_usage") {}
-
-    };
-
-    // C++ wrapper for assembly_component_usage
-    struct assembly_component_usage : product_definition_usage, ObjectHelper<assembly_component_usage,1> { assembly_component_usage() : Object("assembly_component_usage") {}
-		Maybe< identifier::Out > reference_designator;
-    };
-
-    // C++ wrapper for assigned_requirement
-    struct assigned_requirement : group_assignment, ObjectHelper<assigned_requirement,1> { assigned_requirement() : Object("assigned_requirement") {}
-		ListOf< Lazy< product_definition >, 1, 1 > items;
-    };
-
-    // C++ wrapper for compound_representation_item
-    struct compound_representation_item : representation_item, ObjectHelper<compound_representation_item,1> { compound_representation_item() : Object("compound_representation_item") {}
-		compound_item_definition::Out item_element;
-    };
-
-    // C++ wrapper for atomic_formula
-    struct atomic_formula : compound_representation_item, ObjectHelper<atomic_formula,0> { atomic_formula() : Object("atomic_formula") {}
-
-    };
-
-    // C++ wrapper for attribute_assertion
-    struct attribute_assertion :  ObjectHelper<attribute_assertion,0> { attribute_assertion() : Object("attribute_assertion") {}
-
-    };
-
-    // C++ wrapper for attribute_language_assignment
-    struct attribute_language_assignment : attribute_classification_assignment, ObjectHelper<attribute_language_assignment,1> { attribute_language_assignment() : Object("attribute_language_assignment") {}
-		ListOf< attribute_language_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for attribute_value_assignment
-    struct attribute_value_assignment :  ObjectHelper<attribute_value_assignment,3> { attribute_value_assignment() : Object("attribute_value_assignment") {}
-		label::Out attribute_name;
-		attribute_type::Out attribute_value;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for auxiliary_geometric_representation_item
-    struct auxiliary_geometric_representation_item :  ObjectHelper<auxiliary_geometric_representation_item,0> { auxiliary_geometric_representation_item() : Object("auxiliary_geometric_representation_item") {}
-
-    };
-
-    // C++ wrapper for placement
-    struct placement : geometric_representation_item, ObjectHelper<placement,1> { placement() : Object("placement") {}
-		Lazy< cartesian_point > location;
-    };
-
-    // C++ wrapper for axis1_placement
-    struct axis1_placement : placement, ObjectHelper<axis1_placement,1> { axis1_placement() : Object("axis1_placement") {}
-		Maybe< Lazy< direction > > axis;
-    };
-
-    // C++ wrapper for axis2_placement_2d
-    struct axis2_placement_2d : placement, ObjectHelper<axis2_placement_2d,1> { axis2_placement_2d() : Object("axis2_placement_2d") {}
-		Maybe< Lazy< direction > > ref_direction;
-    };
-
-    // C++ wrapper for axis2_placement_3d
-    struct axis2_placement_3d : placement, ObjectHelper<axis2_placement_3d,2> { axis2_placement_3d() : Object("axis2_placement_3d") {}
-		Maybe< Lazy< direction > > axis;
-		Maybe< Lazy< direction > > ref_direction;
-    };
-
-    // C++ wrapper for curve
-    struct curve : geometric_representation_item, ObjectHelper<curve,0> { curve() : Object("curve") {}
-
-    };
-
-    // C++ wrapper for bounded_curve
-    struct bounded_curve : curve, ObjectHelper<bounded_curve,0> { bounded_curve() : Object("bounded_curve") {}
-
-    };
-
-    // C++ wrapper for b_spline_curve
-    struct b_spline_curve : bounded_curve, ObjectHelper<b_spline_curve,5> { b_spline_curve() : Object("b_spline_curve") {}
-		INTEGER::Out degree;
-		ListOf< Lazy< cartesian_point >, 2, 0 > control_points_list;
-		b_spline_curve_form::Out curve_form;
-		LOGICAL::Out closed_curve;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for b_spline_curve_with_knots
-    struct b_spline_curve_with_knots : b_spline_curve, ObjectHelper<b_spline_curve_with_knots,3> { b_spline_curve_with_knots() : Object("b_spline_curve_with_knots") {}
-		ListOf< INTEGER, 2, 0 >::Out knot_multiplicities;
-		ListOf< parameter_value, 2, 0 >::Out knots;
-		knot_type::Out knot_spec;
-    };
-
-    // C++ wrapper for surface
-    struct surface : geometric_representation_item, ObjectHelper<surface,0> { surface() : Object("surface") {}
-
-    };
-
-    // C++ wrapper for bounded_surface
-    struct bounded_surface : surface, ObjectHelper<bounded_surface,0> { bounded_surface() : Object("bounded_surface") {}
-
-    };
-
-    // C++ wrapper for b_spline_surface
-    struct b_spline_surface : bounded_surface, ObjectHelper<b_spline_surface,6> { b_spline_surface() : Object("b_spline_surface") {}
-		INTEGER::Out u_degree;
-		INTEGER::Out v_degree;
-		b_spline_surface_form::Out surface_form;
-		LOGICAL::Out u_closed;
-		LOGICAL::Out v_closed;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for b_spline_surface_with_knots
-    struct b_spline_surface_with_knots : b_spline_surface, ObjectHelper<b_spline_surface_with_knots,5> { b_spline_surface_with_knots() : Object("b_spline_surface_with_knots") {}
-		ListOf< INTEGER, 2, 0 >::Out u_multiplicities;
-		ListOf< INTEGER, 2, 0 >::Out v_multiplicities;
-		ListOf< parameter_value, 2, 0 >::Out u_knots;
-		ListOf< parameter_value, 2, 0 >::Out v_knots;
-		knot_type::Out knot_spec;
-    };
-
-    // C++ wrapper for product_definition
-    struct product_definition :  ObjectHelper<product_definition,4> { product_definition() : Object("product_definition") {}
-		identifier::Out id;
-		Maybe< text::Out > description;
-		Lazy< product_definition_formation > formation;
-		Lazy< product_definition_context > frame_of_reference;
-    };
-
-    // C++ wrapper for rule_software_definition
-    struct rule_software_definition : product_definition, ObjectHelper<rule_software_definition,0> { rule_software_definition() : Object("rule_software_definition") {}
-
-    };
-
-    // C++ wrapper for rule_definition
-    struct rule_definition : rule_software_definition, ObjectHelper<rule_definition,0> { rule_definition() : Object("rule_definition") {}
-
-    };
-
-    // C++ wrapper for back_chaining_rule
-    struct back_chaining_rule : rule_definition, ObjectHelper<back_chaining_rule,0> { back_chaining_rule() : Object("back_chaining_rule") {}
-
-    };
-
-    // C++ wrapper for back_chaining_rule_body
-    struct back_chaining_rule_body :  ObjectHelper<back_chaining_rule_body,0> { back_chaining_rule_body() : Object("back_chaining_rule_body") {}
-
-    };
-
-    // C++ wrapper for colour
-    struct colour :  ObjectHelper<colour,0> { colour() : Object("colour") {}
-
-    };
-
-    // C++ wrapper for background_colour
-    struct background_colour : colour, ObjectHelper<background_colour,1> { background_colour() : Object("background_colour") {}
-		area_or_view::Out presentation;
-    };
-
-    // C++ wrapper for beveled_sheet_representation
-    struct beveled_sheet_representation : shape_representation, ObjectHelper<beveled_sheet_representation,0> { beveled_sheet_representation() : Object("beveled_sheet_representation") {}
-
-    };
-
-    // C++ wrapper for bezier_curve
-    struct bezier_curve : b_spline_curve, ObjectHelper<bezier_curve,0> { bezier_curve() : Object("bezier_curve") {}
-
-    };
-
-    // C++ wrapper for bezier_surface
-    struct bezier_surface : b_spline_surface, ObjectHelper<bezier_surface,0> { bezier_surface() : Object("bezier_surface") {}
-
-    };
-
-    // C++ wrapper for generic_expression
-    struct generic_expression :  ObjectHelper<generic_expression,0> { generic_expression() : Object("generic_expression") {}
-
-    };
-
-    // C++ wrapper for binary_generic_expression
-    struct binary_generic_expression : generic_expression, ObjectHelper<binary_generic_expression,1> { binary_generic_expression() : Object("binary_generic_expression") {}
-		ListOf< Lazy< generic_expression >, 2, 2 > operands;
-    };
-
-    // C++ wrapper for binary_numeric_expression
-    struct binary_numeric_expression :  ObjectHelper<binary_numeric_expression,0> { binary_numeric_expression() : Object("binary_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for binary_representation_item
-    struct binary_representation_item : representation_item, ObjectHelper<binary_representation_item,1> { binary_representation_item() : Object("binary_representation_item") {}
-		BINARY::Out binary_value;
-    };
-
-    // C++ wrapper for block
-    struct block : geometric_representation_item, ObjectHelper<block,4> { block() : Object("block") {}
-		Lazy< axis2_placement_3d > position;
-		positive_length_measure::Out x;
-		positive_length_measure::Out y;
-		positive_length_measure::Out z;
-    };
-
-    // C++ wrapper for expression
-    struct expression : generic_expression, ObjectHelper<expression,0> { expression() : Object("expression") {}
-
-    };
-
-    // C++ wrapper for boolean_expression
-    struct boolean_expression : expression, ObjectHelper<boolean_expression,0> { boolean_expression() : Object("boolean_expression") {}
-
-    };
-
-    // C++ wrapper for boolean_literal
-    struct boolean_literal :  ObjectHelper<boolean_literal,1> { boolean_literal() : Object("boolean_literal") {}
-		BOOLEAN::Out the_value;
-    };
-
-    // C++ wrapper for boolean_representation_item
-    struct boolean_representation_item :  ObjectHelper<boolean_representation_item,0> { boolean_representation_item() : Object("boolean_representation_item") {}
-
-    };
-
-    // C++ wrapper for boolean_result
-    struct boolean_result : geometric_representation_item, ObjectHelper<boolean_result,3> { boolean_result() : Object("boolean_result") {}
-		boolean_operator::Out operator_;
-		boolean_operand::Out first_operand;
-		boolean_operand::Out second_operand;
-    };
-
-    // C++ wrapper for composite_curve
-    struct composite_curve : bounded_curve, ObjectHelper<composite_curve,2> { composite_curve() : Object("composite_curve") {}
-		ListOf< Lazy< composite_curve_segment >, 1, 0 > segments;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for composite_curve_on_surface
-    struct composite_curve_on_surface : composite_curve, ObjectHelper<composite_curve_on_surface,0> { composite_curve_on_surface() : Object("composite_curve_on_surface") {}
-
-    };
-
-    // C++ wrapper for boundary_curve
-    struct boundary_curve : composite_curve_on_surface, ObjectHelper<boundary_curve,0> { boundary_curve() : Object("boundary_curve") {}
-
-    };
-
-    // C++ wrapper for bounded_pcurve
-    struct bounded_pcurve :  ObjectHelper<bounded_pcurve,0> { bounded_pcurve() : Object("bounded_pcurve") {}
-
-    };
-
-    // C++ wrapper for bounded_surface_curve
-    struct bounded_surface_curve :  ObjectHelper<bounded_surface_curve,0> { bounded_surface_curve() : Object("bounded_surface_curve") {}
-
-    };
-
-    // C++ wrapper for founded_item
-    struct founded_item :  ObjectHelper<founded_item,0> { founded_item() : Object("founded_item") {}
-
-    };
-
-    // C++ wrapper for box_domain
-    struct box_domain : founded_item, ObjectHelper<box_domain,4> { box_domain() : Object("box_domain") {}
-		Lazy< cartesian_point > corner;
-		positive_length_measure::Out xlength;
-		positive_length_measure::Out ylength;
-		positive_length_measure::Out zlength;
-    };
-
-    // C++ wrapper for half_space_solid
-    struct half_space_solid : geometric_representation_item, ObjectHelper<half_space_solid,2> { half_space_solid() : Object("half_space_solid") {}
-		Lazy< surface > base_surface;
-		BOOLEAN::Out agreement_flag;
-    };
-
-    // C++ wrapper for boxed_half_space
-    struct boxed_half_space : half_space_solid, ObjectHelper<boxed_half_space,1> { boxed_half_space() : Object("boxed_half_space") {}
-		Lazy< box_domain > enclosure;
-    };
-
-    // C++ wrapper for breakdown_context
-    struct breakdown_context : product_definition_relationship, ObjectHelper<breakdown_context,0> { breakdown_context() : Object("breakdown_context") {}
-
-    };
-
-    // C++ wrapper for breakdown_element_group_assignment
-    struct breakdown_element_group_assignment : group_assignment, ObjectHelper<breakdown_element_group_assignment,1> { breakdown_element_group_assignment() : Object("breakdown_element_group_assignment") {}
-		ListOf< product_definition_or_breakdown_element_usage, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for breakdown_element_realization
-    struct breakdown_element_realization :  ObjectHelper<breakdown_element_realization,0> { breakdown_element_realization() : Object("breakdown_element_realization") {}
-
-    };
-
-    // C++ wrapper for breakdown_element_usage
-    struct breakdown_element_usage : product_definition_relationship, ObjectHelper<breakdown_element_usage,0> { breakdown_element_usage() : Object("breakdown_element_usage") {}
-
-    };
-
-    // C++ wrapper for breakdown_of
-    struct breakdown_of : product_definition_relationship, ObjectHelper<breakdown_of,0> { breakdown_of() : Object("breakdown_of") {}
-
-    };
-
-    // C++ wrapper for solid_model
-    struct solid_model : geometric_representation_item, ObjectHelper<solid_model,0> { solid_model() : Object("solid_model") {}
-
-    };
-
-    // C++ wrapper for manifold_solid_brep
-    struct manifold_solid_brep : solid_model, ObjectHelper<manifold_solid_brep,1> { manifold_solid_brep() : Object("manifold_solid_brep") {}
-		Lazy< closed_shell > outer;
-    };
-
-    // C++ wrapper for brep_with_voids
-    struct brep_with_voids : manifold_solid_brep, ObjectHelper<brep_with_voids,1> { brep_with_voids() : Object("brep_with_voids") {}
-		ListOf< Lazy< oriented_closed_shell >, 1, 0 > voids;
-    };
-
-    // C++ wrapper for bytes_representation_item
-    struct bytes_representation_item : binary_representation_item, ObjectHelper<bytes_representation_item,0> { bytes_representation_item() : Object("bytes_representation_item") {}
-
-    };
-
-    // C++ wrapper for date
-    struct date :  ObjectHelper<date,1> { date() : Object("date") {}
-		year_number::Out year_component;
-    };
-
-    // C++ wrapper for calendar_date
-    struct calendar_date : date, ObjectHelper<calendar_date,2> { calendar_date() : Object("calendar_date") {}
-		day_in_month_number::Out day_component;
-		month_in_year_number::Out month_component;
-    };
-
-    // C++ wrapper for camera_image
-    struct camera_image : mapped_item, ObjectHelper<camera_image,0> { camera_image() : Object("camera_image") {}
-
-    };
-
-    // C++ wrapper for camera_image_3d_with_scale
-    struct camera_image_3d_with_scale : camera_image, ObjectHelper<camera_image_3d_with_scale,0> { camera_image_3d_with_scale() : Object("camera_image_3d_with_scale") {}
-
-    };
-
-    // C++ wrapper for camera_model
-    struct camera_model : geometric_representation_item, ObjectHelper<camera_model,0> { camera_model() : Object("camera_model") {}
-
-    };
-
-    // C++ wrapper for camera_model_d3
-    struct camera_model_d3 : camera_model, ObjectHelper<camera_model_d3,2> { camera_model_d3() : Object("camera_model_d3") {}
-		Lazy< axis2_placement_3d > view_reference_system;
-		Lazy< view_volume > perspective_of_volume;
-    };
-
-    // C++ wrapper for camera_model_d3_multi_clipping
-    struct camera_model_d3_multi_clipping : camera_model_d3, ObjectHelper<camera_model_d3_multi_clipping,1> { camera_model_d3_multi_clipping() : Object("camera_model_d3_multi_clipping") {}
-		ListOf< camera_model_d3_multi_clipping_interection_select, 1, 0 >::Out shape_clipping;
-    };
-
-    // C++ wrapper for camera_model_d3_multi_clipping_intersection
-    struct camera_model_d3_multi_clipping_intersection : geometric_representation_item, ObjectHelper<camera_model_d3_multi_clipping_intersection,1> { camera_model_d3_multi_clipping_intersection() : Object("camera_model_d3_multi_clipping_intersection") {}
-		ListOf< camera_model_d3_multi_clipping_interection_select, 2, 0 >::Out shape_clipping;
-    };
-
-    // C++ wrapper for camera_model_d3_multi_clipping_union
-    struct camera_model_d3_multi_clipping_union : geometric_representation_item, ObjectHelper<camera_model_d3_multi_clipping_union,1> { camera_model_d3_multi_clipping_union() : Object("camera_model_d3_multi_clipping_union") {}
-		ListOf< camera_model_d3_multi_clipping_union_select, 2, 0 >::Out shape_clipping;
-    };
-
-    // C++ wrapper for camera_model_d3_with_hlhsr
-    struct camera_model_d3_with_hlhsr : camera_model_d3, ObjectHelper<camera_model_d3_with_hlhsr,1> { camera_model_d3_with_hlhsr() : Object("camera_model_d3_with_hlhsr") {}
-		BOOLEAN::Out hidden_line_surface_removal;
-    };
-
-    // C++ wrapper for camera_model_with_light_sources
-    struct camera_model_with_light_sources : camera_model_d3, ObjectHelper<camera_model_with_light_sources,1> { camera_model_with_light_sources() : Object("camera_model_with_light_sources") {}
-		ListOf< Lazy< light_source >, 1, 0 > sources;
-    };
-
-    // C++ wrapper for representation_map
-    struct representation_map :  ObjectHelper<representation_map,2> { representation_map() : Object("representation_map") {}
-		Lazy< representation_item > mapping_origin;
-		Lazy< representation > mapped_representation;
-    };
-
-    // C++ wrapper for camera_usage
-    struct camera_usage : representation_map, ObjectHelper<camera_usage,0> { camera_usage() : Object("camera_usage") {}
-
-    };
-
-    // C++ wrapper for capacitance_measure_with_unit
-    struct capacitance_measure_with_unit : measure_with_unit, ObjectHelper<capacitance_measure_with_unit,0> { capacitance_measure_with_unit() : Object("capacitance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for capacitance_unit
-    struct capacitance_unit : derived_unit, ObjectHelper<capacitance_unit,0> { capacitance_unit() : Object("capacitance_unit") {}
-
-    };
-
-    // C++ wrapper for point
-    struct point : geometric_representation_item, ObjectHelper<point,0> { point() : Object("point") {}
-
-    };
-
-    // C++ wrapper for cartesian_point
-    struct cartesian_point : point, ObjectHelper<cartesian_point,1> { cartesian_point() : Object("cartesian_point") {}
-		ListOf< length_measure, 1, 3 >::Out coordinates;
-    };
-
-    // C++ wrapper for cartesian_transformation_operator
-    struct cartesian_transformation_operator :  ObjectHelper<cartesian_transformation_operator,4> { cartesian_transformation_operator() : Object("cartesian_transformation_operator") {}
-		Maybe< Lazy< direction > > axis1;
-		Maybe< Lazy< direction > > axis2;
-		Lazy< cartesian_point > local_origin;
-		Maybe< REAL::Out > scale;
-    };
-
-    // C++ wrapper for cartesian_transformation_operator_2d
-    struct cartesian_transformation_operator_2d : cartesian_transformation_operator, ObjectHelper<cartesian_transformation_operator_2d,0> { cartesian_transformation_operator_2d() : Object("cartesian_transformation_operator_2d") {}
-
-    };
-
-    // C++ wrapper for cartesian_transformation_operator_3d
-    struct cartesian_transformation_operator_3d : cartesian_transformation_operator, ObjectHelper<cartesian_transformation_operator_3d,1> { cartesian_transformation_operator_3d() : Object("cartesian_transformation_operator_3d") {}
-		Maybe< Lazy< direction > > axis3;
-    };
-
-    // C++ wrapper for cc_design_approval
-    struct cc_design_approval : approval_assignment, ObjectHelper<cc_design_approval,1> { cc_design_approval() : Object("cc_design_approval") {}
-		ListOf< approved_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_certification
-    struct cc_design_certification : certification_assignment, ObjectHelper<cc_design_certification,1> { cc_design_certification() : Object("cc_design_certification") {}
-		ListOf< certified_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_contract
-    struct cc_design_contract : contract_assignment, ObjectHelper<cc_design_contract,1> { cc_design_contract() : Object("cc_design_contract") {}
-		ListOf< contracted_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_date_and_time_assignment
-    struct cc_design_date_and_time_assignment : date_and_time_assignment, ObjectHelper<cc_design_date_and_time_assignment,1> { cc_design_date_and_time_assignment() : Object("cc_design_date_and_time_assignment") {}
-		ListOf< date_time_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_person_and_organization_assignment
-    struct cc_design_person_and_organization_assignment : person_and_organization_assignment, ObjectHelper<cc_design_person_and_organization_assignment,1> { cc_design_person_and_organization_assignment() : Object("cc_design_person_and_organization_assignment") {}
-		ListOf< cc_person_organization_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_security_classification
-    struct cc_design_security_classification : security_classification_assignment, ObjectHelper<cc_design_security_classification,1> { cc_design_security_classification() : Object("cc_design_security_classification") {}
-		ListOf< cc_classified_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for cc_design_specification_reference
-    struct cc_design_specification_reference : document_reference, ObjectHelper<cc_design_specification_reference,1> { cc_design_specification_reference() : Object("cc_design_specification_reference") {}
-		ListOf< cc_specified_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for celsius_temperature_measure_with_unit
-    struct celsius_temperature_measure_with_unit : measure_with_unit, ObjectHelper<celsius_temperature_measure_with_unit,0> { celsius_temperature_measure_with_unit() : Object("celsius_temperature_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for centre_of_symmetry
-    struct centre_of_symmetry : derived_shape_aspect, ObjectHelper<centre_of_symmetry,0> { centre_of_symmetry() : Object("centre_of_symmetry") {}
-
-    };
-
-    // C++ wrapper for change
-    struct change : action_assignment, ObjectHelper<change,1> { change() : Object("change") {}
-		ListOf< work_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for change_request
-    struct change_request : action_request_assignment, ObjectHelper<change_request,1> { change_request() : Object("change_request") {}
-		ListOf< change_request_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for character_glyph_style_outline
-    struct character_glyph_style_outline : founded_item, ObjectHelper<character_glyph_style_outline,1> { character_glyph_style_outline() : Object("character_glyph_style_outline") {}
-		Lazy< curve_style > outline_style;
-    };
-
-    // C++ wrapper for character_glyph_style_stroke
-    struct character_glyph_style_stroke : founded_item, ObjectHelper<character_glyph_style_stroke,1> { character_glyph_style_stroke() : Object("character_glyph_style_stroke") {}
-		Lazy< curve_style > stroke_style;
-    };
-
-    // C++ wrapper for symbol_representation
-    struct symbol_representation : representation, ObjectHelper<symbol_representation,0> { symbol_representation() : Object("symbol_representation") {}
-
-    };
-
-    // C++ wrapper for generic_character_glyph_symbol
-    struct generic_character_glyph_symbol : symbol_representation, ObjectHelper<generic_character_glyph_symbol,0> { generic_character_glyph_symbol() : Object("generic_character_glyph_symbol") {}
-
-    };
-
-    // C++ wrapper for character_glyph_symbol
-    struct character_glyph_symbol : generic_character_glyph_symbol, ObjectHelper<character_glyph_symbol,2> { character_glyph_symbol() : Object("character_glyph_symbol") {}
-		Lazy< planar_extent > character_box;
-		ratio_measure::Out baseline_ratio;
-    };
-
-    // C++ wrapper for character_glyph_symbol_outline
-    struct character_glyph_symbol_outline : character_glyph_symbol, ObjectHelper<character_glyph_symbol_outline,1> { character_glyph_symbol_outline() : Object("character_glyph_symbol_outline") {}
-		ListOf< Lazy< annotation_fill_area >, 1, 0 > outlines;
-    };
-
-    // C++ wrapper for character_glyph_symbol_stroke
-    struct character_glyph_symbol_stroke : character_glyph_symbol, ObjectHelper<character_glyph_symbol_stroke,1> { character_glyph_symbol_stroke() : Object("character_glyph_symbol_stroke") {}
-		ListOf< Lazy< curve >, 1, 0 > strokes;
-    };
-
-    // C++ wrapper for general_property
-    struct general_property :  ObjectHelper<general_property,3> { general_property() : Object("general_property") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for characteristic_data_column_header
-    struct characteristic_data_column_header : general_property, ObjectHelper<characteristic_data_column_header,0> { characteristic_data_column_header() : Object("characteristic_data_column_header") {}
-
-    };
-
-    // C++ wrapper for general_property_relationship
-    struct general_property_relationship :  ObjectHelper<general_property_relationship,4> { general_property_relationship() : Object("general_property_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< general_property > relating_property;
-		Lazy< general_property > related_property;
-    };
-
-    // C++ wrapper for characteristic_data_column_header_link
-    struct characteristic_data_column_header_link : general_property_relationship, ObjectHelper<characteristic_data_column_header_link,0> { characteristic_data_column_header_link() : Object("characteristic_data_column_header_link") {}
-
-    };
-
-    // C++ wrapper for characteristic_data_table_header
-    struct characteristic_data_table_header : general_property, ObjectHelper<characteristic_data_table_header,0> { characteristic_data_table_header() : Object("characteristic_data_table_header") {}
-
-    };
-
-    // C++ wrapper for characteristic_data_table_header_decomposition
-    struct characteristic_data_table_header_decomposition : general_property_relationship, ObjectHelper<characteristic_data_table_header_decomposition,0> { characteristic_data_table_header_decomposition() : Object("characteristic_data_table_header_decomposition") {}
-
-    };
-
-    // C++ wrapper for group
-    struct group :  ObjectHelper<group,2> { group() : Object("group") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for characteristic_type
-    struct characteristic_type : group, ObjectHelper<characteristic_type,0> { characteristic_type() : Object("characteristic_type") {}
-
-    };
-
-    // C++ wrapper for characterized_class
-    struct characterized_class :  ObjectHelper<characterized_class,0> { characterized_class() : Object("characterized_class") {}
-
-    };
-
-    // C++ wrapper for characterized_object
-    struct characterized_object :  ObjectHelper<characterized_object,2> { characterized_object() : Object("characterized_object") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for conic
-    struct conic : curve, ObjectHelper<conic,1> { conic() : Object("conic") {}
-		axis2_placement::Out position;
-    };
-
-    // C++ wrapper for circle
-    struct circle : conic, ObjectHelper<circle,1> { circle() : Object("circle") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for circular_runout_tolerance
-    struct circular_runout_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<circular_runout_tolerance,0> { circular_runout_tolerance() : Object("circular_runout_tolerance") {}
-
-    };
-
-    // C++ wrapper for class_by_extension
-    struct class_by_extension : class_t, ObjectHelper<class_by_extension,0> { class_by_extension() : Object("class_by_extension") {}
-
-    };
-
-    // C++ wrapper for class_by_intension
-    struct class_by_intension : class_t, ObjectHelper<class_by_intension,0> { class_by_intension() : Object("class_by_intension") {}
-
-    };
-
-    // C++ wrapper for class_system
-    struct class_system : group, ObjectHelper<class_system,0> { class_system() : Object("class_system") {}
-
-    };
-
-    // C++ wrapper for effectivity_context_assignment
-    struct effectivity_context_assignment :  ObjectHelper<effectivity_context_assignment,2> { effectivity_context_assignment() : Object("effectivity_context_assignment") {}
-		Lazy< effectivity_assignment > assigned_effectivity_assignment;
-		Lazy< NotImplemented > role;
-    };
-
-    // C++ wrapper for class_usage_effectivity_context_assignment
-    struct class_usage_effectivity_context_assignment : effectivity_context_assignment, ObjectHelper<class_usage_effectivity_context_assignment,1> { class_usage_effectivity_context_assignment() : Object("class_usage_effectivity_context_assignment") {}
-		ListOf< class_usage_effectivity_context_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for topological_representation_item
-    struct topological_representation_item : representation_item, ObjectHelper<topological_representation_item,0> { topological_representation_item() : Object("topological_representation_item") {}
-
-    };
-
-    // C++ wrapper for connected_face_set
-    struct connected_face_set : topological_representation_item, ObjectHelper<connected_face_set,1> { connected_face_set() : Object("connected_face_set") {}
-		ListOf< Lazy< face >, 1, 0 > cfs_faces;
-    };
-
-    // C++ wrapper for closed_shell
-    struct closed_shell : connected_face_set, ObjectHelper<closed_shell,0> { closed_shell() : Object("closed_shell") {}
-
-    };
-
-    // C++ wrapper for coaxiality_tolerance
-    struct coaxiality_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<coaxiality_tolerance,0> { coaxiality_tolerance() : Object("coaxiality_tolerance") {}
-
-    };
-
-    // C++ wrapper for colour_specification
-    struct colour_specification : colour, ObjectHelper<colour_specification,1> { colour_specification() : Object("colour_specification") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for colour_rgb
-    struct colour_rgb : colour_specification, ObjectHelper<colour_rgb,3> { colour_rgb() : Object("colour_rgb") {}
-		REAL::Out red;
-		REAL::Out green;
-		REAL::Out blue;
-    };
-
-    // C++ wrapper for common_datum
-    struct common_datum :  ObjectHelper<common_datum,0> { common_datum() : Object("common_datum") {}
-
-    };
-
-    // C++ wrapper for comparison_expression
-    struct comparison_expression :  ObjectHelper<comparison_expression,0> { comparison_expression() : Object("comparison_expression") {}
-
-    };
-
-    // C++ wrapper for complex_clause
-    struct complex_clause : compound_representation_item, ObjectHelper<complex_clause,0> { complex_clause() : Object("complex_clause") {}
-
-    };
-
-    // C++ wrapper for complex_conjunctive_clause
-    struct complex_conjunctive_clause : complex_clause, ObjectHelper<complex_conjunctive_clause,0> { complex_conjunctive_clause() : Object("complex_conjunctive_clause") {}
-
-    };
-
-    // C++ wrapper for complex_disjunctive_clause
-    struct complex_disjunctive_clause : complex_clause, ObjectHelper<complex_disjunctive_clause,0> { complex_disjunctive_clause() : Object("complex_disjunctive_clause") {}
-
-    };
-
-    // C++ wrapper for modified_solid
-    struct modified_solid : solid_model, ObjectHelper<modified_solid,2> { modified_solid() : Object("modified_solid") {}
-		text::Out rationale;
-		base_solid_select::Out base_solid;
-    };
-
-    // C++ wrapper for shelled_solid
-    struct shelled_solid : modified_solid, ObjectHelper<shelled_solid,2> { shelled_solid() : Object("shelled_solid") {}
-		ListOf< Lazy< face_surface >, 1, 0 > deleted_face_set;
-		length_measure::Out thickness;
-    };
-
-    // C++ wrapper for complex_shelled_solid
-    struct complex_shelled_solid : shelled_solid, ObjectHelper<complex_shelled_solid,1> { complex_shelled_solid() : Object("complex_shelled_solid") {}
-		ListOf< length_measure, 1, 0 >::Out thickness_list;
-    };
-
-    // C++ wrapper for composite_assembly_definition
-    struct composite_assembly_definition : product_definition, ObjectHelper<composite_assembly_definition,0> { composite_assembly_definition() : Object("composite_assembly_definition") {}
-
-    };
-
-    // C++ wrapper for composite_assembly_sequence_definition
-    struct composite_assembly_sequence_definition : product_definition, ObjectHelper<composite_assembly_sequence_definition,0> { composite_assembly_sequence_definition() : Object("composite_assembly_sequence_definition") {}
-
-    };
-
-    // C++ wrapper for laminate_table
-    struct laminate_table : product_definition, ObjectHelper<laminate_table,0> { laminate_table() : Object("laminate_table") {}
-
-    };
-
-    // C++ wrapper for part_laminate_table
-    struct part_laminate_table : laminate_table, ObjectHelper<part_laminate_table,0> { part_laminate_table() : Object("part_laminate_table") {}
-
-    };
-
-    // C++ wrapper for composite_assembly_table
-    struct composite_assembly_table : part_laminate_table, ObjectHelper<composite_assembly_table,0> { composite_assembly_table() : Object("composite_assembly_table") {}
-
-    };
-
-    // C++ wrapper for composite_curve_segment
-    struct composite_curve_segment : founded_item, ObjectHelper<composite_curve_segment,3> { composite_curve_segment() : Object("composite_curve_segment") {}
-		transition_code::Out transition;
-		BOOLEAN::Out same_sense;
-		Lazy< curve > parent_curve;
-    };
-
-    // C++ wrapper for material_designation
-    struct material_designation :  ObjectHelper<material_designation,2> { material_designation() : Object("material_designation") {}
-		label::Out name;
-		ListOf< characterized_definition, 1, 0 >::Out definitions;
-    };
-
-    // C++ wrapper for composite_material_designation
-    struct composite_material_designation : material_designation, ObjectHelper<composite_material_designation,0> { composite_material_designation() : Object("composite_material_designation") {}
-
-    };
-
-    // C++ wrapper for composite_shape_aspect
-    struct composite_shape_aspect : shape_aspect, ObjectHelper<composite_shape_aspect,0> { composite_shape_aspect() : Object("composite_shape_aspect") {}
-
-    };
-
-    // C++ wrapper for composite_sheet_representation
-    struct composite_sheet_representation : shape_representation, ObjectHelper<composite_sheet_representation,0> { composite_sheet_representation() : Object("composite_sheet_representation") {}
-
-    };
-
-    // C++ wrapper for composite_text
-    struct composite_text : geometric_representation_item, ObjectHelper<composite_text,1> { composite_text() : Object("composite_text") {}
-		ListOf< text_or_character, 2, 0 >::Out collected_text;
-    };
-
-    // C++ wrapper for composite_text_with_associated_curves
-    struct composite_text_with_associated_curves : composite_text, ObjectHelper<composite_text_with_associated_curves,1> { composite_text_with_associated_curves() : Object("composite_text_with_associated_curves") {}
-		ListOf< Lazy< curve >, 1, 0 > associated_curves;
-    };
-
-    // C++ wrapper for composite_text_with_blanking_box
-    struct composite_text_with_blanking_box : composite_text, ObjectHelper<composite_text_with_blanking_box,1> { composite_text_with_blanking_box() : Object("composite_text_with_blanking_box") {}
-		Lazy< planar_box > blanking;
-    };
-
-    // C++ wrapper for composite_text_with_delineation
-    struct composite_text_with_delineation : composite_text, ObjectHelper<composite_text_with_delineation,1> { composite_text_with_delineation() : Object("composite_text_with_delineation") {}
-		text_delineation::Out delineation;
-    };
-
-    // C++ wrapper for composite_text_with_extent
-    struct composite_text_with_extent : composite_text, ObjectHelper<composite_text_with_extent,1> { composite_text_with_extent() : Object("composite_text_with_extent") {}
-		Lazy< planar_extent > extent;
-    };
-
-    // C++ wrapper for compound_shape_representation
-    struct compound_shape_representation : shape_representation, ObjectHelper<compound_shape_representation,0> { compound_shape_representation() : Object("compound_shape_representation") {}
-
-    };
-
-    // C++ wrapper for concentricity_tolerance
-    struct concentricity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<concentricity_tolerance,0> { concentricity_tolerance() : Object("concentricity_tolerance") {}
-
-    };
-
-    // C++ wrapper for concept_feature_relationship
-    struct concept_feature_relationship :  ObjectHelper<concept_feature_relationship,4> { concept_feature_relationship() : Object("concept_feature_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< product_concept_feature > relating_product_concept_feature;
-		Lazy< product_concept_feature > related_product_concept_feature;
-    };
-
-    // C++ wrapper for concept_feature_relationship_with_condition
-    struct concept_feature_relationship_with_condition : concept_feature_relationship, ObjectHelper<concept_feature_relationship_with_condition,1> { concept_feature_relationship_with_condition() : Object("concept_feature_relationship_with_condition") {}
-		Lazy< NotImplemented > conditional_operator;
-    };
-
-    // C++ wrapper for product_concept_feature
-    struct product_concept_feature :  ObjectHelper<product_concept_feature,3> { product_concept_feature() : Object("product_concept_feature") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for conditional_concept_feature
-    struct conditional_concept_feature : product_concept_feature, ObjectHelper<conditional_concept_feature,1> { conditional_concept_feature() : Object("conditional_concept_feature") {}
-		Lazy< concept_feature_relationship_with_condition > condition;
-    };
-
-    // C++ wrapper for conductance_measure_with_unit
-    struct conductance_measure_with_unit : measure_with_unit, ObjectHelper<conductance_measure_with_unit,0> { conductance_measure_with_unit() : Object("conductance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for conductance_unit
-    struct conductance_unit : derived_unit, ObjectHelper<conductance_unit,0> { conductance_unit() : Object("conductance_unit") {}
-
-    };
-
-    // C++ wrapper for configuration_item
-    struct configuration_item :  ObjectHelper<configuration_item,5> { configuration_item() : Object("configuration_item") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< NotImplemented > item_concept;
-		Maybe< label::Out > purpose;
-    };
-
-    // C++ wrapper for configurable_item
-    struct configurable_item : configuration_item, ObjectHelper<configurable_item,1> { configurable_item() : Object("configurable_item") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > item_concept_feature;
-    };
-
-    // C++ wrapper for effectivity
-    struct effectivity :  ObjectHelper<effectivity,1> { effectivity() : Object("effectivity") {}
-		identifier::Out id;
-    };
-
-    // C++ wrapper for product_definition_effectivity
-    struct product_definition_effectivity : effectivity, ObjectHelper<product_definition_effectivity,1> { product_definition_effectivity() : Object("product_definition_effectivity") {}
-		Lazy< product_definition_relationship > usage;
-    };
-
-    // C++ wrapper for configuration_effectivity
-    struct configuration_effectivity : product_definition_effectivity, ObjectHelper<configuration_effectivity,1> { configuration_effectivity() : Object("configuration_effectivity") {}
-		Lazy< NotImplemented > configuration;
-    };
-
-    // C++ wrapper for configuration_item_relationship
-    struct configuration_item_relationship :  ObjectHelper<configuration_item_relationship,4> { configuration_item_relationship() : Object("configuration_item_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< configuration_item > relating_configuration_item;
-		Lazy< configuration_item > related_configuration_item;
-    };
-
-    // C++ wrapper for configuration_item_hierarchical_relationship
-    struct configuration_item_hierarchical_relationship : configuration_item_relationship, ObjectHelper<configuration_item_hierarchical_relationship,0> { configuration_item_hierarchical_relationship() : Object("configuration_item_hierarchical_relationship") {}
-
-    };
-
-    // C++ wrapper for configuration_item_revision_sequence
-    struct configuration_item_revision_sequence : configuration_item_relationship, ObjectHelper<configuration_item_revision_sequence,0> { configuration_item_revision_sequence() : Object("configuration_item_revision_sequence") {}
-
-    };
-
-    // C++ wrapper for configured_effectivity_assignment
-    struct configured_effectivity_assignment : effectivity_assignment, ObjectHelper<configured_effectivity_assignment,1> { configured_effectivity_assignment() : Object("configured_effectivity_assignment") {}
-		ListOf< configured_effectivity_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for configured_effectivity_context_assignment
-    struct configured_effectivity_context_assignment : effectivity_context_assignment, ObjectHelper<configured_effectivity_context_assignment,1> { configured_effectivity_context_assignment() : Object("configured_effectivity_context_assignment") {}
-		ListOf< configured_effectivity_context_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for conical_stepped_hole_transition
-    struct conical_stepped_hole_transition : geometric_representation_item, ObjectHelper<conical_stepped_hole_transition,3> { conical_stepped_hole_transition() : Object("conical_stepped_hole_transition") {}
-		positive_integer::Out transition_number;
-		plane_angle_measure::Out cone_apex_angle;
-		positive_length_measure::Out cone_base_radius;
-    };
-
-    // C++ wrapper for elementary_surface
-    struct elementary_surface : surface, ObjectHelper<elementary_surface,1> { elementary_surface() : Object("elementary_surface") {}
-		Lazy< axis2_placement_3d > position;
-    };
-
-    // C++ wrapper for conical_surface
-    struct conical_surface : elementary_surface, ObjectHelper<conical_surface,2> { conical_surface() : Object("conical_surface") {}
-		length_measure::Out radius;
-		plane_angle_measure::Out semi_angle;
-    };
-
-    // C++ wrapper for connected_edge_set
-    struct connected_edge_set : topological_representation_item, ObjectHelper<connected_edge_set,1> { connected_edge_set() : Object("connected_edge_set") {}
-		ListOf< Lazy< edge >, 1, 0 > ces_edges;
-    };
-
-    // C++ wrapper for connected_face_sub_set
-    struct connected_face_sub_set : connected_face_set, ObjectHelper<connected_face_sub_set,1> { connected_face_sub_set() : Object("connected_face_sub_set") {}
-		Lazy< connected_face_set > parent_face_set;
-    };
-
-    // C++ wrapper for constructive_geometry_representation
-    struct constructive_geometry_representation : representation, ObjectHelper<constructive_geometry_representation,0> { constructive_geometry_representation() : Object("constructive_geometry_representation") {}
-
-    };
-
-    // C++ wrapper for representation_relationship
-    struct representation_relationship :  ObjectHelper<representation_relationship,4> { representation_relationship() : Object("representation_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< representation > rep_1;
-		Lazy< representation > rep_2;
-    };
-
-    // C++ wrapper for constructive_geometry_representation_relationship
-    struct constructive_geometry_representation_relationship : representation_relationship, ObjectHelper<constructive_geometry_representation_relationship,0> { constructive_geometry_representation_relationship() : Object("constructive_geometry_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for contact_ratio_representation
-    struct contact_ratio_representation : representation, ObjectHelper<contact_ratio_representation,0> { contact_ratio_representation() : Object("contact_ratio_representation") {}
-
-    };
-
-    // C++ wrapper for invisibility
-    struct invisibility :  ObjectHelper<invisibility,1> { invisibility() : Object("invisibility") {}
-		ListOf< invisible_item, 1, 0 >::Out invisible_items;
-    };
-
-    // C++ wrapper for context_dependent_invisibility
-    struct context_dependent_invisibility : invisibility, ObjectHelper<context_dependent_invisibility,1> { context_dependent_invisibility() : Object("context_dependent_invisibility") {}
-		invisibility_context::Out presentation_context;
-    };
-
-    // C++ wrapper for over_riding_styled_item
-    struct over_riding_styled_item : styled_item, ObjectHelper<over_riding_styled_item,1> { over_riding_styled_item() : Object("over_riding_styled_item") {}
-		Lazy< styled_item > over_ridden_style;
-    };
-
-    // C++ wrapper for context_dependent_over_riding_styled_item
-    struct context_dependent_over_riding_styled_item : over_riding_styled_item, ObjectHelper<context_dependent_over_riding_styled_item,1> { context_dependent_over_riding_styled_item() : Object("context_dependent_over_riding_styled_item") {}
-		ListOf< style_context_select, 1, 0 >::Out style_context;
-    };
-
-    // C++ wrapper for context_dependent_unit
-    struct context_dependent_unit : named_unit, ObjectHelper<context_dependent_unit,1> { context_dependent_unit() : Object("context_dependent_unit") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for conversion_based_unit
-    struct conversion_based_unit : named_unit, ObjectHelper<conversion_based_unit,2> { conversion_based_unit() : Object("conversion_based_unit") {}
-		label::Out name;
-		Lazy< measure_with_unit > conversion_factor;
-    };
-
-    // C++ wrapper for csg_shape_representation
-    struct csg_shape_representation : shape_representation, ObjectHelper<csg_shape_representation,0> { csg_shape_representation() : Object("csg_shape_representation") {}
-
-    };
-
-    // C++ wrapper for csg_solid
-    struct csg_solid : solid_model, ObjectHelper<csg_solid,1> { csg_solid() : Object("csg_solid") {}
-		csg_select::Out tree_root_expression;
-    };
-
-    // C++ wrapper for currency
-    struct currency : context_dependent_unit, ObjectHelper<currency,0> { currency() : Object("currency") {}
-
-    };
-
-    // C++ wrapper for currency_measure_with_unit
-    struct currency_measure_with_unit : measure_with_unit, ObjectHelper<currency_measure_with_unit,0> { currency_measure_with_unit() : Object("currency_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for curve_bounded_surface
-    struct curve_bounded_surface : bounded_surface, ObjectHelper<curve_bounded_surface,3> { curve_bounded_surface() : Object("curve_bounded_surface") {}
-		Lazy< surface > basis_surface;
-		ListOf< Lazy< boundary_curve >, 1, 0 > boundaries;
-		BOOLEAN::Out implicit_outer;
-    };
-
-    // C++ wrapper for curve_dimension
-    struct curve_dimension : dimension_curve_directed_callout, ObjectHelper<curve_dimension,0> { curve_dimension() : Object("curve_dimension") {}
-
-    };
-
-    // C++ wrapper for curve_replica
-    struct curve_replica : curve, ObjectHelper<curve_replica,2> { curve_replica() : Object("curve_replica") {}
-		Lazy< curve > parent_curve;
-		Lazy< cartesian_transformation_operator > transformation;
-    };
-
-    // C++ wrapper for curve_style
-    struct curve_style : founded_item, ObjectHelper<curve_style,4> { curve_style() : Object("curve_style") {}
-		label::Out name;
-		curve_font_or_scaled_curve_font_select::Out curve_font;
-		size_select::Out curve_width;
-		Lazy< colour > curve_colour;
-    };
-
-    // C++ wrapper for curve_style_font
-    struct curve_style_font : founded_item, ObjectHelper<curve_style_font,2> { curve_style_font() : Object("curve_style_font") {}
-		label::Out name;
-		ListOf< Lazy< curve_style_font_pattern >, 1, 0 > pattern_list;
-    };
-
-    // C++ wrapper for curve_style_font_and_scaling
-    struct curve_style_font_and_scaling : founded_item, ObjectHelper<curve_style_font_and_scaling,3> { curve_style_font_and_scaling() : Object("curve_style_font_and_scaling") {}
-		label::Out name;
-		curve_style_font_select::Out curve_font;
-		REAL::Out curve_font_scaling;
-    };
-
-    // C++ wrapper for curve_style_font_pattern
-    struct curve_style_font_pattern : founded_item, ObjectHelper<curve_style_font_pattern,2> { curve_style_font_pattern() : Object("curve_style_font_pattern") {}
-		positive_length_measure::Out visible_segment_length;
-		positive_length_measure::Out invisible_segment_length;
-    };
-
-    // C++ wrapper for curve_swept_solid_shape_representation
-    struct curve_swept_solid_shape_representation : shape_representation, ObjectHelper<curve_swept_solid_shape_representation,0> { curve_swept_solid_shape_representation() : Object("curve_swept_solid_shape_representation") {}
-
-    };
-
-    // C++ wrapper for cylindrical_surface
-    struct cylindrical_surface : elementary_surface, ObjectHelper<cylindrical_surface,1> { cylindrical_surface() : Object("cylindrical_surface") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for cylindricity_tolerance
-    struct cylindricity_tolerance : geometric_tolerance, ObjectHelper<cylindricity_tolerance,0> { cylindricity_tolerance() : Object("cylindricity_tolerance") {}
-
-    };
-
-    // C++ wrapper for date_representation_item
-    struct date_representation_item :  ObjectHelper<date_representation_item,0> { date_representation_item() : Object("date_representation_item") {}
-
-    };
-
-    // C++ wrapper for date_time_representation_item
-    struct date_time_representation_item :  ObjectHelper<date_time_representation_item,0> { date_time_representation_item() : Object("date_time_representation_item") {}
-
-    };
-
-    // C++ wrapper for dated_effectivity
-    struct dated_effectivity : effectivity, ObjectHelper<dated_effectivity,2> { dated_effectivity() : Object("dated_effectivity") {}
-		Maybe< date_time_or_event_occurrence::Out > effectivity_end_date;
-		date_time_or_event_occurrence::Out effectivity_start_date;
-    };
-
-    // C++ wrapper for datum
-    struct datum : shape_aspect, ObjectHelper<datum,1> { datum() : Object("datum") {}
-		identifier::Out identification;
-    };
-
-    // C++ wrapper for datum_feature
-    struct datum_feature : shape_aspect, ObjectHelper<datum_feature,0> { datum_feature() : Object("datum_feature") {}
-
-    };
-
-    // C++ wrapper for datum_feature_callout
-    struct datum_feature_callout : draughting_callout, ObjectHelper<datum_feature_callout,0> { datum_feature_callout() : Object("datum_feature_callout") {}
-
-    };
-
-    // C++ wrapper for datum_reference
-    struct datum_reference :  ObjectHelper<datum_reference,2> { datum_reference() : Object("datum_reference") {}
-		INTEGER::Out precedence;
-		Lazy< datum > referenced_datum;
-    };
-
-    // C++ wrapper for datum_target
-    struct datum_target : shape_aspect, ObjectHelper<datum_target,1> { datum_target() : Object("datum_target") {}
-		identifier::Out target_id;
-    };
-
-    // C++ wrapper for datum_target_callout
-    struct datum_target_callout : draughting_callout, ObjectHelper<datum_target_callout,0> { datum_target_callout() : Object("datum_target_callout") {}
-
-    };
-
-    // C++ wrapper for default_tolerance_table
-    struct default_tolerance_table : representation, ObjectHelper<default_tolerance_table,0> { default_tolerance_table() : Object("default_tolerance_table") {}
-
-    };
-
-    // C++ wrapper for default_tolerance_table_cell
-    struct default_tolerance_table_cell : compound_representation_item, ObjectHelper<default_tolerance_table_cell,0> { default_tolerance_table_cell() : Object("default_tolerance_table_cell") {}
-
-    };
-
-    // C++ wrapper for defined_symbol
-    struct defined_symbol : geometric_representation_item, ObjectHelper<defined_symbol,2> { defined_symbol() : Object("defined_symbol") {}
-		defined_symbol_select::Out definition;
-		Lazy< symbol_target > target;
-    };
-
-    // C++ wrapper for definitional_representation
-    struct definitional_representation : representation, ObjectHelper<definitional_representation,0> { definitional_representation() : Object("definitional_representation") {}
-
-    };
-
-    // C++ wrapper for definitional_representation_relationship
-    struct definitional_representation_relationship : representation_relationship, ObjectHelper<definitional_representation_relationship,0> { definitional_representation_relationship() : Object("definitional_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for definitional_representation_relationship_with_same_context
-    struct definitional_representation_relationship_with_same_context : definitional_representation_relationship, ObjectHelper<definitional_representation_relationship_with_same_context,0> { definitional_representation_relationship_with_same_context() : Object("definitional_representation_relationship_with_same_context") {}
-
-    };
-
-    // C++ wrapper for degenerate_pcurve
-    struct degenerate_pcurve : point, ObjectHelper<degenerate_pcurve,2> { degenerate_pcurve() : Object("degenerate_pcurve") {}
-		Lazy< surface > basis_surface;
-		Lazy< definitional_representation > reference_to_curve;
-    };
-
-    // C++ wrapper for toroidal_surface
-    struct toroidal_surface : elementary_surface, ObjectHelper<toroidal_surface,2> { toroidal_surface() : Object("toroidal_surface") {}
-		positive_length_measure::Out major_radius;
-		positive_length_measure::Out minor_radius;
-    };
-
-    // C++ wrapper for degenerate_toroidal_surface
-    struct degenerate_toroidal_surface : toroidal_surface, ObjectHelper<degenerate_toroidal_surface,1> { degenerate_toroidal_surface() : Object("degenerate_toroidal_surface") {}
-		BOOLEAN::Out select_outer;
-    };
-
-    // C++ wrapper for descriptive_representation_item
-    struct descriptive_representation_item : representation_item, ObjectHelper<descriptive_representation_item,1> { descriptive_representation_item() : Object("descriptive_representation_item") {}
-		text::Out description;
-    };
-
-    // C++ wrapper for product_definition_context
-    struct product_definition_context : application_context_element, ObjectHelper<product_definition_context,1> { product_definition_context() : Object("product_definition_context") {}
-		label::Out life_cycle_stage;
-    };
-
-    // C++ wrapper for design_context
-    struct design_context : product_definition_context, ObjectHelper<design_context,0> { design_context() : Object("design_context") {}
-
-    };
-
-    // C++ wrapper for design_make_from_relationship
-    struct design_make_from_relationship : product_definition_relationship, ObjectHelper<design_make_from_relationship,0> { design_make_from_relationship() : Object("design_make_from_relationship") {}
-
-    };
-
-    // C++ wrapper for diameter_dimension
-    struct diameter_dimension : dimension_curve_directed_callout, ObjectHelper<diameter_dimension,0> { diameter_dimension() : Object("diameter_dimension") {}
-
-    };
-
-    // C++ wrapper for ratio_measure_with_unit
-    struct ratio_measure_with_unit : measure_with_unit, ObjectHelper<ratio_measure_with_unit,0> { ratio_measure_with_unit() : Object("ratio_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for dielectric_constant_measure_with_unit
-    struct dielectric_constant_measure_with_unit : ratio_measure_with_unit, ObjectHelper<dielectric_constant_measure_with_unit,0> { dielectric_constant_measure_with_unit() : Object("dielectric_constant_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for dimension_callout
-    struct dimension_callout : draughting_callout, ObjectHelper<dimension_callout,0> { dimension_callout() : Object("dimension_callout") {}
-
-    };
-
-    // C++ wrapper for draughting_callout_relationship
-    struct draughting_callout_relationship :  ObjectHelper<draughting_callout_relationship,4> { draughting_callout_relationship() : Object("draughting_callout_relationship") {}
-		label::Out name;
-		text::Out description;
-		Lazy< draughting_callout > relating_draughting_callout;
-		Lazy< draughting_callout > related_draughting_callout;
-    };
-
-    // C++ wrapper for dimension_callout_component_relationship
-    struct dimension_callout_component_relationship : draughting_callout_relationship, ObjectHelper<dimension_callout_component_relationship,0> { dimension_callout_component_relationship() : Object("dimension_callout_component_relationship") {}
-
-    };
-
-    // C++ wrapper for dimension_callout_relationship
-    struct dimension_callout_relationship : draughting_callout_relationship, ObjectHelper<dimension_callout_relationship,0> { dimension_callout_relationship() : Object("dimension_callout_relationship") {}
-
-    };
-
-    // C++ wrapper for dimension_curve
-    struct dimension_curve : annotation_curve_occurrence, ObjectHelper<dimension_curve,0> { dimension_curve() : Object("dimension_curve") {}
-
-    };
-
-    // C++ wrapper for terminator_symbol
-    struct terminator_symbol : annotation_symbol_occurrence, ObjectHelper<terminator_symbol,1> { terminator_symbol() : Object("terminator_symbol") {}
-		Lazy< annotation_curve_occurrence > annotated_curve;
-    };
-
-    // C++ wrapper for dimension_curve_terminator
-    struct dimension_curve_terminator : terminator_symbol, ObjectHelper<dimension_curve_terminator,1> { dimension_curve_terminator() : Object("dimension_curve_terminator") {}
-		dimension_extent_usage::Out role;
-    };
-
-    // C++ wrapper for dimension_curve_terminator_to_projection_curve_associativity
-    struct dimension_curve_terminator_to_projection_curve_associativity : annotation_occurrence_associativity, ObjectHelper<dimension_curve_terminator_to_projection_curve_associativity,0> { dimension_curve_terminator_to_projection_curve_associativity() : Object("dimension_curve_terminator_to_projection_curve_associativity") {}
-
-    };
-
-    // C++ wrapper for dimension_pair
-    struct dimension_pair : draughting_callout_relationship, ObjectHelper<dimension_pair,0> { dimension_pair() : Object("dimension_pair") {}
-
-    };
-
-    // C++ wrapper for dimension_text_associativity
-    struct dimension_text_associativity :  ObjectHelper<dimension_text_associativity,0> { dimension_text_associativity() : Object("dimension_text_associativity") {}
-
-    };
-
-    // C++ wrapper for dimensional_location_with_path
-    struct dimensional_location_with_path : dimensional_location, ObjectHelper<dimensional_location_with_path,1> { dimensional_location_with_path() : Object("dimensional_location_with_path") {}
-		Lazy< shape_aspect > path;
-    };
-
-    // C++ wrapper for dimensional_size_with_path
-    struct dimensional_size_with_path : dimensional_size, ObjectHelper<dimensional_size_with_path,1> { dimensional_size_with_path() : Object("dimensional_size_with_path") {}
-		Lazy< shape_aspect > path;
-    };
-
-    // C++ wrapper for executed_action
-    struct executed_action : action, ObjectHelper<executed_action,0> { executed_action() : Object("executed_action") {}
-
-    };
-
-    // C++ wrapper for directed_action
-    struct directed_action : executed_action, ObjectHelper<directed_action,1> { directed_action() : Object("directed_action") {}
-		Lazy< NotImplemented > directive;
-    };
-
-    // C++ wrapper for directed_dimensional_location
-    struct directed_dimensional_location : dimensional_location, ObjectHelper<directed_dimensional_location,0> { directed_dimensional_location() : Object("directed_dimensional_location") {}
-
-    };
-
-    // C++ wrapper for direction
-    struct direction : geometric_representation_item, ObjectHelper<direction,1> { direction() : Object("direction") {}
-		ListOf< REAL, 2, 3 >::Out direction_ratios;
-    };
-
-    // C++ wrapper for document_file
-    struct document_file :  ObjectHelper<document_file,0> { document_file() : Object("document_file") {}
-
-    };
-
-    // C++ wrapper for document_identifier
-    struct document_identifier : group, ObjectHelper<document_identifier,0> { document_identifier() : Object("document_identifier") {}
-
-    };
-
-    // C++ wrapper for document_identifier_assignment
-    struct document_identifier_assignment : group_assignment, ObjectHelper<document_identifier_assignment,1> { document_identifier_assignment() : Object("document_identifier_assignment") {}
-		ListOf< document_identifier_assigned_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for document_product_association
-    struct document_product_association :  ObjectHelper<document_product_association,4> { document_product_association() : Object("document_product_association") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< NotImplemented > relating_document;
-		product_or_formation_or_definition::Out related_product;
-    };
-
-    // C++ wrapper for document_product_equivalence
-    struct document_product_equivalence : document_product_association, ObjectHelper<document_product_equivalence,0> { document_product_equivalence() : Object("document_product_equivalence") {}
-
-    };
-
-    // C++ wrapper for dose_equivalent_measure_with_unit
-    struct dose_equivalent_measure_with_unit : measure_with_unit, ObjectHelper<dose_equivalent_measure_with_unit,0> { dose_equivalent_measure_with_unit() : Object("dose_equivalent_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for dose_equivalent_unit
-    struct dose_equivalent_unit : derived_unit, ObjectHelper<dose_equivalent_unit,0> { dose_equivalent_unit() : Object("dose_equivalent_unit") {}
-
-    };
-
-    // C++ wrapper for double_offset_shelled_solid
-    struct double_offset_shelled_solid : shelled_solid, ObjectHelper<double_offset_shelled_solid,1> { double_offset_shelled_solid() : Object("double_offset_shelled_solid") {}
-		length_measure::Out thickness2;
-    };
-
-    // C++ wrapper for item_defined_transformation
-    struct item_defined_transformation :  ObjectHelper<item_defined_transformation,4> { item_defined_transformation() : Object("item_defined_transformation") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< representation_item > transform_item_1;
-		Lazy< representation_item > transform_item_2;
-    };
-
-    // C++ wrapper for transformation_with_derived_angle
-    struct transformation_with_derived_angle : item_defined_transformation, ObjectHelper<transformation_with_derived_angle,0> { transformation_with_derived_angle() : Object("transformation_with_derived_angle") {}
-
-    };
-
-    // C++ wrapper for draped_defined_transformation
-    struct draped_defined_transformation : transformation_with_derived_angle, ObjectHelper<draped_defined_transformation,0> { draped_defined_transformation() : Object("draped_defined_transformation") {}
-
-    };
-
-    // C++ wrapper for draughting_annotation_occurrence
-    struct draughting_annotation_occurrence : annotation_occurrence, ObjectHelper<draughting_annotation_occurrence,0> { draughting_annotation_occurrence() : Object("draughting_annotation_occurrence") {}
-
-    };
-
-    // C++ wrapper for draughting_elements
-    struct draughting_elements : draughting_callout, ObjectHelper<draughting_elements,0> { draughting_elements() : Object("draughting_elements") {}
-
-    };
-
-    // C++ wrapper for draughting_model
-    struct draughting_model : representation, ObjectHelper<draughting_model,0> { draughting_model() : Object("draughting_model") {}
-
-    };
-
-    // C++ wrapper for item_identified_representation_usage
-    struct item_identified_representation_usage :  ObjectHelper<item_identified_representation_usage,5> { item_identified_representation_usage() : Object("item_identified_representation_usage") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		represented_definition::Out definition;
-		Lazy< representation > used_representation;
-		Lazy< representation_item > identified_item;
-    };
-
-    // C++ wrapper for draughting_model_item_association
-    struct draughting_model_item_association : item_identified_representation_usage, ObjectHelper<draughting_model_item_association,0> { draughting_model_item_association() : Object("draughting_model_item_association") {}
-
-    };
-
-    // C++ wrapper for pre_defined_colour
-    struct pre_defined_colour :  ObjectHelper<pre_defined_colour,0> { pre_defined_colour() : Object("pre_defined_colour") {}
-
-    };
-
-    // C++ wrapper for draughting_pre_defined_colour
-    struct draughting_pre_defined_colour : pre_defined_colour, ObjectHelper<draughting_pre_defined_colour,0> { draughting_pre_defined_colour() : Object("draughting_pre_defined_colour") {}
-
-    };
-
-    // C++ wrapper for pre_defined_item
-    struct pre_defined_item :  ObjectHelper<pre_defined_item,1> { pre_defined_item() : Object("pre_defined_item") {}
-		label::Out name;
-    };
-
-    // C++ wrapper for pre_defined_curve_font
-    struct pre_defined_curve_font : pre_defined_item, ObjectHelper<pre_defined_curve_font,0> { pre_defined_curve_font() : Object("pre_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for draughting_pre_defined_curve_font
-    struct draughting_pre_defined_curve_font : pre_defined_curve_font, ObjectHelper<draughting_pre_defined_curve_font,0> { draughting_pre_defined_curve_font() : Object("draughting_pre_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for pre_defined_text_font
-    struct pre_defined_text_font : pre_defined_item, ObjectHelper<pre_defined_text_font,0> { pre_defined_text_font() : Object("pre_defined_text_font") {}
-
-    };
-
-    // C++ wrapper for draughting_pre_defined_text_font
-    struct draughting_pre_defined_text_font : pre_defined_text_font, ObjectHelper<draughting_pre_defined_text_font,0> { draughting_pre_defined_text_font() : Object("draughting_pre_defined_text_font") {}
-
-    };
-
-    // C++ wrapper for draughting_subfigure_representation
-    struct draughting_subfigure_representation : symbol_representation, ObjectHelper<draughting_subfigure_representation,0> { draughting_subfigure_representation() : Object("draughting_subfigure_representation") {}
-
-    };
-
-    // C++ wrapper for draughting_symbol_representation
-    struct draughting_symbol_representation : symbol_representation, ObjectHelper<draughting_symbol_representation,0> { draughting_symbol_representation() : Object("draughting_symbol_representation") {}
-
-    };
-
-    // C++ wrapper for text_literal
-    struct text_literal : geometric_representation_item, ObjectHelper<text_literal,5> { text_literal() : Object("text_literal") {}
-		presentable_text::Out literal;
-		axis2_placement::Out placement;
-		text_alignment::Out alignment;
-		text_path::Out path;
-		font_select::Out font;
-    };
-
-    // C++ wrapper for text_literal_with_delineation
-    struct text_literal_with_delineation : text_literal, ObjectHelper<text_literal_with_delineation,1> { text_literal_with_delineation() : Object("text_literal_with_delineation") {}
-		text_delineation::Out delineation;
-    };
-
-    // C++ wrapper for draughting_text_literal_with_delineation
-    struct draughting_text_literal_with_delineation : text_literal_with_delineation, ObjectHelper<draughting_text_literal_with_delineation,0> { draughting_text_literal_with_delineation() : Object("draughting_text_literal_with_delineation") {}
-
-    };
-
-    // C++ wrapper for presentation_set
-    struct presentation_set :  ObjectHelper<presentation_set,0> { presentation_set() : Object("presentation_set") {}
-
-    };
-
-    // C++ wrapper for drawing_revision
-    struct drawing_revision : presentation_set, ObjectHelper<drawing_revision,3> { drawing_revision() : Object("drawing_revision") {}
-		identifier::Out revision_identifier;
-		Lazy< NotImplemented > drawing_identifier;
-		Maybe< text::Out > intended_scale;
-    };
-
-    // C++ wrapper for presentation_representation
-    struct presentation_representation : representation, ObjectHelper<presentation_representation,0> { presentation_representation() : Object("presentation_representation") {}
-
-    };
-
-    // C++ wrapper for presentation_area
-    struct presentation_area : presentation_representation, ObjectHelper<presentation_area,0> { presentation_area() : Object("presentation_area") {}
-
-    };
-
-    // C++ wrapper for drawing_sheet_revision
-    struct drawing_sheet_revision : presentation_area, ObjectHelper<drawing_sheet_revision,1> { drawing_sheet_revision() : Object("drawing_sheet_revision") {}
-		identifier::Out revision_identifier;
-    };
-
-    // C++ wrapper for drawing_sheet_revision_sequence
-    struct drawing_sheet_revision_sequence : representation_relationship, ObjectHelper<drawing_sheet_revision_sequence,0> { drawing_sheet_revision_sequence() : Object("drawing_sheet_revision_sequence") {}
-
-    };
-
-    // C++ wrapper for drawing_sheet_revision_usage
-    struct drawing_sheet_revision_usage : area_in_set, ObjectHelper<drawing_sheet_revision_usage,1> { drawing_sheet_revision_usage() : Object("drawing_sheet_revision_usage") {}
-		identifier::Out sheet_number;
-    };
-
-    // C++ wrapper for edge
-    struct edge : topological_representation_item, ObjectHelper<edge,2> { edge() : Object("edge") {}
-		Lazy< vertex > edge_start;
-		Lazy< vertex > edge_end;
-    };
-
-    // C++ wrapper for edge_based_wireframe_model
-    struct edge_based_wireframe_model : geometric_representation_item, ObjectHelper<edge_based_wireframe_model,1> { edge_based_wireframe_model() : Object("edge_based_wireframe_model") {}
-		ListOf< Lazy< connected_edge_set >, 1, 0 > ebwm_boundary;
-    };
-
-    // C++ wrapper for edge_based_wireframe_shape_representation
-    struct edge_based_wireframe_shape_representation : shape_representation, ObjectHelper<edge_based_wireframe_shape_representation,0> { edge_based_wireframe_shape_representation() : Object("edge_based_wireframe_shape_representation") {}
-
-    };
-
-    // C++ wrapper for edge_blended_solid
-    struct edge_blended_solid : modified_solid, ObjectHelper<edge_blended_solid,1> { edge_blended_solid() : Object("edge_blended_solid") {}
-		ListOf< Lazy< edge_curve >, 1, 0 > blended_edges;
-    };
-
-    // C++ wrapper for edge_curve
-    struct edge_curve :  ObjectHelper<edge_curve,2> { edge_curve() : Object("edge_curve") {}
-		Lazy< curve > edge_geometry;
-		BOOLEAN::Out same_sense;
-    };
-
-    // C++ wrapper for edge_loop
-    struct edge_loop :  ObjectHelper<edge_loop,0> { edge_loop() : Object("edge_loop") {}
-
-    };
-
-    // C++ wrapper for electric_charge_measure_with_unit
-    struct electric_charge_measure_with_unit : measure_with_unit, ObjectHelper<electric_charge_measure_with_unit,0> { electric_charge_measure_with_unit() : Object("electric_charge_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for electric_charge_unit
-    struct electric_charge_unit : derived_unit, ObjectHelper<electric_charge_unit,0> { electric_charge_unit() : Object("electric_charge_unit") {}
-
-    };
-
-    // C++ wrapper for electric_current_measure_with_unit
-    struct electric_current_measure_with_unit : measure_with_unit, ObjectHelper<electric_current_measure_with_unit,0> { electric_current_measure_with_unit() : Object("electric_current_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for electric_current_unit
-    struct electric_current_unit : named_unit, ObjectHelper<electric_current_unit,0> { electric_current_unit() : Object("electric_current_unit") {}
-
-    };
-
-    // C++ wrapper for electric_potential_measure_with_unit
-    struct electric_potential_measure_with_unit : measure_with_unit, ObjectHelper<electric_potential_measure_with_unit,0> { electric_potential_measure_with_unit() : Object("electric_potential_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for electric_potential_unit
-    struct electric_potential_unit : derived_unit, ObjectHelper<electric_potential_unit,0> { electric_potential_unit() : Object("electric_potential_unit") {}
-
-    };
-
-    // C++ wrapper for elementary_brep_shape_representation
-    struct elementary_brep_shape_representation : shape_representation, ObjectHelper<elementary_brep_shape_representation,0> { elementary_brep_shape_representation() : Object("elementary_brep_shape_representation") {}
-
-    };
-
-    // C++ wrapper for ellipse
-    struct ellipse : conic, ObjectHelper<ellipse,2> { ellipse() : Object("ellipse") {}
-		positive_length_measure::Out semi_axis_1;
-		positive_length_measure::Out semi_axis_2;
-    };
-
-    // C++ wrapper for energy_measure_with_unit
-    struct energy_measure_with_unit : measure_with_unit, ObjectHelper<energy_measure_with_unit,0> { energy_measure_with_unit() : Object("energy_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for energy_unit
-    struct energy_unit : derived_unit, ObjectHelper<energy_unit,0> { energy_unit() : Object("energy_unit") {}
-
-    };
-
-    // C++ wrapper for property_definition
-    struct property_definition :  ObjectHelper<property_definition,3> { property_definition() : Object("property_definition") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		characterized_definition::Out definition;
-    };
-
-    // C++ wrapper for fact_type
-    struct fact_type : property_definition, ObjectHelper<fact_type,0> { fact_type() : Object("fact_type") {}
-
-    };
-
-    // C++ wrapper for entity_assertion
-    struct entity_assertion : fact_type, ObjectHelper<entity_assertion,0> { entity_assertion() : Object("entity_assertion") {}
-
-    };
-
-    // C++ wrapper for enum_reference_prefix
-    struct enum_reference_prefix : descriptive_representation_item, ObjectHelper<enum_reference_prefix,0> { enum_reference_prefix() : Object("enum_reference_prefix") {}
-
-    };
-
-    // C++ wrapper for evaluated_characteristic
-    struct evaluated_characteristic :  ObjectHelper<evaluated_characteristic,0> { evaluated_characteristic() : Object("evaluated_characteristic") {}
-
-    };
-
-    // C++ wrapper for evaluated_degenerate_pcurve
-    struct evaluated_degenerate_pcurve : degenerate_pcurve, ObjectHelper<evaluated_degenerate_pcurve,1> { evaluated_degenerate_pcurve() : Object("evaluated_degenerate_pcurve") {}
-		Lazy< cartesian_point > equivalent_point;
-    };
-
-    // C++ wrapper for evaluation_product_definition
-    struct evaluation_product_definition : product_definition, ObjectHelper<evaluation_product_definition,0> { evaluation_product_definition() : Object("evaluation_product_definition") {}
-
-    };
-
-    // C++ wrapper for event_occurrence
-    struct event_occurrence :  ObjectHelper<event_occurrence,3> { event_occurrence() : Object("event_occurrence") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for product_concept_feature_category
-    struct product_concept_feature_category : group, ObjectHelper<product_concept_feature_category,0> { product_concept_feature_category() : Object("product_concept_feature_category") {}
-
-    };
-
-    // C++ wrapper for exclusive_product_concept_feature_category
-    struct exclusive_product_concept_feature_category : product_concept_feature_category, ObjectHelper<exclusive_product_concept_feature_category,0> { exclusive_product_concept_feature_category() : Object("exclusive_product_concept_feature_category") {}
-
-    };
-
-    // C++ wrapper for uncertainty_qualifier
-    struct uncertainty_qualifier :  ObjectHelper<uncertainty_qualifier,2> { uncertainty_qualifier() : Object("uncertainty_qualifier") {}
-		label::Out measure_name;
-		text::Out description;
-    };
-
-    // C++ wrapper for standard_uncertainty
-    struct standard_uncertainty : uncertainty_qualifier, ObjectHelper<standard_uncertainty,1> { standard_uncertainty() : Object("standard_uncertainty") {}
-		REAL::Out uncertainty_value;
-    };
-
-    // C++ wrapper for expanded_uncertainty
-    struct expanded_uncertainty : standard_uncertainty, ObjectHelper<expanded_uncertainty,1> { expanded_uncertainty() : Object("expanded_uncertainty") {}
-		REAL::Out coverage_factor;
-    };
-
-    // C++ wrapper for representation_item_relationship
-    struct representation_item_relationship :  ObjectHelper<representation_item_relationship,4> { representation_item_relationship() : Object("representation_item_relationship") {}
-		label::Out name;
-		Maybe< text::Out > description;
-		Lazy< representation_item > relating_representation_item;
-		Lazy< representation_item > related_representation_item;
-    };
-
-    // C++ wrapper for explicit_procedural_representation_item_relationship
-    struct explicit_procedural_representation_item_relationship : representation_item_relationship, ObjectHelper<explicit_procedural_representation_item_relationship,0> { explicit_procedural_representation_item_relationship() : Object("explicit_procedural_representation_item_relationship") {}
-
-    };
-
-    // C++ wrapper for explicit_procedural_geometric_representation_item_relationship
-    struct explicit_procedural_geometric_representation_item_relationship : explicit_procedural_representation_item_relationship, ObjectHelper<explicit_procedural_geometric_representation_item_relationship,0> { explicit_procedural_geometric_representation_item_relationship() : Object("explicit_procedural_geometric_representation_item_relationship") {}
-
-    };
-
-    // C++ wrapper for explicit_procedural_representation_relationship
-    struct explicit_procedural_representation_relationship : representation_relationship, ObjectHelper<explicit_procedural_representation_relationship,0> { explicit_procedural_representation_relationship() : Object("explicit_procedural_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for explicit_procedural_shape_representation_relationship
-    struct explicit_procedural_shape_representation_relationship : explicit_procedural_representation_relationship, ObjectHelper<explicit_procedural_shape_representation_relationship,0> { explicit_procedural_shape_representation_relationship() : Object("explicit_procedural_shape_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for expression_conversion_based_unit
-    struct expression_conversion_based_unit :  ObjectHelper<expression_conversion_based_unit,0> { expression_conversion_based_unit() : Object("expression_conversion_based_unit") {}
-
-    };
-
-    // C++ wrapper for extension
-    struct extension : derived_shape_aspect, ObjectHelper<extension,0> { extension() : Object("extension") {}
-
-    };
-
-    // C++ wrapper for extent
-    struct extent : characterized_object, ObjectHelper<extent,0> { extent() : Object("extent") {}
-
-    };
-
-    // C++ wrapper for external_source
-    struct external_source :  ObjectHelper<external_source,1> { external_source() : Object("external_source") {}
-		source_item::Out source_id;
-    };
-
-    // C++ wrapper for external_class_library
-    struct external_class_library : external_source, ObjectHelper<external_class_library,0> { external_class_library() : Object("external_class_library") {}
-
-    };
-
-    // C++ wrapper for externally_defined_class
-    struct externally_defined_class :  ObjectHelper<externally_defined_class,0> { externally_defined_class() : Object("externally_defined_class") {}
-
-    };
-
-    // C++ wrapper for externally_defined_colour
-    struct externally_defined_colour :  ObjectHelper<externally_defined_colour,0> { externally_defined_colour() : Object("externally_defined_colour") {}
-
-    };
-
-    // C++ wrapper for externally_defined_context_dependent_unit
-    struct externally_defined_context_dependent_unit :  ObjectHelper<externally_defined_context_dependent_unit,0> { externally_defined_context_dependent_unit() : Object("externally_defined_context_dependent_unit") {}
-
-    };
-
-    // C++ wrapper for externally_defined_conversion_based_unit
-    struct externally_defined_conversion_based_unit :  ObjectHelper<externally_defined_conversion_based_unit,0> { externally_defined_conversion_based_unit() : Object("externally_defined_conversion_based_unit") {}
-
-    };
-
-    // C++ wrapper for externally_defined_currency
-    struct externally_defined_currency :  ObjectHelper<externally_defined_currency,0> { externally_defined_currency() : Object("externally_defined_currency") {}
-
-    };
-
-    // C++ wrapper for externally_defined_item
-    struct externally_defined_item :  ObjectHelper<externally_defined_item,2> { externally_defined_item() : Object("externally_defined_item") {}
-		source_item::Out item_id;
-		Lazy< external_source > source;
-    };
-
-    // C++ wrapper for externally_defined_curve_font
-    struct externally_defined_curve_font : externally_defined_item, ObjectHelper<externally_defined_curve_font,0> { externally_defined_curve_font() : Object("externally_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for externally_defined_dimension_definition
-    struct externally_defined_dimension_definition :  ObjectHelper<externally_defined_dimension_definition,0> { externally_defined_dimension_definition() : Object("externally_defined_dimension_definition") {}
-
-    };
-
-    // C++ wrapper for externally_defined_general_property
-    struct externally_defined_general_property :  ObjectHelper<externally_defined_general_property,0> { externally_defined_general_property() : Object("externally_defined_general_property") {}
-
-    };
-
-    // C++ wrapper for externally_defined_hatch_style
-    struct externally_defined_hatch_style :  ObjectHelper<externally_defined_hatch_style,0> { externally_defined_hatch_style() : Object("externally_defined_hatch_style") {}
-
-    };
-
-    // C++ wrapper for externally_defined_marker
-    struct externally_defined_marker :  ObjectHelper<externally_defined_marker,0> { externally_defined_marker() : Object("externally_defined_marker") {}
-
-    };
-
-    // C++ wrapper for picture_representation_item
-    struct picture_representation_item : bytes_representation_item, ObjectHelper<picture_representation_item,0> { picture_representation_item() : Object("picture_representation_item") {}
-
-    };
-
-    // C++ wrapper for externally_defined_picture_representation_item
-    struct externally_defined_picture_representation_item : picture_representation_item, ObjectHelper<externally_defined_picture_representation_item,0> { externally_defined_picture_representation_item() : Object("externally_defined_picture_representation_item") {}
-
-    };
-
-    // C++ wrapper for externally_defined_representation_item
-    struct externally_defined_representation_item :  ObjectHelper<externally_defined_representation_item,0> { externally_defined_representation_item() : Object("externally_defined_representation_item") {}
-
-    };
-
-    // C++ wrapper for externally_defined_string
-    struct externally_defined_string : externally_defined_representation_item, ObjectHelper<externally_defined_string,0> { externally_defined_string() : Object("externally_defined_string") {}
-
-    };
-
-    // C++ wrapper for externally_defined_symbol
-    struct externally_defined_symbol : externally_defined_item, ObjectHelper<externally_defined_symbol,0> { externally_defined_symbol() : Object("externally_defined_symbol") {}
-
-    };
-
-    // C++ wrapper for externally_defined_terminator_symbol
-    struct externally_defined_terminator_symbol : externally_defined_symbol, ObjectHelper<externally_defined_terminator_symbol,0> { externally_defined_terminator_symbol() : Object("externally_defined_terminator_symbol") {}
-
-    };
-
-    // C++ wrapper for externally_defined_text_font
-    struct externally_defined_text_font : externally_defined_item, ObjectHelper<externally_defined_text_font,0> { externally_defined_text_font() : Object("externally_defined_text_font") {}
-
-    };
-
-    // C++ wrapper for externally_defined_tile
-    struct externally_defined_tile : externally_defined_item, ObjectHelper<externally_defined_tile,0> { externally_defined_tile() : Object("externally_defined_tile") {}
-
-    };
-
-    // C++ wrapper for externally_defined_tile_style
-    struct externally_defined_tile_style :  ObjectHelper<externally_defined_tile_style,0> { externally_defined_tile_style() : Object("externally_defined_tile_style") {}
-
-    };
-
-    // C++ wrapper for swept_area_solid
-    struct swept_area_solid : solid_model, ObjectHelper<swept_area_solid,1> { swept_area_solid() : Object("swept_area_solid") {}
-		Lazy< curve_bounded_surface > swept_area;
-    };
-
-    // C++ wrapper for extruded_area_solid
-    struct extruded_area_solid : swept_area_solid, ObjectHelper<extruded_area_solid,2> { extruded_area_solid() : Object("extruded_area_solid") {}
-		Lazy< direction > extruded_direction;
-		positive_length_measure::Out depth;
-    };
-
-    // C++ wrapper for swept_face_solid
-    struct swept_face_solid : solid_model, ObjectHelper<swept_face_solid,1> { swept_face_solid() : Object("swept_face_solid") {}
-		Lazy< face_surface > swept_face;
-    };
-
-    // C++ wrapper for extruded_face_solid
-    struct extruded_face_solid : swept_face_solid, ObjectHelper<extruded_face_solid,2> { extruded_face_solid() : Object("extruded_face_solid") {}
-		Lazy< direction > extruded_direction;
-		positive_length_measure::Out depth;
-    };
-
-    // C++ wrapper for extruded_face_solid_with_trim_conditions
-    struct extruded_face_solid_with_trim_conditions : extruded_face_solid, ObjectHelper<extruded_face_solid_with_trim_conditions,6> { extruded_face_solid_with_trim_conditions() : Object("extruded_face_solid_with_trim_conditions") {}
-		trim_condition_select::Out first_trim_condition;
-		trim_condition_select::Out second_trim_condition;
-		trim_intent::Out first_trim_intent;
-		trim_intent::Out second_trim_intent;
-		non_negative_length_measure::Out first_offset;
-		non_negative_length_measure::Out second_offset;
-    };
-
-    // C++ wrapper for extruded_face_solid_with_draft_angle
-    struct extruded_face_solid_with_draft_angle : extruded_face_solid_with_trim_conditions, ObjectHelper<extruded_face_solid_with_draft_angle,1> { extruded_face_solid_with_draft_angle() : Object("extruded_face_solid_with_draft_angle") {}
-		plane_angle_measure::Out draft_angle;
-    };
-
-    // C++ wrapper for extruded_face_solid_with_multiple_draft_angles
-    struct extruded_face_solid_with_multiple_draft_angles : extruded_face_solid_with_trim_conditions, ObjectHelper<extruded_face_solid_with_multiple_draft_angles,1> { extruded_face_solid_with_multiple_draft_angles() : Object("extruded_face_solid_with_multiple_draft_angles") {}
-		ListOf< plane_angle_measure, 2, 0 >::Out draft_angles;
-    };
-
-    // C++ wrapper for face
-    struct face : topological_representation_item, ObjectHelper<face,1> { face() : Object("face") {}
-		ListOf< Lazy< face_bound >, 1, 0 > bounds;
-    };
-
-    // C++ wrapper for face_based_surface_model
-    struct face_based_surface_model : geometric_representation_item, ObjectHelper<face_based_surface_model,1> { face_based_surface_model() : Object("face_based_surface_model") {}
-		ListOf< Lazy< connected_face_set >, 1, 0 > fbsm_faces;
-    };
-
-    // C++ wrapper for face_bound
-    struct face_bound : topological_representation_item, ObjectHelper<face_bound,2> { face_bound() : Object("face_bound") {}
-		Lazy< loop > bound;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for face_outer_bound
-    struct face_outer_bound : face_bound, ObjectHelper<face_outer_bound,0> { face_outer_bound() : Object("face_outer_bound") {}
-
-    };
-
-    // C++ wrapper for faceted_brep
-    struct faceted_brep : manifold_solid_brep, ObjectHelper<faceted_brep,0> { faceted_brep() : Object("faceted_brep") {}
-
-    };
-
-    // C++ wrapper for faceted_brep_shape_representation
-    struct faceted_brep_shape_representation : shape_representation, ObjectHelper<faceted_brep_shape_representation,0> { faceted_brep_shape_representation() : Object("faceted_brep_shape_representation") {}
-
-    };
-
-    // C++ wrapper for fill_area_style
-    struct fill_area_style : founded_item, ObjectHelper<fill_area_style,2> { fill_area_style() : Object("fill_area_style") {}
-		label::Out name;
-		ListOf< fill_style_select, 1, 0 >::Out fill_styles;
-    };
-
-    // C++ wrapper for fill_area_style_hatching
-    struct fill_area_style_hatching : geometric_representation_item, ObjectHelper<fill_area_style_hatching,5> { fill_area_style_hatching() : Object("fill_area_style_hatching") {}
-		Lazy< curve_style > hatch_line_appearance;
-		Lazy< one_direction_repeat_factor > start_of_next_hatch_line;
-		Lazy< cartesian_point > point_of_reference_hatch_line;
-		Lazy< cartesian_point > pattern_start;
-		plane_angle_measure::Out hatch_line_angle;
-    };
-
-    // C++ wrapper for fill_area_style_tile_coloured_region
-    struct fill_area_style_tile_coloured_region : geometric_representation_item, ObjectHelper<fill_area_style_tile_coloured_region,2> { fill_area_style_tile_coloured_region() : Object("fill_area_style_tile_coloured_region") {}
-		curve_or_annotation_curve_occurrence::Out closed_curve;
-		Lazy< colour > region_colour;
-    };
-
-    // C++ wrapper for fill_area_style_tile_curve_with_style
-    struct fill_area_style_tile_curve_with_style : geometric_representation_item, ObjectHelper<fill_area_style_tile_curve_with_style,1> { fill_area_style_tile_curve_with_style() : Object("fill_area_style_tile_curve_with_style") {}
-		Lazy< annotation_curve_occurrence > styled_curve;
-    };
-
-    // C++ wrapper for fill_area_style_tile_symbol_with_style
-    struct fill_area_style_tile_symbol_with_style : geometric_representation_item, ObjectHelper<fill_area_style_tile_symbol_with_style,1> { fill_area_style_tile_symbol_with_style() : Object("fill_area_style_tile_symbol_with_style") {}
-		Lazy< annotation_symbol_occurrence > symbol;
-    };
-
-    // C++ wrapper for fill_area_style_tiles
-    struct fill_area_style_tiles : geometric_representation_item, ObjectHelper<fill_area_style_tiles,3> { fill_area_style_tiles() : Object("fill_area_style_tiles") {}
-		Lazy< two_direction_repeat_factor > tiling_pattern;
-		ListOf< fill_area_style_tile_shape_select, 1, 0 >::Out tiles;
-		positive_ratio_measure::Out tiling_scale;
-    };
-
-    // C++ wrapper for shape_representation_relationship
-    struct shape_representation_relationship : representation_relationship, ObjectHelper<shape_representation_relationship,0> { shape_representation_relationship() : Object("shape_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for flat_pattern_ply_representation_relationship
-    struct flat_pattern_ply_representation_relationship : shape_representation_relationship, ObjectHelper<flat_pattern_ply_representation_relationship,0> { flat_pattern_ply_representation_relationship() : Object("flat_pattern_ply_representation_relationship") {}
-
-    };
-
-    // C++ wrapper for flatness_tolerance
-    struct flatness_tolerance : geometric_tolerance, ObjectHelper<flatness_tolerance,0> { flatness_tolerance() : Object("flatness_tolerance") {}
-
-    };
-
-    // C++ wrapper for force_measure_with_unit
-    struct force_measure_with_unit : measure_with_unit, ObjectHelper<force_measure_with_unit,0> { force_measure_with_unit() : Object("force_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for force_unit
-    struct force_unit : derived_unit, ObjectHelper<force_unit,0> { force_unit() : Object("force_unit") {}
-
-    };
-
-    // C++ wrapper for forward_chaining_rule
-    struct forward_chaining_rule : rule_definition, ObjectHelper<forward_chaining_rule,0> { forward_chaining_rule() : Object("forward_chaining_rule") {}
-
-    };
-
-    // C++ wrapper for forward_chaining_rule_premise
-    struct forward_chaining_rule_premise :  ObjectHelper<forward_chaining_rule_premise,0> { forward_chaining_rule_premise() : Object("forward_chaining_rule_premise") {}
-
-    };
-
-    // C++ wrapper for frequency_measure_with_unit
-    struct frequency_measure_with_unit : measure_with_unit, ObjectHelper<frequency_measure_with_unit,0> { frequency_measure_with_unit() : Object("frequency_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for frequency_unit
-    struct frequency_unit : derived_unit, ObjectHelper<frequency_unit,0> { frequency_unit() : Object("frequency_unit") {}
-
-    };
-
-    // C++ wrapper for func
-    struct func : compound_representation_item, ObjectHelper<func,0> { func() : Object("func") {}
-
-    };
-
-    // C++ wrapper for functional_breakdown_context
-    struct functional_breakdown_context : breakdown_context, ObjectHelper<functional_breakdown_context,0> { functional_breakdown_context() : Object("functional_breakdown_context") {}
-
-    };
-
-    // C++ wrapper for functional_element_usage
-    struct functional_element_usage : breakdown_element_usage, ObjectHelper<functional_element_usage,0> { functional_element_usage() : Object("functional_element_usage") {}
-
-    };
-
-    // C++ wrapper for general_material_property
-    struct general_material_property : general_property, ObjectHelper<general_material_property,0> { general_material_property() : Object("general_material_property") {}
-
-    };
-
-    // C++ wrapper for simple_generic_expression
-    struct simple_generic_expression : generic_expression, ObjectHelper<simple_generic_expression,0> { simple_generic_expression() : Object("simple_generic_expression") {}
-
-    };
-
-    // C++ wrapper for generic_literal
-    struct generic_literal : simple_generic_expression, ObjectHelper<generic_literal,0> { generic_literal() : Object("generic_literal") {}
-
-    };
-
-    // C++ wrapper for generic_variable
-    struct generic_variable : simple_generic_expression, ObjectHelper<generic_variable,0> { generic_variable() : Object("generic_variable") {}
-
-    };
-
-    // C++ wrapper for geometric_alignment
-    struct geometric_alignment : derived_shape_aspect, ObjectHelper<geometric_alignment,0> { geometric_alignment() : Object("geometric_alignment") {}
-
-    };
-
-    // C++ wrapper for geometric_set
-    struct geometric_set : geometric_representation_item, ObjectHelper<geometric_set,1> { geometric_set() : Object("geometric_set") {}
-		ListOf< geometric_set_select, 1, 0 >::Out elements;
-    };
-
-    // C++ wrapper for geometric_curve_set
-    struct geometric_curve_set : geometric_set, ObjectHelper<geometric_curve_set,0> { geometric_curve_set() : Object("geometric_curve_set") {}
-
-    };
-
-    // C++ wrapper for geometric_intersection
-    struct geometric_intersection : derived_shape_aspect, ObjectHelper<geometric_intersection,0> { geometric_intersection() : Object("geometric_intersection") {}
-
-    };
-
-    // C++ wrapper for geometric_item_specific_usage
-    struct geometric_item_specific_usage : item_identified_representation_usage, ObjectHelper<geometric_item_specific_usage,0> { geometric_item_specific_usage() : Object("geometric_item_specific_usage") {}
-
-    };
-
-    // C++ wrapper for geometric_model_element_relationship
-    struct geometric_model_element_relationship :  ObjectHelper<geometric_model_element_relationship,0> { geometric_model_element_relationship() : Object("geometric_model_element_relationship") {}
-
-    };
-
-    // C++ wrapper for representation_context
-    struct representation_context :  ObjectHelper<representation_context,2> { representation_context() : Object("representation_context") {}
-		identifier::Out context_identifier;
-		text::Out context_type;
-    };
-
-    // C++ wrapper for geometric_representation_context
-    struct geometric_representation_context : representation_context, ObjectHelper<geometric_representation_context,1> { geometric_representation_context() : Object("geometric_representation_context") {}
-		dimension_count::Out coordinate_space_dimension;
-    };
-
-    // C++ wrapper for geometric_tolerance_with_defined_unit
-    struct geometric_tolerance_with_defined_unit : geometric_tolerance, ObjectHelper<geometric_tolerance_with_defined_unit,1> { geometric_tolerance_with_defined_unit() : Object("geometric_tolerance_with_defined_unit") {}
-		Lazy< measure_with_unit > unit_size;
-    };
-
-    // C++ wrapper for geometrical_tolerance_callout
-    struct geometrical_tolerance_callout : draughting_callout, ObjectHelper<geometrical_tolerance_callout,0> { geometrical_tolerance_callout() : Object("geometrical_tolerance_callout") {}
-
-    };
-
-    // C++ wrapper for geometrically_bounded_2d_wireframe_representation
-    struct geometrically_bounded_2d_wireframe_representation : shape_representation, ObjectHelper<geometrically_bounded_2d_wireframe_representation,0> { geometrically_bounded_2d_wireframe_representation() : Object("geometrically_bounded_2d_wireframe_representation") {}
-
-    };
-
-    // C++ wrapper for geometrically_bounded_surface_shape_representation
-    struct geometrically_bounded_surface_shape_representation : shape_representation, ObjectHelper<geometrically_bounded_surface_shape_representation,0> { geometrically_bounded_surface_shape_representation() : Object("geometrically_bounded_surface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for geometrically_bounded_wireframe_shape_representation
-    struct geometrically_bounded_wireframe_shape_representation : shape_representation, ObjectHelper<geometrically_bounded_wireframe_shape_representation,0> { geometrically_bounded_wireframe_shape_representation() : Object("geometrically_bounded_wireframe_shape_representation") {}
-
-    };
-
-    // C++ wrapper for global_assignment
-    struct global_assignment : representation_item_relationship, ObjectHelper<global_assignment,0> { global_assignment() : Object("global_assignment") {}
-
-    };
-
-    // C++ wrapper for global_uncertainty_assigned_context
-    struct global_uncertainty_assigned_context : representation_context, ObjectHelper<global_uncertainty_assigned_context,1> { global_uncertainty_assigned_context() : Object("global_uncertainty_assigned_context") {}
-		ListOf< Lazy< uncertainty_measure_with_unit >, 1, 0 > uncertainty;
-    };
-
-    // C++ wrapper for global_unit_assigned_context
-    struct global_unit_assigned_context : representation_context, ObjectHelper<global_unit_assigned_context,1> { global_unit_assigned_context() : Object("global_unit_assigned_context") {}
-		ListOf< unit, 1, 0 >::Out units;
-    };
-
-    // C++ wrapper for ground_fact
-    struct ground_fact : atomic_formula, ObjectHelper<ground_fact,0> { ground_fact() : Object("ground_fact") {}
-
-    };
-
-    // C++ wrapper for hardness_representation
-    struct hardness_representation : representation, ObjectHelper<hardness_representation,0> { hardness_representation() : Object("hardness_representation") {}
-
-    };
-
-    // C++ wrapper for hidden_element_over_riding_styled_item
-    struct hidden_element_over_riding_styled_item : context_dependent_over_riding_styled_item, ObjectHelper<hidden_element_over_riding_styled_item,0> { hidden_element_over_riding_styled_item() : Object("hidden_element_over_riding_styled_item") {}
-
-    };
-
-    // C++ wrapper for hyperbola
-    struct hyperbola : conic, ObjectHelper<hyperbola,2> { hyperbola() : Object("hyperbola") {}
-		positive_length_measure::Out semi_axis;
-		positive_length_measure::Out semi_imag_axis;
-    };
-
-    // C++ wrapper for illuminance_measure_with_unit
-    struct illuminance_measure_with_unit : measure_with_unit, ObjectHelper<illuminance_measure_with_unit,0> { illuminance_measure_with_unit() : Object("illuminance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for illuminance_unit
-    struct illuminance_unit : derived_unit, ObjectHelper<illuminance_unit,0> { illuminance_unit() : Object("illuminance_unit") {}
-
-    };
-
-    // C++ wrapper for included_text_block
-    struct included_text_block : mapped_item, ObjectHelper<included_text_block,0> { included_text_block() : Object("included_text_block") {}
-
-    };
-
-    // C++ wrapper for inclusion_product_concept_feature
-    struct inclusion_product_concept_feature : conditional_concept_feature, ObjectHelper<inclusion_product_concept_feature,0> { inclusion_product_concept_feature() : Object("inclusion_product_concept_feature") {}
-
-    };
-
-    // C++ wrapper for user_selected_elements
-    struct user_selected_elements : representation_item, ObjectHelper<user_selected_elements,1> { user_selected_elements() : Object("user_selected_elements") {}
-		ListOf< Lazy< representation_item >, 1, 0 > picked_items;
-    };
-
-    // C++ wrapper for indirectly_selected_elements
-    struct indirectly_selected_elements : user_selected_elements, ObjectHelper<indirectly_selected_elements,1> { indirectly_selected_elements() : Object("indirectly_selected_elements") {}
-		ListOf< Lazy< representation_item >, 1, 0 > indirectly_picked_items;
-    };
-
-    // C++ wrapper for indirectly_selected_shape_elements
-    struct indirectly_selected_shape_elements :  ObjectHelper<indirectly_selected_shape_elements,0> { indirectly_selected_shape_elements() : Object("indirectly_selected_shape_elements") {}
-
-    };
-
-    // C++ wrapper for inductance_measure_with_unit
-    struct inductance_measure_with_unit : measure_with_unit, ObjectHelper<inductance_measure_with_unit,0> { inductance_measure_with_unit() : Object("inductance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for inductance_unit
-    struct inductance_unit : derived_unit, ObjectHelper<inductance_unit,0> { inductance_unit() : Object("inductance_unit") {}
-
-    };
-
-    // C++ wrapper for information_right
-    struct information_right : action_method, ObjectHelper<information_right,0> { information_right() : Object("information_right") {}
-
-    };
-
-    // C++ wrapper for information_usage_right
-    struct information_usage_right : action_method, ObjectHelper<information_usage_right,0> { information_usage_right() : Object("information_usage_right") {}
-
-    };
-
-    // C++ wrapper for instance_usage_context_assignment
-    struct instance_usage_context_assignment : product_definition_context, ObjectHelper<instance_usage_context_assignment,1> { instance_usage_context_assignment() : Object("instance_usage_context_assignment") {}
-		ListOf< instance_usage_context_select, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for instanced_feature
-    struct instanced_feature :  ObjectHelper<instanced_feature,0> { instanced_feature() : Object("instanced_feature") {}
-
-    };
-
-    // C++ wrapper for literal_number
-    struct literal_number :  ObjectHelper<literal_number,1> { literal_number() : Object("literal_number") {}
-		NUMBER::Out the_value;
-    };
-
-    // C++ wrapper for int_literal
-    struct int_literal : literal_number, ObjectHelper<int_literal,0> { int_literal() : Object("int_literal") {}
-
-    };
-
-    // C++ wrapper for integer_representation_item
-    struct integer_representation_item :  ObjectHelper<integer_representation_item,0> { integer_representation_item() : Object("integer_representation_item") {}
-
-    };
-
-    // C++ wrapper for surface_curve
-    struct surface_curve : curve, ObjectHelper<surface_curve,3> { surface_curve() : Object("surface_curve") {}
-		Lazy< curve > curve_3d;
-		ListOf< pcurve_or_surface, 1, 2 >::Out associated_geometry;
-		preferred_surface_curve_representation::Out master_representation;
-    };
-
-    // C++ wrapper for intersection_curve
-    struct intersection_curve : surface_curve, ObjectHelper<intersection_curve,0> { intersection_curve() : Object("intersection_curve") {}
-
-    };
-
-    // C++ wrapper for interval_expression
-    struct interval_expression :  ObjectHelper<interval_expression,0> { interval_expression() : Object("interval_expression") {}
-
-    };
-
-    // C++ wrapper for iso4217_currency
-    struct iso4217_currency : currency, ObjectHelper<iso4217_currency,0> { iso4217_currency() : Object("iso4217_currency") {}
-
-    };
-
-    // C++ wrapper for known_source
-    struct known_source :  ObjectHelper<known_source,0> { known_source() : Object("known_source") {}
-
-    };
-
-    // C++ wrapper for laid_defined_transformation
-    struct laid_defined_transformation : transformation_with_derived_angle, ObjectHelper<laid_defined_transformation,0> { laid_defined_transformation() : Object("laid_defined_transformation") {}
-
-    };
-
-    // C++ wrapper for language
-    struct language : group, ObjectHelper<language,0> { language() : Object("language") {}
-
-    };
-
-    // C++ wrapper for leader_curve
-    struct leader_curve : annotation_curve_occurrence, ObjectHelper<leader_curve,0> { leader_curve() : Object("leader_curve") {}
-
-    };
-
-    // C++ wrapper for leader_directed_callout
-    struct leader_directed_callout : draughting_callout, ObjectHelper<leader_directed_callout,0> { leader_directed_callout() : Object("leader_directed_callout") {}
-
-    };
-
-    // C++ wrapper for leader_directed_dimension
-    struct leader_directed_dimension : leader_directed_callout, ObjectHelper<leader_directed_dimension,0> { leader_directed_dimension() : Object("leader_directed_dimension") {}
-
-    };
-
-    // C++ wrapper for leader_terminator
-    struct leader_terminator : terminator_symbol, ObjectHelper<leader_terminator,0> { leader_terminator() : Object("leader_terminator") {}
-
-    };
-
-    // C++ wrapper for length_measure_with_unit
-    struct length_measure_with_unit : measure_with_unit, ObjectHelper<length_measure_with_unit,0> { length_measure_with_unit() : Object("length_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for length_unit
-    struct length_unit : named_unit, ObjectHelper<length_unit,0> { length_unit() : Object("length_unit") {}
-
-    };
-
-    // C++ wrapper for light_source
-    struct light_source : geometric_representation_item, ObjectHelper<light_source,1> { light_source() : Object("light_source") {}
-		Lazy< colour > light_colour;
-    };
-
-    // C++ wrapper for light_source_ambient
-    struct light_source_ambient : light_source, ObjectHelper<light_source_ambient,0> { light_source_ambient() : Object("light_source_ambient") {}
-
-    };
-
-    // C++ wrapper for light_source_directional
-    struct light_source_directional : light_source, ObjectHelper<light_source_directional,1> { light_source_directional() : Object("light_source_directional") {}
-		Lazy< direction > orientation;
-    };
-
-    // C++ wrapper for light_source_positional
-    struct light_source_positional : light_source, ObjectHelper<light_source_positional,3> { light_source_positional() : Object("light_source_positional") {}
-		Lazy< cartesian_point > position;
-		REAL::Out constant_attenuation;
-		REAL::Out distance_attenuation;
-    };
-
-    // C++ wrapper for light_source_spot
-    struct light_source_spot : light_source, ObjectHelper<light_source_spot,6> { light_source_spot() : Object("light_source_spot") {}
-		Lazy< cartesian_point > position;
-		Lazy< direction > orientation;
-		REAL::Out concentration_exponent;
-		REAL::Out constant_attenuation;
-		REAL::Out distance_attenuation;
-		positive_plane_angle_measure::Out spread_angle;
-    };
-
-    // C++ wrapper for line
-    struct line : curve, ObjectHelper<line,2> { line() : Object("line") {}
-		Lazy< cartesian_point > pnt;
-		Lazy< vector > dir;
-    };
-
-    // C++ wrapper for line_profile_tolerance
-    struct line_profile_tolerance : geometric_tolerance, ObjectHelper<line_profile_tolerance,0> { line_profile_tolerance() : Object("line_profile_tolerance") {}
-
-    };
-
-    // C++ wrapper for linear_dimension
-    struct linear_dimension : dimension_curve_directed_callout, ObjectHelper<linear_dimension,0> { linear_dimension() : Object("linear_dimension") {}
-
-    };
-
-    // C++ wrapper for simple_clause
-    struct simple_clause : compound_representation_item, ObjectHelper<simple_clause,0> { simple_clause() : Object("simple_clause") {}
-
-    };
-
-    // C++ wrapper for literal_conjunction
-    struct literal_conjunction : simple_clause, ObjectHelper<literal_conjunction,0> { literal_conjunction() : Object("literal_conjunction") {}
-
-    };
-
-    // C++ wrapper for literal_disjunction
-    struct literal_disjunction : simple_clause, ObjectHelper<literal_disjunction,0> { literal_disjunction() : Object("literal_disjunction") {}
-
-    };
-
-    // C++ wrapper for logical_literal
-    struct logical_literal : generic_literal, ObjectHelper<logical_literal,1> { logical_literal() : Object("logical_literal") {}
-		LOGICAL::Out lit_value;
-    };
-
-    // C++ wrapper for logical_representation_item
-    struct logical_representation_item :  ObjectHelper<logical_representation_item,0> { logical_representation_item() : Object("logical_representation_item") {}
-
-    };
-
-    // C++ wrapper for loop
-    struct loop : topological_representation_item, ObjectHelper<loop,0> { loop() : Object("loop") {}
-
-    };
-
-    // C++ wrapper for loss_tangent_measure_with_unit
-    struct loss_tangent_measure_with_unit : ratio_measure_with_unit, ObjectHelper<loss_tangent_measure_with_unit,0> { loss_tangent_measure_with_unit() : Object("loss_tangent_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for lot_effectivity
-    struct lot_effectivity : effectivity, ObjectHelper<lot_effectivity,2> { lot_effectivity() : Object("lot_effectivity") {}
-		identifier::Out effectivity_lot_id;
-		Lazy< measure_with_unit > effectivity_lot_size;
-    };
-
-    // C++ wrapper for luminous_flux_measure_with_unit
-    struct luminous_flux_measure_with_unit : measure_with_unit, ObjectHelper<luminous_flux_measure_with_unit,0> { luminous_flux_measure_with_unit() : Object("luminous_flux_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for luminous_flux_unit
-    struct luminous_flux_unit : named_unit, ObjectHelper<luminous_flux_unit,0> { luminous_flux_unit() : Object("luminous_flux_unit") {}
-
-    };
-
-    // C++ wrapper for luminous_intensity_measure_with_unit
-    struct luminous_intensity_measure_with_unit : measure_with_unit, ObjectHelper<luminous_intensity_measure_with_unit,0> { luminous_intensity_measure_with_unit() : Object("luminous_intensity_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for luminous_intensity_unit
-    struct luminous_intensity_unit : named_unit, ObjectHelper<luminous_intensity_unit,0> { luminous_intensity_unit() : Object("luminous_intensity_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_density_measure_with_unit
-    struct magnetic_flux_density_measure_with_unit : measure_with_unit, ObjectHelper<magnetic_flux_density_measure_with_unit,0> { magnetic_flux_density_measure_with_unit() : Object("magnetic_flux_density_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_density_unit
-    struct magnetic_flux_density_unit : derived_unit, ObjectHelper<magnetic_flux_density_unit,0> { magnetic_flux_density_unit() : Object("magnetic_flux_density_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_measure_with_unit
-    struct magnetic_flux_measure_with_unit : measure_with_unit, ObjectHelper<magnetic_flux_measure_with_unit,0> { magnetic_flux_measure_with_unit() : Object("magnetic_flux_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for magnetic_flux_unit
-    struct magnetic_flux_unit : derived_unit, ObjectHelper<magnetic_flux_unit,0> { magnetic_flux_unit() : Object("magnetic_flux_unit") {}
-
-    };
-
-    // C++ wrapper for make_from_usage_option
-    struct make_from_usage_option : product_definition_usage, ObjectHelper<make_from_usage_option,3> { make_from_usage_option() : Object("make_from_usage_option") {}
-		INTEGER::Out ranking;
-		text::Out ranking_rationale;
-		Lazy< measure_with_unit > quantity;
-    };
-
-    // C++ wrapper for manifold_subsurface_shape_representation
-    struct manifold_subsurface_shape_representation : shape_representation, ObjectHelper<manifold_subsurface_shape_representation,0> { manifold_subsurface_shape_representation() : Object("manifold_subsurface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for manifold_surface_shape_representation
-    struct manifold_surface_shape_representation : shape_representation, ObjectHelper<manifold_surface_shape_representation,0> { manifold_surface_shape_representation() : Object("manifold_surface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for mass_measure_with_unit
-    struct mass_measure_with_unit : measure_with_unit, ObjectHelper<mass_measure_with_unit,0> { mass_measure_with_unit() : Object("mass_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for mass_unit
-    struct mass_unit : named_unit, ObjectHelper<mass_unit,0> { mass_unit() : Object("mass_unit") {}
-
-    };
-
-    // C++ wrapper for material_property
-    struct material_property : property_definition, ObjectHelper<material_property,0> { material_property() : Object("material_property") {}
-
-    };
-
-    // C++ wrapper for property_definition_representation
-    struct property_definition_representation :  ObjectHelper<property_definition_representation,2> { property_definition_representation() : Object("property_definition_representation") {}
-		represented_definition::Out definition;
-		Lazy< representation > used_representation;
-    };
-
-    // C++ wrapper for material_property_representation
-    struct material_property_representation : property_definition_representation, ObjectHelper<material_property_representation,1> { material_property_representation() : Object("material_property_representation") {}
-		Lazy< NotImplemented > dependent_environment;
-    };
-
-    // C++ wrapper for measure_representation_item
-    struct measure_representation_item :  ObjectHelper<measure_representation_item,0> { measure_representation_item() : Object("measure_representation_item") {}
-
-    };
-
-    // C++ wrapper for product_context
-    struct product_context : application_context_element, ObjectHelper<product_context,1> { product_context() : Object("product_context") {}
-		label::Out discipline_type;
-    };
-
-    // C++ wrapper for mechanical_context
-    struct mechanical_context : product_context, ObjectHelper<mechanical_context,0> { mechanical_context() : Object("mechanical_context") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_and_draughting_relationship
-    struct mechanical_design_and_draughting_relationship : definitional_representation_relationship_with_same_context, ObjectHelper<mechanical_design_and_draughting_relationship,0> { mechanical_design_and_draughting_relationship() : Object("mechanical_design_and_draughting_relationship") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_geometric_presentation_area
-    struct mechanical_design_geometric_presentation_area : presentation_area, ObjectHelper<mechanical_design_geometric_presentation_area,0> { mechanical_design_geometric_presentation_area() : Object("mechanical_design_geometric_presentation_area") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_geometric_presentation_representation
-    struct mechanical_design_geometric_presentation_representation : representation, ObjectHelper<mechanical_design_geometric_presentation_representation,0> { mechanical_design_geometric_presentation_representation() : Object("mechanical_design_geometric_presentation_representation") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_presentation_representation_with_draughting
-    struct mechanical_design_presentation_representation_with_draughting : representation, ObjectHelper<mechanical_design_presentation_representation_with_draughting,0> { mechanical_design_presentation_representation_with_draughting() : Object("mechanical_design_presentation_representation_with_draughting") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_shaded_presentation_area
-    struct mechanical_design_shaded_presentation_area : presentation_area, ObjectHelper<mechanical_design_shaded_presentation_area,0> { mechanical_design_shaded_presentation_area() : Object("mechanical_design_shaded_presentation_area") {}
-
-    };
-
-    // C++ wrapper for mechanical_design_shaded_presentation_representation
-    struct mechanical_design_shaded_presentation_representation : representation, ObjectHelper<mechanical_design_shaded_presentation_representation,0> { mechanical_design_shaded_presentation_representation() : Object("mechanical_design_shaded_presentation_representation") {}
-
-    };
-
-    // C++ wrapper for min_and_major_ply_orientation_basis
-    struct min_and_major_ply_orientation_basis :  ObjectHelper<min_and_major_ply_orientation_basis,0> { min_and_major_ply_orientation_basis() : Object("min_and_major_ply_orientation_basis") {}
-
-    };
-
-    // C++ wrapper for modified_geometric_tolerance
-    struct modified_geometric_tolerance : geometric_tolerance, ObjectHelper<modified_geometric_tolerance,1> { modified_geometric_tolerance() : Object("modified_geometric_tolerance") {}
-		limit_condition::Out modifier;
-    };
-
-    // C++ wrapper for modified_solid_with_placed_configuration
-    struct modified_solid_with_placed_configuration : modified_solid, ObjectHelper<modified_solid_with_placed_configuration,1> { modified_solid_with_placed_configuration() : Object("modified_solid_with_placed_configuration") {}
-		Lazy< axis2_placement_3d > placing;
-    };
-
-    // C++ wrapper for moments_of_inertia_representation
-    struct moments_of_inertia_representation : representation, ObjectHelper<moments_of_inertia_representation,0> { moments_of_inertia_representation() : Object("moments_of_inertia_representation") {}
-
-    };
-
-    // C++ wrapper for multi_language_attribute_assignment
-    struct multi_language_attribute_assignment : attribute_value_assignment, ObjectHelper<multi_language_attribute_assignment,1> { multi_language_attribute_assignment() : Object("multi_language_attribute_assignment") {}
-		ListOf< multi_language_attribute_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for multiple_arity_boolean_expression
-    struct multiple_arity_boolean_expression :  ObjectHelper<multiple_arity_boolean_expression,0> { multiple_arity_boolean_expression() : Object("multiple_arity_boolean_expression") {}
-
-    };
-
-    // C++ wrapper for multiple_arity_generic_expression
-    struct multiple_arity_generic_expression : generic_expression, ObjectHelper<multiple_arity_generic_expression,1> { multiple_arity_generic_expression() : Object("multiple_arity_generic_expression") {}
-		ListOf< Lazy< generic_expression >, 2, 0 > operands;
-    };
-
-    // C++ wrapper for multiple_arity_numeric_expression
-    struct multiple_arity_numeric_expression :  ObjectHelper<multiple_arity_numeric_expression,0> { multiple_arity_numeric_expression() : Object("multiple_arity_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for next_assembly_usage_occurrence
-    struct next_assembly_usage_occurrence : assembly_component_usage, ObjectHelper<next_assembly_usage_occurrence,0> { next_assembly_usage_occurrence() : Object("next_assembly_usage_occurrence") {}
-
-    };
-
-    // C++ wrapper for non_manifold_surface_shape_representation
-    struct non_manifold_surface_shape_representation : shape_representation, ObjectHelper<non_manifold_surface_shape_representation,0> { non_manifold_surface_shape_representation() : Object("non_manifold_surface_shape_representation") {}
-
-    };
-
-    // C++ wrapper for null_representation_item
-    struct null_representation_item : representation_item, ObjectHelper<null_representation_item,0> { null_representation_item() : Object("null_representation_item") {}
-
-    };
-
-    // C++ wrapper for numeric_expression
-    struct numeric_expression : expression, ObjectHelper<numeric_expression,0> { numeric_expression() : Object("numeric_expression") {}
-
-    };
-
-    // C++ wrapper for offset_curve_2d
-    struct offset_curve_2d : curve, ObjectHelper<offset_curve_2d,3> { offset_curve_2d() : Object("offset_curve_2d") {}
-		Lazy< curve > basis_curve;
-		length_measure::Out distance;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for offset_curve_3d
-    struct offset_curve_3d : curve, ObjectHelper<offset_curve_3d,4> { offset_curve_3d() : Object("offset_curve_3d") {}
-		Lazy< curve > basis_curve;
-		length_measure::Out distance;
-		LOGICAL::Out self_intersect;
-		Lazy< direction > ref_direction;
-    };
-
-    // C++ wrapper for offset_surface
-    struct offset_surface : surface, ObjectHelper<offset_surface,3> { offset_surface() : Object("offset_surface") {}
-		Lazy< surface > basis_surface;
-		length_measure::Out distance;
-		LOGICAL::Out self_intersect;
-    };
-
-    // C++ wrapper for one_direction_repeat_factor
-    struct one_direction_repeat_factor : geometric_representation_item, ObjectHelper<one_direction_repeat_factor,1> { one_direction_repeat_factor() : Object("one_direction_repeat_factor") {}
-		Lazy< vector > repeat_factor;
-    };
-
-    // C++ wrapper for open_shell
-    struct open_shell : connected_face_set, ObjectHelper<open_shell,0> { open_shell() : Object("open_shell") {}
-
-    };
-
-    // C++ wrapper for ordinal_date
-    struct ordinal_date : date, ObjectHelper<ordinal_date,1> { ordinal_date() : Object("ordinal_date") {}
-		day_in_year_number::Out day_component;
-    };
-
-    // C++ wrapper for projection_directed_callout
-    struct projection_directed_callout : draughting_callout, ObjectHelper<projection_directed_callout,0> { projection_directed_callout() : Object("projection_directed_callout") {}
-
-    };
-
-    // C++ wrapper for ordinate_dimension
-    struct ordinate_dimension : projection_directed_callout, ObjectHelper<ordinate_dimension,0> { ordinate_dimension() : Object("ordinate_dimension") {}
-
-    };
-
-    // C++ wrapper for organizational_address
-    struct organizational_address : address, ObjectHelper<organizational_address,2> { organizational_address() : Object("organizational_address") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > organizations;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for oriented_closed_shell
-    struct oriented_closed_shell : closed_shell, ObjectHelper<oriented_closed_shell,2> { oriented_closed_shell() : Object("oriented_closed_shell") {}
-		Lazy< closed_shell > closed_shell_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_edge
-    struct oriented_edge : edge, ObjectHelper<oriented_edge,2> { oriented_edge() : Object("oriented_edge") {}
-		Lazy< edge > edge_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_face
-    struct oriented_face : face, ObjectHelper<oriented_face,2> { oriented_face() : Object("oriented_face") {}
-		Lazy< face > face_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_open_shell
-    struct oriented_open_shell : open_shell, ObjectHelper<oriented_open_shell,2> { oriented_open_shell() : Object("oriented_open_shell") {}
-		Lazy< open_shell > open_shell_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for path
-    struct path : topological_representation_item, ObjectHelper<path,1> { path() : Object("path") {}
-		ListOf< Lazy< oriented_edge >, 1, 0 > edge_list;
-    };
-
-    // C++ wrapper for oriented_path
-    struct oriented_path : path, ObjectHelper<oriented_path,2> { oriented_path() : Object("oriented_path") {}
-		Lazy< path > path_element;
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for oriented_surface
-    struct oriented_surface : surface, ObjectHelper<oriented_surface,1> { oriented_surface() : Object("oriented_surface") {}
-		BOOLEAN::Out orientation;
-    };
-
-    // C++ wrapper for outer_boundary_curve
-    struct outer_boundary_curve : boundary_curve, ObjectHelper<outer_boundary_curve,0> { outer_boundary_curve() : Object("outer_boundary_curve") {}
-
-    };
-
-    // C++ wrapper for package_product_concept_feature
-    struct package_product_concept_feature : product_concept_feature, ObjectHelper<package_product_concept_feature,0> { package_product_concept_feature() : Object("package_product_concept_feature") {}
-
-    };
-
-    // C++ wrapper for parabola
-    struct parabola : conic, ObjectHelper<parabola,1> { parabola() : Object("parabola") {}
-		length_measure::Out focal_dist;
-    };
-
-    // C++ wrapper for parallel_offset
-    struct parallel_offset : derived_shape_aspect, ObjectHelper<parallel_offset,1> { parallel_offset() : Object("parallel_offset") {}
-		Lazy< measure_with_unit > offset;
-    };
-
-    // C++ wrapper for parallelism_tolerance
-    struct parallelism_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<parallelism_tolerance,0> { parallelism_tolerance() : Object("parallelism_tolerance") {}
-
-    };
-
-    // C++ wrapper for parametric_representation_context
-    struct parametric_representation_context : representation_context, ObjectHelper<parametric_representation_context,0> { parametric_representation_context() : Object("parametric_representation_context") {}
-
-    };
-
-    // C++ wrapper for partial_document_with_structured_text_representation_assignment
-    struct partial_document_with_structured_text_representation_assignment :  ObjectHelper<partial_document_with_structured_text_representation_assignment,0> { partial_document_with_structured_text_representation_assignment() : Object("partial_document_with_structured_text_representation_assignment") {}
-
-    };
-
-    // C++ wrapper for pcurve
-    struct pcurve : curve, ObjectHelper<pcurve,2> { pcurve() : Object("pcurve") {}
-		Lazy< surface > basis_surface;
-		Lazy< definitional_representation > reference_to_curve;
-    };
-
-    // C++ wrapper for percentage_laminate_definition
-    struct percentage_laminate_definition : product_definition, ObjectHelper<percentage_laminate_definition,0> { percentage_laminate_definition() : Object("percentage_laminate_definition") {}
-
-    };
-
-    // C++ wrapper for zone_structural_makeup
-    struct zone_structural_makeup : laminate_table, ObjectHelper<zone_structural_makeup,0> { zone_structural_makeup() : Object("zone_structural_makeup") {}
-
-    };
-
-    // C++ wrapper for percentage_laminate_table
-    struct percentage_laminate_table : zone_structural_makeup, ObjectHelper<percentage_laminate_table,0> { percentage_laminate_table() : Object("percentage_laminate_table") {}
-
-    };
-
-    // C++ wrapper for percentage_ply_definition
-    struct percentage_ply_definition : product_definition, ObjectHelper<percentage_ply_definition,0> { percentage_ply_definition() : Object("percentage_ply_definition") {}
-
-    };
-
-    // C++ wrapper for perpendicular_to
-    struct perpendicular_to : derived_shape_aspect, ObjectHelper<perpendicular_to,0> { perpendicular_to() : Object("perpendicular_to") {}
-
-    };
-
-    // C++ wrapper for perpendicularity_tolerance
-    struct perpendicularity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<perpendicularity_tolerance,0> { perpendicularity_tolerance() : Object("perpendicularity_tolerance") {}
-
-    };
-
-    // C++ wrapper for person_and_organization_address
-    struct person_and_organization_address :  ObjectHelper<person_and_organization_address,0> { person_and_organization_address() : Object("person_and_organization_address") {}
-
-    };
-
-    // C++ wrapper for personal_address
-    struct personal_address : address, ObjectHelper<personal_address,2> { personal_address() : Object("personal_address") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > people;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for physical_breakdown_context
-    struct physical_breakdown_context : breakdown_context, ObjectHelper<physical_breakdown_context,0> { physical_breakdown_context() : Object("physical_breakdown_context") {}
-
-    };
-
-    // C++ wrapper for physical_element_usage
-    struct physical_element_usage : breakdown_element_usage, ObjectHelper<physical_element_usage,0> { physical_element_usage() : Object("physical_element_usage") {}
-
-    };
-
-    // C++ wrapper for presentation_view
-    struct presentation_view : presentation_representation, ObjectHelper<presentation_view,0> { presentation_view() : Object("presentation_view") {}
-
-    };
-
-    // C++ wrapper for picture_representation
-    struct picture_representation : presentation_view, ObjectHelper<picture_representation,0> { picture_representation() : Object("picture_representation") {}
-
-    };
-
-    // C++ wrapper for placed_datum_target_feature
-    struct placed_datum_target_feature : datum_target, ObjectHelper<placed_datum_target_feature,0> { placed_datum_target_feature() : Object("placed_datum_target_feature") {}
-
-    };
-
-    // C++ wrapper for placed_feature
-    struct placed_feature : shape_aspect, ObjectHelper<placed_feature,0> { placed_feature() : Object("placed_feature") {}
-
-    };
-
-    // C++ wrapper for planar_extent
-    struct planar_extent : geometric_representation_item, ObjectHelper<planar_extent,2> { planar_extent() : Object("planar_extent") {}
-		length_measure::Out size_in_x;
-		length_measure::Out size_in_y;
-    };
-
-    // C++ wrapper for planar_box
-    struct planar_box : planar_extent, ObjectHelper<planar_box,1> { planar_box() : Object("planar_box") {}
-		axis2_placement::Out placement;
-    };
-
-    // C++ wrapper for plane
-    struct plane : elementary_surface, ObjectHelper<plane,0> { plane() : Object("plane") {}
-
-    };
-
-    // C++ wrapper for plane_angle_measure_with_unit
-    struct plane_angle_measure_with_unit : measure_with_unit, ObjectHelper<plane_angle_measure_with_unit,0> { plane_angle_measure_with_unit() : Object("plane_angle_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for plane_angle_unit
-    struct plane_angle_unit : named_unit, ObjectHelper<plane_angle_unit,0> { plane_angle_unit() : Object("plane_angle_unit") {}
-
-    };
-
-    // C++ wrapper for ply_laminate_definition
-    struct ply_laminate_definition : product_definition, ObjectHelper<ply_laminate_definition,0> { ply_laminate_definition() : Object("ply_laminate_definition") {}
-
-    };
-
-    // C++ wrapper for ply_laminate_sequence_definition
-    struct ply_laminate_sequence_definition : product_definition, ObjectHelper<ply_laminate_sequence_definition,0> { ply_laminate_sequence_definition() : Object("ply_laminate_sequence_definition") {}
-
-    };
-
-    // C++ wrapper for ply_laminate_table
-    struct ply_laminate_table : part_laminate_table, ObjectHelper<ply_laminate_table,0> { ply_laminate_table() : Object("ply_laminate_table") {}
-
-    };
-
-    // C++ wrapper for point_and_vector
-    struct point_and_vector :  ObjectHelper<point_and_vector,0> { point_and_vector() : Object("point_and_vector") {}
-
-    };
-
-    // C++ wrapper for point_on_curve
-    struct point_on_curve : point, ObjectHelper<point_on_curve,2> { point_on_curve() : Object("point_on_curve") {}
-		Lazy< curve > basis_curve;
-		parameter_value::Out point_parameter;
-    };
-
-    // C++ wrapper for point_on_surface
-    struct point_on_surface : point, ObjectHelper<point_on_surface,3> { point_on_surface() : Object("point_on_surface") {}
-		Lazy< surface > basis_surface;
-		parameter_value::Out point_parameter_u;
-		parameter_value::Out point_parameter_v;
-    };
-
-    // C++ wrapper for point_path
-    struct point_path :  ObjectHelper<point_path,0> { point_path() : Object("point_path") {}
-
-    };
-
-    // C++ wrapper for point_replica
-    struct point_replica : point, ObjectHelper<point_replica,2> { point_replica() : Object("point_replica") {}
-		Lazy< point > parent_pt;
-		Lazy< cartesian_transformation_operator > transformation;
-    };
-
-    // C++ wrapper for point_style
-    struct point_style : founded_item, ObjectHelper<point_style,4> { point_style() : Object("point_style") {}
-		label::Out name;
-		marker_select::Out marker;
-		size_select::Out marker_size;
-		Lazy< colour > marker_colour;
-    };
-
-    // C++ wrapper for polar_complex_number_literal
-    struct polar_complex_number_literal : generic_literal, ObjectHelper<polar_complex_number_literal,2> { polar_complex_number_literal() : Object("polar_complex_number_literal") {}
-		REAL::Out radius;
-		REAL::Out angle;
-    };
-
-    // C++ wrapper for poly_loop
-    struct poly_loop :  ObjectHelper<poly_loop,1> { poly_loop() : Object("poly_loop") {}
-		ListOf< Lazy< cartesian_point >, 3, 0 > polygon;
-    };
-
-    // C++ wrapper for polyline
-    struct polyline : bounded_curve, ObjectHelper<polyline,1> { polyline() : Object("polyline") {}
-		ListOf< Lazy< cartesian_point >, 2, 0 > points;
-    };
-
-    // C++ wrapper for position_tolerance
-    struct position_tolerance : geometric_tolerance, ObjectHelper<position_tolerance,0> { position_tolerance() : Object("position_tolerance") {}
-
-    };
-
-    // C++ wrapper for positioned_sketch
-    struct positioned_sketch : geometric_representation_item, ObjectHelper<positioned_sketch,2> { positioned_sketch() : Object("positioned_sketch") {}
-		sketch_basis_select::Out sketch_basis;
-		ListOf< Lazy< auxiliary_geometric_representation_item >, 0, 0 > auxiliary_elements;
-    };
-
-    // C++ wrapper for power_measure_with_unit
-    struct power_measure_with_unit : measure_with_unit, ObjectHelper<power_measure_with_unit,0> { power_measure_with_unit() : Object("power_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for power_unit
-    struct power_unit : derived_unit, ObjectHelper<power_unit,0> { power_unit() : Object("power_unit") {}
-
-    };
-
-    // C++ wrapper for pre_defined_symbol
-    struct pre_defined_symbol : pre_defined_item, ObjectHelper<pre_defined_symbol,0> { pre_defined_symbol() : Object("pre_defined_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_dimension_symbol
-    struct pre_defined_dimension_symbol : pre_defined_symbol, ObjectHelper<pre_defined_dimension_symbol,0> { pre_defined_dimension_symbol() : Object("pre_defined_dimension_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_geometrical_tolerance_symbol
-    struct pre_defined_geometrical_tolerance_symbol : pre_defined_symbol, ObjectHelper<pre_defined_geometrical_tolerance_symbol,0> { pre_defined_geometrical_tolerance_symbol() : Object("pre_defined_geometrical_tolerance_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_marker
-    struct pre_defined_marker : pre_defined_item, ObjectHelper<pre_defined_marker,0> { pre_defined_marker() : Object("pre_defined_marker") {}
-
-    };
-
-    // C++ wrapper for pre_defined_point_marker_symbol
-    struct pre_defined_point_marker_symbol :  ObjectHelper<pre_defined_point_marker_symbol,0> { pre_defined_point_marker_symbol() : Object("pre_defined_point_marker_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_surface_condition_symbol
-    struct pre_defined_surface_condition_symbol : pre_defined_symbol, ObjectHelper<pre_defined_surface_condition_symbol,0> { pre_defined_surface_condition_symbol() : Object("pre_defined_surface_condition_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_surface_side_style
-    struct pre_defined_surface_side_style : pre_defined_item, ObjectHelper<pre_defined_surface_side_style,0> { pre_defined_surface_side_style() : Object("pre_defined_surface_side_style") {}
-
-    };
-
-    // C++ wrapper for pre_defined_terminator_symbol
-    struct pre_defined_terminator_symbol : pre_defined_symbol, ObjectHelper<pre_defined_terminator_symbol,0> { pre_defined_terminator_symbol() : Object("pre_defined_terminator_symbol") {}
-
-    };
-
-    // C++ wrapper for pre_defined_tile
-    struct pre_defined_tile : pre_defined_item, ObjectHelper<pre_defined_tile,0> { pre_defined_tile() : Object("pre_defined_tile") {}
-
-    };
-
-    // C++ wrapper for predefined_picture_representation_item
-    struct predefined_picture_representation_item : picture_representation_item, ObjectHelper<predefined_picture_representation_item,0> { predefined_picture_representation_item() : Object("predefined_picture_representation_item") {}
-
-    };
-
-    // C++ wrapper for presentation_style_assignment
-    struct presentation_style_assignment : founded_item, ObjectHelper<presentation_style_assignment,1> { presentation_style_assignment() : Object("presentation_style_assignment") {}
-		ListOf< presentation_style_select, 1, 0 >::Out styles;
-    };
-
-    // C++ wrapper for presentation_style_by_context
-    struct presentation_style_by_context : presentation_style_assignment, ObjectHelper<presentation_style_by_context,1> { presentation_style_by_context() : Object("presentation_style_by_context") {}
-		style_context_select::Out style_context;
-    };
-
-    // C++ wrapper for pressure_measure_with_unit
-    struct pressure_measure_with_unit : measure_with_unit, ObjectHelper<pressure_measure_with_unit,0> { pressure_measure_with_unit() : Object("pressure_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for pressure_unit
-    struct pressure_unit : derived_unit, ObjectHelper<pressure_unit,0> { pressure_unit() : Object("pressure_unit") {}
-
-    };
-
-    // C++ wrapper for procedural_representation
-    struct procedural_representation : representation, ObjectHelper<procedural_representation,0> { procedural_representation() : Object("procedural_representation") {}
-
-    };
-
-    // C++ wrapper for procedural_representation_sequence
-    struct procedural_representation_sequence : representation_item, ObjectHelper<procedural_representation_sequence,3> { procedural_representation_sequence() : Object("procedural_representation_sequence") {}
-		ListOf< Lazy< representation_item >, 1, 0 > elements;
-		ListOf< Lazy< representation_item >, 0, 0 > suppressed_items;
-		text::Out rationale;
-    };
-
-    // C++ wrapper for procedural_shape_representation
-    struct procedural_shape_representation :  ObjectHelper<procedural_shape_representation,0> { procedural_shape_representation() : Object("procedural_shape_representation") {}
-
-    };
-
-    // C++ wrapper for procedural_shape_representation_sequence
-    struct procedural_shape_representation_sequence :  ObjectHelper<procedural_shape_representation_sequence,0> { procedural_shape_representation_sequence() : Object("procedural_shape_representation_sequence") {}
-
-    };
-
-    // C++ wrapper for product_category
-    struct product_category :  ObjectHelper<product_category,2> { product_category() : Object("product_category") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for product_class
-    struct product_class :  ObjectHelper<product_class,0> { product_class() : Object("product_class") {}
-
-    };
-
-    // C++ wrapper for product_concept_context
-    struct product_concept_context : application_context_element, ObjectHelper<product_concept_context,1> { product_concept_context() : Object("product_concept_context") {}
-		label::Out market_segment_type;
-    };
-
-    // C++ wrapper for product_concept_feature_category_usage
-    struct product_concept_feature_category_usage : group_assignment, ObjectHelper<product_concept_feature_category_usage,1> { product_concept_feature_category_usage() : Object("product_concept_feature_category_usage") {}
-		ListOf< category_usage_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for product_definition_element_relationship
-    struct product_definition_element_relationship : group, ObjectHelper<product_definition_element_relationship,0> { product_definition_element_relationship() : Object("product_definition_element_relationship") {}
-
-    };
-
-    // C++ wrapper for product_definition_formation
-    struct product_definition_formation :  ObjectHelper<product_definition_formation,3> { product_definition_formation() : Object("product_definition_formation") {}
-		identifier::Out id;
-		Maybe< text::Out > description;
-		Lazy< NotImplemented > of_product;
-    };
-
-    // C++ wrapper for product_definition_formation_with_specified_source
-    struct product_definition_formation_with_specified_source : product_definition_formation, ObjectHelper<product_definition_formation_with_specified_source,1> { product_definition_formation_with_specified_source() : Object("product_definition_formation_with_specified_source") {}
-		source::Out make_or_buy;
-    };
-
-    // C++ wrapper for product_definition_group_assignment
-    struct product_definition_group_assignment : group_assignment, ObjectHelper<product_definition_group_assignment,1> { product_definition_group_assignment() : Object("product_definition_group_assignment") {}
-		ListOf< product_definition_or_product_definition_relationship, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for product_definition_shape
-    struct product_definition_shape : property_definition, ObjectHelper<product_definition_shape,0> { product_definition_shape() : Object("product_definition_shape") {}
-
-    };
-
-    // C++ wrapper for product_definition_with_associated_documents
-    struct product_definition_with_associated_documents : product_definition, ObjectHelper<product_definition_with_associated_documents,1> { product_definition_with_associated_documents() : Object("product_definition_with_associated_documents") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > documentation_ids;
-    };
-
-    // C++ wrapper for product_identification
-    struct product_identification :  ObjectHelper<product_identification,0> { product_identification() : Object("product_identification") {}
-
-    };
-
-    // C++ wrapper for product_material_composition_relationship
-    struct product_material_composition_relationship : product_definition_relationship, ObjectHelper<product_material_composition_relationship,4> { product_material_composition_relationship() : Object("product_material_composition_relationship") {}
-		label::Out class_;
-		ListOf< characterized_product_composition_value, 1, 0 >::Out constituent_amount;
-		label::Out composition_basis;
-		text::Out determination_method;
-    };
-
-    // C++ wrapper for product_related_product_category
-    struct product_related_product_category : product_category, ObjectHelper<product_related_product_category,1> { product_related_product_category() : Object("product_related_product_category") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > products;
-    };
-
-    // C++ wrapper for product_specification
-    struct product_specification :  ObjectHelper<product_specification,0> { product_specification() : Object("product_specification") {}
-
-    };
-
-    // C++ wrapper for tolerance_zone_definition
-    struct tolerance_zone_definition :  ObjectHelper<tolerance_zone_definition,2> { tolerance_zone_definition() : Object("tolerance_zone_definition") {}
-		Lazy< tolerance_zone > zone;
-		ListOf< Lazy< shape_aspect >, 1, 0 > boundaries;
-    };
-
-    // C++ wrapper for projected_zone_definition
-    struct projected_zone_definition : tolerance_zone_definition, ObjectHelper<projected_zone_definition,2> { projected_zone_definition() : Object("projected_zone_definition") {}
-		Lazy< shape_aspect > projection_end;
-		Lazy< measure_with_unit > projected_length;
-    };
-
-    // C++ wrapper for projection_curve
-    struct projection_curve : annotation_curve_occurrence, ObjectHelper<projection_curve,0> { projection_curve() : Object("projection_curve") {}
-
-    };
-
-    // C++ wrapper for promissory_usage_occurrence
-    struct promissory_usage_occurrence : assembly_component_usage, ObjectHelper<promissory_usage_occurrence,0> { promissory_usage_occurrence() : Object("promissory_usage_occurrence") {}
-
-    };
-
-    // C++ wrapper for qualified_representation_item
-    struct qualified_representation_item : representation_item, ObjectHelper<qualified_representation_item,1> { qualified_representation_item() : Object("qualified_representation_item") {}
-		ListOf< value_qualifier, 1, 0 >::Out qualifiers;
-    };
-
-    // C++ wrapper for qualitative_uncertainty
-    struct qualitative_uncertainty : uncertainty_qualifier, ObjectHelper<qualitative_uncertainty,1> { qualitative_uncertainty() : Object("qualitative_uncertainty") {}
-		text::Out uncertainty_value;
-    };
-
-    // C++ wrapper for quantified_assembly_component_usage
-    struct quantified_assembly_component_usage : assembly_component_usage, ObjectHelper<quantified_assembly_component_usage,1> { quantified_assembly_component_usage() : Object("quantified_assembly_component_usage") {}
-		Lazy< measure_with_unit > quantity;
-    };
-
-    // C++ wrapper for quasi_uniform_curve
-    struct quasi_uniform_curve : b_spline_curve, ObjectHelper<quasi_uniform_curve,0> { quasi_uniform_curve() : Object("quasi_uniform_curve") {}
-
-    };
-
-    // C++ wrapper for quasi_uniform_surface
-    struct quasi_uniform_surface : b_spline_surface, ObjectHelper<quasi_uniform_surface,0> { quasi_uniform_surface() : Object("quasi_uniform_surface") {}
-
-    };
-
-    // C++ wrapper for radioactivity_measure_with_unit
-    struct radioactivity_measure_with_unit : measure_with_unit, ObjectHelper<radioactivity_measure_with_unit,0> { radioactivity_measure_with_unit() : Object("radioactivity_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for radioactivity_unit
-    struct radioactivity_unit : derived_unit, ObjectHelper<radioactivity_unit,0> { radioactivity_unit() : Object("radioactivity_unit") {}
-
-    };
-
-    // C++ wrapper for radius_dimension
-    struct radius_dimension : dimension_curve_directed_callout, ObjectHelper<radius_dimension,0> { radius_dimension() : Object("radius_dimension") {}
-
-    };
-
-    // C++ wrapper for range_characteristic
-    struct range_characteristic :  ObjectHelper<range_characteristic,0> { range_characteristic() : Object("range_characteristic") {}
-
-    };
-
-    // C++ wrapper for ratio_unit
-    struct ratio_unit : named_unit, ObjectHelper<ratio_unit,0> { ratio_unit() : Object("ratio_unit") {}
-
-    };
-
-    // C++ wrapper for rational_b_spline_curve
-    struct rational_b_spline_curve : b_spline_curve, ObjectHelper<rational_b_spline_curve,1> { rational_b_spline_curve() : Object("rational_b_spline_curve") {}
-		ListOf< REAL, 2, 0 >::Out weights_data;
-    };
-
-    // C++ wrapper for rational_b_spline_surface
-    struct rational_b_spline_surface : b_spline_surface, ObjectHelper<rational_b_spline_surface,0> { rational_b_spline_surface() : Object("rational_b_spline_surface") {}
-
-    };
-
-    // C++ wrapper for rational_representation_item
-    struct rational_representation_item :  ObjectHelper<rational_representation_item,0> { rational_representation_item() : Object("rational_representation_item") {}
-
-    };
-
-    // C++ wrapper for real_literal
-    struct real_literal : literal_number, ObjectHelper<real_literal,0> { real_literal() : Object("real_literal") {}
-
-    };
-
-    // C++ wrapper for real_representation_item
-    struct real_representation_item :  ObjectHelper<real_representation_item,0> { real_representation_item() : Object("real_representation_item") {}
-
-    };
-
-    // C++ wrapper for rectangular_composite_surface
-    struct rectangular_composite_surface : bounded_surface, ObjectHelper<rectangular_composite_surface,0> { rectangular_composite_surface() : Object("rectangular_composite_surface") {}
-
-    };
-
-    // C++ wrapper for rectangular_trimmed_surface
-    struct rectangular_trimmed_surface : bounded_surface, ObjectHelper<rectangular_trimmed_surface,7> { rectangular_trimmed_surface() : Object("rectangular_trimmed_surface") {}
-		Lazy< surface > basis_surface;
-		parameter_value::Out u1;
-		parameter_value::Out u2;
-		parameter_value::Out v1;
-		parameter_value::Out v2;
-		BOOLEAN::Out usense;
-		BOOLEAN::Out vsense;
-    };
-
-    // C++ wrapper for referenced_modified_datum
-    struct referenced_modified_datum : datum_reference, ObjectHelper<referenced_modified_datum,1> { referenced_modified_datum() : Object("referenced_modified_datum") {}
-		limit_condition::Out modifier;
-    };
-
-    // C++ wrapper for relative_event_occurrence
-    struct relative_event_occurrence : event_occurrence, ObjectHelper<relative_event_occurrence,2> { relative_event_occurrence() : Object("relative_event_occurrence") {}
-		Lazy< event_occurrence > base_event;
-		Lazy< time_measure_with_unit > offset;
-    };
-
-    // C++ wrapper for rep_item_group
-    struct rep_item_group :  ObjectHelper<rep_item_group,0> { rep_item_group() : Object("rep_item_group") {}
-
-    };
-
-    // C++ wrapper for reparametrised_composite_curve_segment
-    struct reparametrised_composite_curve_segment : composite_curve_segment, ObjectHelper<reparametrised_composite_curve_segment,1> { reparametrised_composite_curve_segment() : Object("reparametrised_composite_curve_segment") {}
-		parameter_value::Out param_length;
-    };
-
-    // C++ wrapper for representation_relationship_with_transformation
-    struct representation_relationship_with_transformation : representation_relationship, ObjectHelper<representation_relationship_with_transformation,1> { representation_relationship_with_transformation() : Object("representation_relationship_with_transformation") {}
-		transformation::Out transformation_operator;
-    };
-
-    // C++ wrapper for requirement_assigned_object
-    struct requirement_assigned_object : group_assignment, ObjectHelper<requirement_assigned_object,1> { requirement_assigned_object() : Object("requirement_assigned_object") {}
-		ListOf< requirement_assigned_item, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for requirement_assignment
-    struct requirement_assignment :  ObjectHelper<requirement_assignment,0> { requirement_assignment() : Object("requirement_assignment") {}
-
-    };
-
-    // C++ wrapper for requirement_source
-    struct requirement_source : group, ObjectHelper<requirement_source,0> { requirement_source() : Object("requirement_source") {}
-
-    };
-
-    // C++ wrapper for requirement_view_definition_relationship
-    struct requirement_view_definition_relationship : product_definition_relationship, ObjectHelper<requirement_view_definition_relationship,0> { requirement_view_definition_relationship() : Object("requirement_view_definition_relationship") {}
-
-    };
-
-    // C++ wrapper for resistance_measure_with_unit
-    struct resistance_measure_with_unit : measure_with_unit, ObjectHelper<resistance_measure_with_unit,0> { resistance_measure_with_unit() : Object("resistance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for resistance_unit
-    struct resistance_unit : derived_unit, ObjectHelper<resistance_unit,0> { resistance_unit() : Object("resistance_unit") {}
-
-    };
-
-    // C++ wrapper for revolved_area_solid
-    struct revolved_area_solid : swept_area_solid, ObjectHelper<revolved_area_solid,2> { revolved_area_solid() : Object("revolved_area_solid") {}
-		Lazy< axis1_placement > axis;
-		plane_angle_measure::Out angle;
-    };
-
-    // C++ wrapper for revolved_face_solid
-    struct revolved_face_solid : swept_face_solid, ObjectHelper<revolved_face_solid,2> { revolved_face_solid() : Object("revolved_face_solid") {}
-		Lazy< axis1_placement > axis;
-		plane_angle_measure::Out angle;
-    };
-
-    // C++ wrapper for revolved_face_solid_with_trim_conditions
-    struct revolved_face_solid_with_trim_conditions : revolved_face_solid, ObjectHelper<revolved_face_solid_with_trim_conditions,2> { revolved_face_solid_with_trim_conditions() : Object("revolved_face_solid_with_trim_conditions") {}
-		trim_condition_select::Out first_trim_condition;
-		trim_condition_select::Out second_trim_condition;
-    };
-
-    // C++ wrapper for right_angular_wedge
-    struct right_angular_wedge : geometric_representation_item, ObjectHelper<right_angular_wedge,5> { right_angular_wedge() : Object("right_angular_wedge") {}
-		Lazy< axis2_placement_3d > position;
-		positive_length_measure::Out x;
-		positive_length_measure::Out y;
-		positive_length_measure::Out z;
-		length_measure::Out ltx;
-    };
-
-    // C++ wrapper for right_circular_cone
-    struct right_circular_cone : geometric_representation_item, ObjectHelper<right_circular_cone,4> { right_circular_cone() : Object("right_circular_cone") {}
-		Lazy< axis1_placement > position;
-		positive_length_measure::Out height;
-		length_measure::Out radius;
-		plane_angle_measure::Out semi_angle;
-    };
-
-    // C++ wrapper for right_circular_cylinder
-    struct right_circular_cylinder : geometric_representation_item, ObjectHelper<right_circular_cylinder,3> { right_circular_cylinder() : Object("right_circular_cylinder") {}
-		Lazy< axis1_placement > position;
-		positive_length_measure::Out height;
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for right_to_usage_association
-    struct right_to_usage_association : action_method_relationship, ObjectHelper<right_to_usage_association,0> { right_to_usage_association() : Object("right_to_usage_association") {}
-
-    };
-
-    // C++ wrapper for roundness_tolerance
-    struct roundness_tolerance : geometric_tolerance, ObjectHelper<roundness_tolerance,0> { roundness_tolerance() : Object("roundness_tolerance") {}
-
-    };
-
-    // C++ wrapper for row_representation_item
-    struct row_representation_item : compound_representation_item, ObjectHelper<row_representation_item,0> { row_representation_item() : Object("row_representation_item") {}
-
-    };
-
-    // C++ wrapper for row_value
-    struct row_value : compound_representation_item, ObjectHelper<row_value,0> { row_value() : Object("row_value") {}
-
-    };
-
-    // C++ wrapper for row_variable
-    struct row_variable : abstract_variable, ObjectHelper<row_variable,0> { row_variable() : Object("row_variable") {}
-
-    };
-
-    // C++ wrapper for rule_action
-    struct rule_action : action, ObjectHelper<rule_action,0> { rule_action() : Object("rule_action") {}
-
-    };
-
-    // C++ wrapper for rule_condition
-    struct rule_condition : atomic_formula, ObjectHelper<rule_condition,0> { rule_condition() : Object("rule_condition") {}
-
-    };
-
-    // C++ wrapper for rule_set
-    struct rule_set : rule_software_definition, ObjectHelper<rule_set,0> { rule_set() : Object("rule_set") {}
-
-    };
-
-    // C++ wrapper for rule_set_group
-    struct rule_set_group : rule_software_definition, ObjectHelper<rule_set_group,0> { rule_set_group() : Object("rule_set_group") {}
-
-    };
-
-    // C++ wrapper for rule_superseded_assignment
-    struct rule_superseded_assignment : action_assignment, ObjectHelper<rule_superseded_assignment,1> { rule_superseded_assignment() : Object("rule_superseded_assignment") {}
-		ListOf< rule_superseded_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for rule_supersedence
-    struct rule_supersedence : rule_action, ObjectHelper<rule_supersedence,0> { rule_supersedence() : Object("rule_supersedence") {}
-
-    };
-
-    // C++ wrapper for surface_curve_swept_area_solid
-    struct surface_curve_swept_area_solid : swept_area_solid, ObjectHelper<surface_curve_swept_area_solid,4> { surface_curve_swept_area_solid() : Object("surface_curve_swept_area_solid") {}
-		Lazy< curve > directrix;
-		REAL::Out start_param;
-		REAL::Out end_param;
-		Lazy< surface > reference_surface;
-    };
-
-    // C++ wrapper for ruled_surface_swept_area_solid
-    struct ruled_surface_swept_area_solid : surface_curve_swept_area_solid, ObjectHelper<ruled_surface_swept_area_solid,0> { ruled_surface_swept_area_solid() : Object("ruled_surface_swept_area_solid") {}
-
-    };
-
-    // C++ wrapper for runout_zone_definition
-    struct runout_zone_definition : tolerance_zone_definition, ObjectHelper<runout_zone_definition,1> { runout_zone_definition() : Object("runout_zone_definition") {}
-		Lazy< runout_zone_orientation > orientation;
-    };
-
-    // C++ wrapper for runout_zone_orientation
-    struct runout_zone_orientation :  ObjectHelper<runout_zone_orientation,1> { runout_zone_orientation() : Object("runout_zone_orientation") {}
-		Lazy< measure_with_unit > angle;
-    };
-
-    // C++ wrapper for runout_zone_orientation_reference_direction
-    struct runout_zone_orientation_reference_direction : runout_zone_orientation, ObjectHelper<runout_zone_orientation_reference_direction,1> { runout_zone_orientation_reference_direction() : Object("runout_zone_orientation_reference_direction") {}
-		Lazy< shape_aspect_relationship > orientation_defining_relationship;
-    };
-
-    // C++ wrapper for satisfied_requirement
-    struct satisfied_requirement : group_assignment, ObjectHelper<satisfied_requirement,1> { satisfied_requirement() : Object("satisfied_requirement") {}
-		ListOf< Lazy< product_definition >, 1, 1 > items;
-    };
-
-    // C++ wrapper for satisfies_requirement
-    struct satisfies_requirement : group, ObjectHelper<satisfies_requirement,0> { satisfies_requirement() : Object("satisfies_requirement") {}
-
-    };
-
-    // C++ wrapper for satisfying_item
-    struct satisfying_item : group_assignment, ObjectHelper<satisfying_item,1> { satisfying_item() : Object("satisfying_item") {}
-		ListOf< requirement_satisfaction_item, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for scalar_variable
-    struct scalar_variable : abstract_variable, ObjectHelper<scalar_variable,0> { scalar_variable() : Object("scalar_variable") {}
-
-    };
-
-    // C++ wrapper for scattering_parameter
-    struct scattering_parameter : polar_complex_number_literal, ObjectHelper<scattering_parameter,0> { scattering_parameter() : Object("scattering_parameter") {}
-
-    };
-
-    // C++ wrapper for sculptured_solid
-    struct sculptured_solid : modified_solid, ObjectHelper<sculptured_solid,2> { sculptured_solid() : Object("sculptured_solid") {}
-		generalized_surface_select::Out sculpturing_element;
-		BOOLEAN::Out positive_side;
-    };
-
-    // C++ wrapper for seam_curve
-    struct seam_curve : surface_curve, ObjectHelper<seam_curve,0> { seam_curve() : Object("seam_curve") {}
-
-    };
-
-    // C++ wrapper for serial_numbered_effectivity
-    struct serial_numbered_effectivity : effectivity, ObjectHelper<serial_numbered_effectivity,2> { serial_numbered_effectivity() : Object("serial_numbered_effectivity") {}
-		identifier::Out effectivity_start_id;
-		Maybe< identifier::Out > effectivity_end_id;
-    };
-
-    // C++ wrapper for shape_aspect_associativity
-    struct shape_aspect_associativity : shape_aspect_relationship, ObjectHelper<shape_aspect_associativity,0> { shape_aspect_associativity() : Object("shape_aspect_associativity") {}
-
-    };
-
-    // C++ wrapper for shape_aspect_deriving_relationship
-    struct shape_aspect_deriving_relationship : shape_aspect_relationship, ObjectHelper<shape_aspect_deriving_relationship,0> { shape_aspect_deriving_relationship() : Object("shape_aspect_deriving_relationship") {}
-
-    };
-
-    // C++ wrapper for shape_definition_representation
-    struct shape_definition_representation : property_definition_representation, ObjectHelper<shape_definition_representation,0> { shape_definition_representation() : Object("shape_definition_representation") {}
-
-    };
-
-    // C++ wrapper for shape_dimension_representation
-    struct shape_dimension_representation : shape_representation, ObjectHelper<shape_dimension_representation,0> { shape_dimension_representation() : Object("shape_dimension_representation") {}
-
-    };
-
-    // C++ wrapper for shape_feature_definition
-    struct shape_feature_definition : characterized_object, ObjectHelper<shape_feature_definition,0> { shape_feature_definition() : Object("shape_feature_definition") {}
-
-    };
-
-    // C++ wrapper for shape_representation_with_parameters
-    struct shape_representation_with_parameters : shape_representation, ObjectHelper<shape_representation_with_parameters,0> { shape_representation_with_parameters() : Object("shape_representation_with_parameters") {}
-
-    };
-
-    // C++ wrapper for shell_based_surface_model
-    struct shell_based_surface_model : geometric_representation_item, ObjectHelper<shell_based_surface_model,1> { shell_based_surface_model() : Object("shell_based_surface_model") {}
-		ListOf< shell, 1, 0 >::Out sbsm_boundary;
-    };
-
-    // C++ wrapper for shell_based_wireframe_model
-    struct shell_based_wireframe_model : geometric_representation_item, ObjectHelper<shell_based_wireframe_model,1> { shell_based_wireframe_model() : Object("shell_based_wireframe_model") {}
-		ListOf< shell, 1, 0 >::Out sbwm_boundary;
-    };
-
-    // C++ wrapper for shell_based_wireframe_shape_representation
-    struct shell_based_wireframe_shape_representation : shape_representation, ObjectHelper<shell_based_wireframe_shape_representation,0> { shell_based_wireframe_shape_representation() : Object("shell_based_wireframe_shape_representation") {}
-
-    };
-
-    // C++ wrapper for si_absorbed_dose_unit
-    struct si_absorbed_dose_unit :  ObjectHelper<si_absorbed_dose_unit,0> { si_absorbed_dose_unit() : Object("si_absorbed_dose_unit") {}
-
-    };
-
-    // C++ wrapper for si_capacitance_unit
-    struct si_capacitance_unit :  ObjectHelper<si_capacitance_unit,0> { si_capacitance_unit() : Object("si_capacitance_unit") {}
-
-    };
-
-    // C++ wrapper for si_conductance_unit
-    struct si_conductance_unit :  ObjectHelper<si_conductance_unit,0> { si_conductance_unit() : Object("si_conductance_unit") {}
-
-    };
-
-    // C++ wrapper for si_dose_equivalent_unit
-    struct si_dose_equivalent_unit :  ObjectHelper<si_dose_equivalent_unit,0> { si_dose_equivalent_unit() : Object("si_dose_equivalent_unit") {}
-
-    };
-
-    // C++ wrapper for si_electric_charge_unit
-    struct si_electric_charge_unit :  ObjectHelper<si_electric_charge_unit,0> { si_electric_charge_unit() : Object("si_electric_charge_unit") {}
-
-    };
-
-    // C++ wrapper for si_electric_potential_unit
-    struct si_electric_potential_unit :  ObjectHelper<si_electric_potential_unit,0> { si_electric_potential_unit() : Object("si_electric_potential_unit") {}
-
-    };
-
-    // C++ wrapper for si_energy_unit
-    struct si_energy_unit :  ObjectHelper<si_energy_unit,0> { si_energy_unit() : Object("si_energy_unit") {}
-
-    };
-
-    // C++ wrapper for si_force_unit
-    struct si_force_unit :  ObjectHelper<si_force_unit,0> { si_force_unit() : Object("si_force_unit") {}
-
-    };
-
-    // C++ wrapper for si_frequency_unit
-    struct si_frequency_unit :  ObjectHelper<si_frequency_unit,0> { si_frequency_unit() : Object("si_frequency_unit") {}
-
-    };
-
-    // C++ wrapper for si_illuminance_unit
-    struct si_illuminance_unit :  ObjectHelper<si_illuminance_unit,0> { si_illuminance_unit() : Object("si_illuminance_unit") {}
-
-    };
-
-    // C++ wrapper for si_inductance_unit
-    struct si_inductance_unit :  ObjectHelper<si_inductance_unit,0> { si_inductance_unit() : Object("si_inductance_unit") {}
-
-    };
-
-    // C++ wrapper for si_magnetic_flux_density_unit
-    struct si_magnetic_flux_density_unit :  ObjectHelper<si_magnetic_flux_density_unit,0> { si_magnetic_flux_density_unit() : Object("si_magnetic_flux_density_unit") {}
-
-    };
-
-    // C++ wrapper for si_magnetic_flux_unit
-    struct si_magnetic_flux_unit :  ObjectHelper<si_magnetic_flux_unit,0> { si_magnetic_flux_unit() : Object("si_magnetic_flux_unit") {}
-
-    };
-
-    // C++ wrapper for si_power_unit
-    struct si_power_unit :  ObjectHelper<si_power_unit,0> { si_power_unit() : Object("si_power_unit") {}
-
-    };
-
-    // C++ wrapper for si_pressure_unit
-    struct si_pressure_unit :  ObjectHelper<si_pressure_unit,0> { si_pressure_unit() : Object("si_pressure_unit") {}
-
-    };
-
-    // C++ wrapper for si_radioactivity_unit
-    struct si_radioactivity_unit :  ObjectHelper<si_radioactivity_unit,0> { si_radioactivity_unit() : Object("si_radioactivity_unit") {}
-
-    };
-
-    // C++ wrapper for si_resistance_unit
-    struct si_resistance_unit :  ObjectHelper<si_resistance_unit,0> { si_resistance_unit() : Object("si_resistance_unit") {}
-
-    };
-
-    // C++ wrapper for si_unit
-    struct si_unit : named_unit, ObjectHelper<si_unit,2> { si_unit() : Object("si_unit") {}
-		Maybe< si_prefix::Out > prefix;
-		si_unit_name::Out name;
-    };
-
-    // C++ wrapper for simple_boolean_expression
-    struct simple_boolean_expression :  ObjectHelper<simple_boolean_expression,0> { simple_boolean_expression() : Object("simple_boolean_expression") {}
-
-    };
-
-    // C++ wrapper for simple_numeric_expression
-    struct simple_numeric_expression :  ObjectHelper<simple_numeric_expression,0> { simple_numeric_expression() : Object("simple_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for slash_expression
-    struct slash_expression : binary_numeric_expression, ObjectHelper<slash_expression,0> { slash_expression() : Object("slash_expression") {}
-
-    };
-
-    // C++ wrapper for smeared_material_definition
-    struct smeared_material_definition : zone_structural_makeup, ObjectHelper<smeared_material_definition,0> { smeared_material_definition() : Object("smeared_material_definition") {}
-
-    };
-
-    // C++ wrapper for solid_angle_measure_with_unit
-    struct solid_angle_measure_with_unit : measure_with_unit, ObjectHelper<solid_angle_measure_with_unit,0> { solid_angle_measure_with_unit() : Object("solid_angle_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for solid_angle_unit
-    struct solid_angle_unit : named_unit, ObjectHelper<solid_angle_unit,0> { solid_angle_unit() : Object("solid_angle_unit") {}
-
-    };
-
-    // C++ wrapper for solid_curve_font
-    struct solid_curve_font : pre_defined_curve_font, ObjectHelper<solid_curve_font,0> { solid_curve_font() : Object("solid_curve_font") {}
-
-    };
-
-    // C++ wrapper for solid_replica
-    struct solid_replica : solid_model, ObjectHelper<solid_replica,2> { solid_replica() : Object("solid_replica") {}
-		Lazy< solid_model > parent_solid;
-		Lazy< cartesian_transformation_operator_3d > transformation;
-    };
-
-    // C++ wrapper for solid_with_chamfered_edges
-    struct solid_with_chamfered_edges : edge_blended_solid, ObjectHelper<solid_with_chamfered_edges,0> { solid_with_chamfered_edges() : Object("solid_with_chamfered_edges") {}
-
-    };
-
-    // C++ wrapper for solid_with_angle_based_chamfer
-    struct solid_with_angle_based_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_angle_based_chamfer,3> { solid_with_angle_based_chamfer() : Object("solid_with_angle_based_chamfer") {}
-		positive_length_measure::Out offset_distance;
-		BOOLEAN::Out left_offset;
-		positive_plane_angle_measure::Out offset_angle;
-    };
-
-    // C++ wrapper for solid_with_shape_element_pattern
-    struct solid_with_shape_element_pattern : modified_solid_with_placed_configuration, ObjectHelper<solid_with_shape_element_pattern,1> { solid_with_shape_element_pattern() : Object("solid_with_shape_element_pattern") {}
-		Lazy< modified_solid_with_placed_configuration > replicated_element;
-    };
-
-    // C++ wrapper for solid_with_circular_pattern
-    struct solid_with_circular_pattern : solid_with_shape_element_pattern, ObjectHelper<solid_with_circular_pattern,4> { solid_with_circular_pattern() : Object("solid_with_circular_pattern") {}
-		positive_integer::Out replicate_count;
-		plane_angle_measure::Out angular_spacing;
-		BOOLEAN::Out radial_alignment;
-		Lazy< point > reference_point;
-    };
-
-    // C++ wrapper for solid_with_depression
-    struct solid_with_depression : modified_solid_with_placed_configuration, ObjectHelper<solid_with_depression,1> { solid_with_depression() : Object("solid_with_depression") {}
-		positive_length_measure::Out depth;
-    };
-
-    // C++ wrapper for solid_with_pocket
-    struct solid_with_pocket : solid_with_depression, ObjectHelper<solid_with_pocket,2> { solid_with_pocket() : Object("solid_with_pocket") {}
-		non_negative_length_measure::Out floor_blend_radius;
-		plane_angle_measure::Out draft_angle;
-    };
-
-    // C++ wrapper for solid_with_circular_pocket
-    struct solid_with_circular_pocket : solid_with_pocket, ObjectHelper<solid_with_circular_pocket,1> { solid_with_circular_pocket() : Object("solid_with_circular_pocket") {}
-		positive_length_measure::Out pocket_radius;
-    };
-
-    // C++ wrapper for solid_with_protrusion
-    struct solid_with_protrusion : modified_solid_with_placed_configuration, ObjectHelper<solid_with_protrusion,2> { solid_with_protrusion() : Object("solid_with_protrusion") {}
-		positive_length_measure::Out protrusion_height;
-		plane_angle_measure::Out protrusion_draft_angle;
-    };
-
-    // C++ wrapper for solid_with_circular_protrusion
-    struct solid_with_circular_protrusion : solid_with_protrusion, ObjectHelper<solid_with_circular_protrusion,1> { solid_with_circular_protrusion() : Object("solid_with_circular_protrusion") {}
-		positive_length_measure::Out protrusion_radius;
-    };
-
-    // C++ wrapper for solid_with_hole
-    struct solid_with_hole : solid_with_depression, ObjectHelper<solid_with_hole,0> { solid_with_hole() : Object("solid_with_hole") {}
-
-    };
-
-    // C++ wrapper for solid_with_stepped_round_hole
-    struct solid_with_stepped_round_hole : solid_with_hole, ObjectHelper<solid_with_stepped_round_hole,1> { solid_with_stepped_round_hole() : Object("solid_with_stepped_round_hole") {}
-		positive_integer::Out segments;
-    };
-
-    // C++ wrapper for solid_with_conical_bottom_round_hole
-    struct solid_with_conical_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_conical_bottom_round_hole,2> { solid_with_conical_bottom_round_hole() : Object("solid_with_conical_bottom_round_hole") {}
-		positive_plane_angle_measure::Out semi_apex_angle;
-		non_negative_length_measure::Out tip_radius;
-    };
-
-    // C++ wrapper for solid_with_constant_radius_edge_blend
-    struct solid_with_constant_radius_edge_blend : edge_blended_solid, ObjectHelper<solid_with_constant_radius_edge_blend,1> { solid_with_constant_radius_edge_blend() : Object("solid_with_constant_radius_edge_blend") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for solid_with_slot
-    struct solid_with_slot : solid_with_depression, ObjectHelper<solid_with_slot,2> { solid_with_slot() : Object("solid_with_slot") {}
-		positive_length_measure::Out slot_width;
-		ListOf< LOGICAL, 2, 2 >::Out closed_ends;
-    };
-
-    // C++ wrapper for solid_with_curved_slot
-    struct solid_with_curved_slot : solid_with_slot, ObjectHelper<solid_with_curved_slot,1> { solid_with_curved_slot() : Object("solid_with_curved_slot") {}
-		Lazy< bounded_curve > slot_centreline;
-    };
-
-    // C++ wrapper for solid_with_double_offset_chamfer
-    struct solid_with_double_offset_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_double_offset_chamfer,2> { solid_with_double_offset_chamfer() : Object("solid_with_double_offset_chamfer") {}
-		positive_length_measure::Out left_offset_distance;
-		positive_length_measure::Out right_offset_distance;
-    };
-
-    // C++ wrapper for solid_with_flat_bottom_round_hole
-    struct solid_with_flat_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_flat_bottom_round_hole,1> { solid_with_flat_bottom_round_hole() : Object("solid_with_flat_bottom_round_hole") {}
-		non_negative_length_measure::Out fillet_radius;
-    };
-
-    // C++ wrapper for solid_with_general_pocket
-    struct solid_with_general_pocket : solid_with_pocket, ObjectHelper<solid_with_general_pocket,2> { solid_with_general_pocket() : Object("solid_with_general_pocket") {}
-		Lazy< positioned_sketch > profile;
-		Lazy< point > reference_point;
-    };
-
-    // C++ wrapper for solid_with_general_protrusion
-    struct solid_with_general_protrusion : solid_with_protrusion, ObjectHelper<solid_with_general_protrusion,2> { solid_with_general_protrusion() : Object("solid_with_general_protrusion") {}
-		Lazy< positioned_sketch > profile;
-		Lazy< point > reference_point;
-    };
-
-    // C++ wrapper for solid_with_groove
-    struct solid_with_groove : solid_with_depression, ObjectHelper<solid_with_groove,5> { solid_with_groove() : Object("solid_with_groove") {}
-		positive_length_measure::Out groove_radius;
-		positive_length_measure::Out groove_width;
-		plane_angle_measure::Out draft_angle;
-		non_negative_length_measure::Out floor_fillet_radius;
-		BOOLEAN::Out external_groove;
-    };
-
-    // C++ wrapper for solid_with_incomplete_circular_pattern
-    struct solid_with_incomplete_circular_pattern : solid_with_circular_pattern, ObjectHelper<solid_with_incomplete_circular_pattern,1> { solid_with_incomplete_circular_pattern() : Object("solid_with_incomplete_circular_pattern") {}
-		ListOf< positive_integer, 1, 0 >::Out omitted_instances;
-    };
-
-    // C++ wrapper for solid_with_rectangular_pattern
-    struct solid_with_rectangular_pattern : solid_with_shape_element_pattern, ObjectHelper<solid_with_rectangular_pattern,4> { solid_with_rectangular_pattern() : Object("solid_with_rectangular_pattern") {}
-		positive_integer::Out row_count;
-		positive_integer::Out column_count;
-		length_measure::Out row_spacing;
-		length_measure::Out column_spacing;
-    };
-
-    // C++ wrapper for solid_with_incomplete_rectangular_pattern
-    struct solid_with_incomplete_rectangular_pattern : solid_with_rectangular_pattern, ObjectHelper<solid_with_incomplete_rectangular_pattern,0> { solid_with_incomplete_rectangular_pattern() : Object("solid_with_incomplete_rectangular_pattern") {}
-
-    };
-
-    // C++ wrapper for solid_with_rectangular_pocket
-    struct solid_with_rectangular_pocket : solid_with_pocket, ObjectHelper<solid_with_rectangular_pocket,3> { solid_with_rectangular_pocket() : Object("solid_with_rectangular_pocket") {}
-		positive_length_measure::Out pocket_length;
-		positive_length_measure::Out pocket_width;
-		non_negative_length_measure::Out corner_radius;
-    };
-
-    // C++ wrapper for solid_with_rectangular_protrusion
-    struct solid_with_rectangular_protrusion : solid_with_protrusion, ObjectHelper<solid_with_rectangular_protrusion,3> { solid_with_rectangular_protrusion() : Object("solid_with_rectangular_protrusion") {}
-		positive_length_measure::Out protrusion_length;
-		positive_length_measure::Out protrusion_width;
-		non_negative_length_measure::Out protrusion_corner_radius;
-    };
-
-    // C++ wrapper for solid_with_single_offset_chamfer
-    struct solid_with_single_offset_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_single_offset_chamfer,1> { solid_with_single_offset_chamfer() : Object("solid_with_single_offset_chamfer") {}
-		positive_length_measure::Out offset_distance;
-    };
-
-    // C++ wrapper for solid_with_spherical_bottom_round_hole
-    struct solid_with_spherical_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_spherical_bottom_round_hole,1> { solid_with_spherical_bottom_round_hole() : Object("solid_with_spherical_bottom_round_hole") {}
-		positive_length_measure::Out sphere_radius;
-    };
-
-    // C++ wrapper for solid_with_stepped_round_hole_and_conical_transitions
-    struct solid_with_stepped_round_hole_and_conical_transitions : solid_with_stepped_round_hole, ObjectHelper<solid_with_stepped_round_hole_and_conical_transitions,1> { solid_with_stepped_round_hole_and_conical_transitions() : Object("solid_with_stepped_round_hole_and_conical_transitions") {}
-		ListOf< Lazy< conical_stepped_hole_transition >, 1, 0 > conical_transitions;
-    };
-
-    // C++ wrapper for solid_with_straight_slot
-    struct solid_with_straight_slot : solid_with_slot, ObjectHelper<solid_with_straight_slot,1> { solid_with_straight_slot() : Object("solid_with_straight_slot") {}
-		positive_length_measure::Out slot_length;
-    };
-
-    // C++ wrapper for solid_with_tee_section_slot
-    struct solid_with_tee_section_slot : solid_with_slot, ObjectHelper<solid_with_tee_section_slot,2> { solid_with_tee_section_slot() : Object("solid_with_tee_section_slot") {}
-		positive_length_measure::Out tee_section_width;
-		positive_length_measure::Out collar_depth;
-    };
-
-    // C++ wrapper for solid_with_through_depression
-    struct solid_with_through_depression : solid_with_depression, ObjectHelper<solid_with_through_depression,1> { solid_with_through_depression() : Object("solid_with_through_depression") {}
-		ListOf< Lazy< face_surface >, 1, 0 > exit_faces;
-    };
-
-    // C++ wrapper for solid_with_trapezoidal_section_slot
-    struct solid_with_trapezoidal_section_slot : solid_with_slot, ObjectHelper<solid_with_trapezoidal_section_slot,2> { solid_with_trapezoidal_section_slot() : Object("solid_with_trapezoidal_section_slot") {}
-		plane_angle_measure::Out draft_angle;
-		non_negative_length_measure::Out floor_fillet_radius;
-    };
-
-    // C++ wrapper for solid_with_variable_radius_edge_blend
-    struct solid_with_variable_radius_edge_blend :  ObjectHelper<solid_with_variable_radius_edge_blend,3> { solid_with_variable_radius_edge_blend() : Object("solid_with_variable_radius_edge_blend") {}
-		ListOf< Lazy< point >, 2, 0 > point_list;
-		ListOf< positive_length_measure, 2, 0 >::Out radius_list;
-		ListOf< blend_radius_variation_type, 1, 0 >::Out edge_function_list;
-    };
-
-    // C++ wrapper for source_for_requirement
-    struct source_for_requirement : group_assignment, ObjectHelper<source_for_requirement,1> { source_for_requirement() : Object("source_for_requirement") {}
-		ListOf< requirement_source_item, 1, 1 >::Out items;
-    };
-
-    // C++ wrapper for sourced_requirement
-    struct sourced_requirement : group_assignment, ObjectHelper<sourced_requirement,1> { sourced_requirement() : Object("sourced_requirement") {}
-		ListOf< Lazy< product_definition >, 1, 1 > items;
-    };
-
-    // C++ wrapper for specification_definition
-    struct specification_definition : product_definition, ObjectHelper<specification_definition,0> { specification_definition() : Object("specification_definition") {}
-
-    };
-
-    // C++ wrapper for specified_higher_usage_occurrence
-    struct specified_higher_usage_occurrence : assembly_component_usage, ObjectHelper<specified_higher_usage_occurrence,2> { specified_higher_usage_occurrence() : Object("specified_higher_usage_occurrence") {}
-		Lazy< assembly_component_usage > upper_usage;
-		Lazy< next_assembly_usage_occurrence > next_usage;
-    };
-
-    // C++ wrapper for sphere
-    struct sphere : geometric_representation_item, ObjectHelper<sphere,2> { sphere() : Object("sphere") {}
-		positive_length_measure::Out radius;
-		Lazy< point > centre;
-    };
-
-    // C++ wrapper for spherical_surface
-    struct spherical_surface : elementary_surface, ObjectHelper<spherical_surface,1> { spherical_surface() : Object("spherical_surface") {}
-		positive_length_measure::Out radius;
-    };
-
-    // C++ wrapper for start_request
-    struct start_request : action_request_assignment, ObjectHelper<start_request,1> { start_request() : Object("start_request") {}
-		ListOf< start_request_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for start_work
-    struct start_work : action_assignment, ObjectHelper<start_work,1> { start_work() : Object("start_work") {}
-		ListOf< work_item, 1, 0 >::Out items;
-    };
-
-    // C++ wrapper for straightness_tolerance
-    struct straightness_tolerance : geometric_tolerance, ObjectHelper<straightness_tolerance,0> { straightness_tolerance() : Object("straightness_tolerance") {}
-
-    };
-
-    // C++ wrapper for structured_dimension_callout
-    struct structured_dimension_callout : draughting_callout, ObjectHelper<structured_dimension_callout,0> { structured_dimension_callout() : Object("structured_dimension_callout") {}
-
-    };
-
-    // C++ wrapper for structured_text_composition
-    struct structured_text_composition : compound_representation_item, ObjectHelper<structured_text_composition,0> { structured_text_composition() : Object("structured_text_composition") {}
-
-    };
-
-    // C++ wrapper for structured_text_representation
-    struct structured_text_representation : representation, ObjectHelper<structured_text_representation,0> { structured_text_representation() : Object("structured_text_representation") {}
-
-    };
-
-    // C++ wrapper for subedge
-    struct subedge : edge, ObjectHelper<subedge,1> { subedge() : Object("subedge") {}
-		Lazy< edge > parent_edge;
-    };
-
-    // C++ wrapper for subface
-    struct subface : face, ObjectHelper<subface,1> { subface() : Object("subface") {}
-		Lazy< face > parent_face;
-    };
-
-    // C++ wrapper for supplied_part_relationship
-    struct supplied_part_relationship : product_definition_relationship, ObjectHelper<supplied_part_relationship,0> { supplied_part_relationship() : Object("supplied_part_relationship") {}
-
-    };
-
-    // C++ wrapper for surface_condition_callout
-    struct surface_condition_callout : draughting_callout, ObjectHelper<surface_condition_callout,0> { surface_condition_callout() : Object("surface_condition_callout") {}
-
-    };
-
-    // C++ wrapper for swept_surface
-    struct swept_surface : surface, ObjectHelper<swept_surface,1> { swept_surface() : Object("swept_surface") {}
-		Lazy< curve > swept_curve;
-    };
-
-    // C++ wrapper for surface_of_linear_extrusion
-    struct surface_of_linear_extrusion : swept_surface, ObjectHelper<surface_of_linear_extrusion,1> { surface_of_linear_extrusion() : Object("surface_of_linear_extrusion") {}
-		Lazy< vector > extrusion_axis;
-    };
-
-    // C++ wrapper for surface_of_revolution
-    struct surface_of_revolution : swept_surface, ObjectHelper<surface_of_revolution,1> { surface_of_revolution() : Object("surface_of_revolution") {}
-		Lazy< axis1_placement > axis_position;
-    };
-
-    // C++ wrapper for surface_patch
-    struct surface_patch : founded_item, ObjectHelper<surface_patch,5> { surface_patch() : Object("surface_patch") {}
-		Lazy< bounded_surface > parent_surface;
-		transition_code::Out u_transition;
-		transition_code::Out v_transition;
-		BOOLEAN::Out u_sense;
-		BOOLEAN::Out v_sense;
-    };
-
-    // C++ wrapper for surface_profile_tolerance
-    struct surface_profile_tolerance : geometric_tolerance, ObjectHelper<surface_profile_tolerance,0> { surface_profile_tolerance() : Object("surface_profile_tolerance") {}
-
-    };
-
-    // C++ wrapper for surface_replica
-    struct surface_replica : surface, ObjectHelper<surface_replica,2> { surface_replica() : Object("surface_replica") {}
-		Lazy< surface > parent_surface;
-		Lazy< cartesian_transformation_operator_3d > transformation;
-    };
-
-    // C++ wrapper for surface_side_style
-    struct surface_side_style : founded_item, ObjectHelper<surface_side_style,2> { surface_side_style() : Object("surface_side_style") {}
-		label::Out name;
-		ListOf< surface_style_element_select, 1, 7 >::Out styles;
-    };
-
-    // C++ wrapper for surface_style_boundary
-    struct surface_style_boundary : founded_item, ObjectHelper<surface_style_boundary,1> { surface_style_boundary() : Object("surface_style_boundary") {}
-		curve_or_render::Out style_of_boundary;
-    };
-
-    // C++ wrapper for surface_style_control_grid
-    struct surface_style_control_grid : founded_item, ObjectHelper<surface_style_control_grid,1> { surface_style_control_grid() : Object("surface_style_control_grid") {}
-		curve_or_render::Out style_of_control_grid;
-    };
-
-    // C++ wrapper for surface_style_fill_area
-    struct surface_style_fill_area : founded_item, ObjectHelper<surface_style_fill_area,1> { surface_style_fill_area() : Object("surface_style_fill_area") {}
-		Lazy< fill_area_style > fill_area;
-    };
-
-    // C++ wrapper for surface_style_parameter_line
-    struct surface_style_parameter_line : founded_item, ObjectHelper<surface_style_parameter_line,2> { surface_style_parameter_line() : Object("surface_style_parameter_line") {}
-		curve_or_render::Out style_of_parameter_lines;
-		ListOf< direction_count_select, 1, 2 >::Out direction_counts;
-    };
-
-    // C++ wrapper for surface_style_reflectance_ambient
-    struct surface_style_reflectance_ambient :  ObjectHelper<surface_style_reflectance_ambient,1> { surface_style_reflectance_ambient() : Object("surface_style_reflectance_ambient") {}
-		REAL::Out ambient_reflectance;
-    };
-
-    // C++ wrapper for surface_style_reflectance_ambient_diffuse
-    struct surface_style_reflectance_ambient_diffuse : surface_style_reflectance_ambient, ObjectHelper<surface_style_reflectance_ambient_diffuse,1> { surface_style_reflectance_ambient_diffuse() : Object("surface_style_reflectance_ambient_diffuse") {}
-		REAL::Out diffuse_reflectance;
-    };
-
-    // C++ wrapper for surface_style_reflectance_ambient_diffuse_specular
-    struct surface_style_reflectance_ambient_diffuse_specular : surface_style_reflectance_ambient_diffuse, ObjectHelper<surface_style_reflectance_ambient_diffuse_specular,3> { surface_style_reflectance_ambient_diffuse_specular() : Object("surface_style_reflectance_ambient_diffuse_specular") {}
-		REAL::Out specular_reflectance;
-		REAL::Out specular_exponent;
-		Lazy< colour > specular_colour;
-    };
-
-    // C++ wrapper for surface_style_rendering
-    struct surface_style_rendering :  ObjectHelper<surface_style_rendering,2> { surface_style_rendering() : Object("surface_style_rendering") {}
-		shading_surface_method::Out rendering_method;
-		Lazy< colour > surface_colour;
-    };
-
-    // C++ wrapper for surface_style_rendering_with_properties
-    struct surface_style_rendering_with_properties : surface_style_rendering, ObjectHelper<surface_style_rendering_with_properties,1> { surface_style_rendering_with_properties() : Object("surface_style_rendering_with_properties") {}
-		ListOf< rendering_properties_select, 1, 2 >::Out properties;
-    };
-
-    // C++ wrapper for surface_style_segmentation_curve
-    struct surface_style_segmentation_curve : founded_item, ObjectHelper<surface_style_segmentation_curve,1> { surface_style_segmentation_curve() : Object("surface_style_segmentation_curve") {}
-		curve_or_render::Out style_of_segmentation_curve;
-    };
-
-    // C++ wrapper for surface_style_silhouette
-    struct surface_style_silhouette : founded_item, ObjectHelper<surface_style_silhouette,1> { surface_style_silhouette() : Object("surface_style_silhouette") {}
-		curve_or_render::Out style_of_silhouette;
-    };
-
-    // C++ wrapper for surface_style_usage
-    struct surface_style_usage : founded_item, ObjectHelper<surface_style_usage,2> { surface_style_usage() : Object("surface_style_usage") {}
-		surface_side::Out side;
-		surface_side_style_select::Out style;
-    };
-
-    // C++ wrapper for surface_texture_representation
-    struct surface_texture_representation : representation, ObjectHelper<surface_texture_representation,0> { surface_texture_representation() : Object("surface_texture_representation") {}
-
-    };
-
-    // C++ wrapper for surfaced_open_shell
-    struct surfaced_open_shell : open_shell, ObjectHelper<surfaced_open_shell,0> { surfaced_open_shell() : Object("surfaced_open_shell") {}
-
-    };
-
-    // C++ wrapper for swept_disk_solid
-    struct swept_disk_solid : solid_model, ObjectHelper<swept_disk_solid,5> { swept_disk_solid() : Object("swept_disk_solid") {}
-		Lazy< curve > directrix;
-		positive_length_measure::Out radius;
-		Maybe< positive_length_measure::Out > inner_radius;
-		REAL::Out start_param;
-		REAL::Out end_param;
-    };
-
-    // C++ wrapper for symbol
-    struct symbol : representation_item, ObjectHelper<symbol,0> { symbol() : Object("symbol") {}
-
-    };
-
-    // C++ wrapper for symbol_representation_map
-    struct symbol_representation_map : representation_map, ObjectHelper<symbol_representation_map,0> { symbol_representation_map() : Object("symbol_representation_map") {}
-
-    };
-
-    // C++ wrapper for symbol_style
-    struct symbol_style : founded_item, ObjectHelper<symbol_style,2> { symbol_style() : Object("symbol_style") {}
-		label::Out name;
-		symbol_style_select::Out style_of_symbol;
-    };
-
-    // C++ wrapper for symbol_target
-    struct symbol_target : geometric_representation_item, ObjectHelper<symbol_target,3> { symbol_target() : Object("symbol_target") {}
-		axis2_placement::Out placement;
-		positive_ratio_measure::Out x_scale;
-		positive_ratio_measure::Out y_scale;
-    };
-
-    // C++ wrapper for symmetric_shape_aspect
-    struct symmetric_shape_aspect : shape_aspect, ObjectHelper<symmetric_shape_aspect,0> { symmetric_shape_aspect() : Object("symmetric_shape_aspect") {}
-
-    };
-
-    // C++ wrapper for symmetry_tolerance
-    struct symmetry_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<symmetry_tolerance,0> { symmetry_tolerance() : Object("symmetry_tolerance") {}
-
-    };
-
-    // C++ wrapper for table_representation_item
-    struct table_representation_item : compound_representation_item, ObjectHelper<table_representation_item,0> { table_representation_item() : Object("table_representation_item") {}
-
-    };
-
-    // C++ wrapper for tactile_appearance_representation
-    struct tactile_appearance_representation : representation, ObjectHelper<tactile_appearance_representation,0> { tactile_appearance_representation() : Object("tactile_appearance_representation") {}
-
-    };
-
-    // C++ wrapper for tagged_text_format
-    struct tagged_text_format : representation_context, ObjectHelper<tagged_text_format,0> { tagged_text_format() : Object("tagged_text_format") {}
-
-    };
-
-    // C++ wrapper for tagged_text_item
-    struct tagged_text_item : descriptive_representation_item, ObjectHelper<tagged_text_item,0> { tagged_text_item() : Object("tagged_text_item") {}
-
-    };
-
-    // C++ wrapper for tangent
-    struct tangent : derived_shape_aspect, ObjectHelper<tangent,0> { tangent() : Object("tangent") {}
-
-    };
-
-    // C++ wrapper for text_literal_with_associated_curves
-    struct text_literal_with_associated_curves : text_literal, ObjectHelper<text_literal_with_associated_curves,1> { text_literal_with_associated_curves() : Object("text_literal_with_associated_curves") {}
-		ListOf< Lazy< curve >, 1, 0 > associated_curves;
-    };
-
-    // C++ wrapper for text_literal_with_blanking_box
-    struct text_literal_with_blanking_box : text_literal, ObjectHelper<text_literal_with_blanking_box,1> { text_literal_with_blanking_box() : Object("text_literal_with_blanking_box") {}
-		Lazy< planar_box > blanking;
-    };
-
-    // C++ wrapper for text_literal_with_extent
-    struct text_literal_with_extent : text_literal, ObjectHelper<text_literal_with_extent,1> { text_literal_with_extent() : Object("text_literal_with_extent") {}
-		Lazy< planar_extent > extent;
-    };
-
-    // C++ wrapper for text_string_representation
-    struct text_string_representation : representation, ObjectHelper<text_string_representation,0> { text_string_representation() : Object("text_string_representation") {}
-
-    };
-
-    // C++ wrapper for text_style
-    struct text_style : founded_item, ObjectHelper<text_style,2> { text_style() : Object("text_style") {}
-		label::Out name;
-		character_style_select::Out character_appearance;
-    };
-
-    // C++ wrapper for text_style_with_box_characteristics
-    struct text_style_with_box_characteristics : text_style, ObjectHelper<text_style_with_box_characteristics,1> { text_style_with_box_characteristics() : Object("text_style_with_box_characteristics") {}
-		ListOf< box_characteristic_select, 1, 4 >::Out characteristics;
-    };
-
-    // C++ wrapper for text_style_with_mirror
-    struct text_style_with_mirror : text_style, ObjectHelper<text_style_with_mirror,1> { text_style_with_mirror() : Object("text_style_with_mirror") {}
-		axis2_placement::Out mirror_placement;
-    };
-
-    // C++ wrapper for text_style_with_spacing
-    struct text_style_with_spacing : text_style, ObjectHelper<text_style_with_spacing,1> { text_style_with_spacing() : Object("text_style_with_spacing") {}
-		character_spacing_select::Out character_spacing;
-    };
-
-    // C++ wrapper for thermal_resistance_measure_with_unit
-    struct thermal_resistance_measure_with_unit : measure_with_unit, ObjectHelper<thermal_resistance_measure_with_unit,0> { thermal_resistance_measure_with_unit() : Object("thermal_resistance_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for thermal_resistance_unit
-    struct thermal_resistance_unit : derived_unit, ObjectHelper<thermal_resistance_unit,0> { thermal_resistance_unit() : Object("thermal_resistance_unit") {}
-
-    };
-
-    // C++ wrapper for thermodynamic_temperature_measure_with_unit
-    struct thermodynamic_temperature_measure_with_unit : measure_with_unit, ObjectHelper<thermodynamic_temperature_measure_with_unit,0> { thermodynamic_temperature_measure_with_unit() : Object("thermodynamic_temperature_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for thermodynamic_temperature_unit
-    struct thermodynamic_temperature_unit : named_unit, ObjectHelper<thermodynamic_temperature_unit,0> { thermodynamic_temperature_unit() : Object("thermodynamic_temperature_unit") {}
-
-    };
-
-    // C++ wrapper for thickened_face_solid
-    struct thickened_face_solid : solid_model, ObjectHelper<thickened_face_solid,3> { thickened_face_solid() : Object("thickened_face_solid") {}
-		generalized_surface_select::Out base_element;
-		length_measure::Out offset1;
-		length_measure::Out offset2;
-    };
-
-    // C++ wrapper for thickness_laminate_definition
-    struct thickness_laminate_definition : product_definition, ObjectHelper<thickness_laminate_definition,0> { thickness_laminate_definition() : Object("thickness_laminate_definition") {}
-
-    };
-
-    // C++ wrapper for thickness_laminate_table
-    struct thickness_laminate_table : zone_structural_makeup, ObjectHelper<thickness_laminate_table,0> { thickness_laminate_table() : Object("thickness_laminate_table") {}
-
-    };
-
-    // C++ wrapper for time_interval
-    struct time_interval :  ObjectHelper<time_interval,3> { time_interval() : Object("time_interval") {}
-		identifier::Out id;
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for time_interval_based_effectivity
-    struct time_interval_based_effectivity : effectivity, ObjectHelper<time_interval_based_effectivity,1> { time_interval_based_effectivity() : Object("time_interval_based_effectivity") {}
-		Lazy< time_interval > effectivity_period;
-    };
-
-    // C++ wrapper for time_interval_with_bounds
-    struct time_interval_with_bounds : time_interval, ObjectHelper<time_interval_with_bounds,3> { time_interval_with_bounds() : Object("time_interval_with_bounds") {}
-		Maybe< date_time_or_event_occurrence::Out > primary_bound;
-		Maybe< date_time_or_event_occurrence::Out > secondary_bound;
-		Maybe< Lazy< time_measure_with_unit > > duration;
-    };
-
-    // C++ wrapper for time_measure_with_unit
-    struct time_measure_with_unit : measure_with_unit, ObjectHelper<time_measure_with_unit,0> { time_measure_with_unit() : Object("time_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for time_unit
-    struct time_unit : named_unit, ObjectHelper<time_unit,0> { time_unit() : Object("time_unit") {}
-
-    };
-
-    // C++ wrapper for tolerance_zone
-    struct tolerance_zone : shape_aspect, ObjectHelper<tolerance_zone,2> { tolerance_zone() : Object("tolerance_zone") {}
-		ListOf< Lazy< geometric_tolerance >, 1, 0 > defining_tolerance;
-		Lazy< NotImplemented > form;
-    };
-
-    // C++ wrapper for torus
-    struct torus : geometric_representation_item, ObjectHelper<torus,3> { torus() : Object("torus") {}
-		Lazy< axis1_placement > position;
-		positive_length_measure::Out major_radius;
-		positive_length_measure::Out minor_radius;
-    };
-
-    // C++ wrapper for total_runout_tolerance
-    struct total_runout_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<total_runout_tolerance,0> { total_runout_tolerance() : Object("total_runout_tolerance") {}
-
-    };
-
-    // C++ wrapper for track_blended_solid
-    struct track_blended_solid : edge_blended_solid, ObjectHelper<track_blended_solid,0> { track_blended_solid() : Object("track_blended_solid") {}
-
-    };
-
-    // C++ wrapper for track_blended_solid_with_end_conditions
-    struct track_blended_solid_with_end_conditions : track_blended_solid, ObjectHelper<track_blended_solid_with_end_conditions,1> { track_blended_solid_with_end_conditions() : Object("track_blended_solid_with_end_conditions") {}
-		ListOf< blend_end_condition_select, 2, 2 >::Out end_conditions;
-    };
-
-    // C++ wrapper for trimmed_curve
-    struct trimmed_curve : bounded_curve, ObjectHelper<trimmed_curve,5> { trimmed_curve() : Object("trimmed_curve") {}
-		Lazy< curve > basis_curve;
-		ListOf< trimming_select, 1, 2 >::Out trim_1;
-		ListOf< trimming_select, 1, 2 >::Out trim_2;
-		BOOLEAN::Out sense_agreement;
-		trimming_preference::Out master_representation;
-    };
-
-    // C++ wrapper for two_direction_repeat_factor
-    struct two_direction_repeat_factor : one_direction_repeat_factor, ObjectHelper<two_direction_repeat_factor,1> { two_direction_repeat_factor() : Object("two_direction_repeat_factor") {}
-		Lazy< vector > second_repeat_factor;
-    };
-
-    // C++ wrapper for unary_generic_expression
-    struct unary_generic_expression : generic_expression, ObjectHelper<unary_generic_expression,1> { unary_generic_expression() : Object("unary_generic_expression") {}
-		Lazy< generic_expression > operand;
-    };
-
-    // C++ wrapper for unary_numeric_expression
-    struct unary_numeric_expression :  ObjectHelper<unary_numeric_expression,0> { unary_numeric_expression() : Object("unary_numeric_expression") {}
-
-    };
-
-    // C++ wrapper for uncertainty_assigned_representation
-    struct uncertainty_assigned_representation : representation, ObjectHelper<uncertainty_assigned_representation,1> { uncertainty_assigned_representation() : Object("uncertainty_assigned_representation") {}
-		ListOf< Lazy< uncertainty_measure_with_unit >, 1, 0 > uncertainty;
-    };
-
-    // C++ wrapper for uncertainty_measure_with_unit
-    struct uncertainty_measure_with_unit : measure_with_unit, ObjectHelper<uncertainty_measure_with_unit,2> { uncertainty_measure_with_unit() : Object("uncertainty_measure_with_unit") {}
-		label::Out name;
-		Maybe< text::Out > description;
-    };
-
-    // C++ wrapper for uniform_curve
-    struct uniform_curve : b_spline_curve, ObjectHelper<uniform_curve,0> { uniform_curve() : Object("uniform_curve") {}
-
-    };
-
-    // C++ wrapper for uniform_resource_identifier
-    struct uniform_resource_identifier : descriptive_representation_item, ObjectHelper<uniform_resource_identifier,0> { uniform_resource_identifier() : Object("uniform_resource_identifier") {}
-
-    };
-
-    // C++ wrapper for uniform_surface
-    struct uniform_surface : b_spline_surface, ObjectHelper<uniform_surface,0> { uniform_surface() : Object("uniform_surface") {}
-
-    };
-
-    // C++ wrapper for usage_association
-    struct usage_association : action_method_relationship, ObjectHelper<usage_association,0> { usage_association() : Object("usage_association") {}
-
-    };
-
-    // C++ wrapper for user_defined_curve_font
-    struct user_defined_curve_font :  ObjectHelper<user_defined_curve_font,0> { user_defined_curve_font() : Object("user_defined_curve_font") {}
-
-    };
-
-    // C++ wrapper for user_defined_marker
-    struct user_defined_marker :  ObjectHelper<user_defined_marker,0> { user_defined_marker() : Object("user_defined_marker") {}
-
-    };
-
-    // C++ wrapper for user_defined_terminator_symbol
-    struct user_defined_terminator_symbol :  ObjectHelper<user_defined_terminator_symbol,0> { user_defined_terminator_symbol() : Object("user_defined_terminator_symbol") {}
-
-    };
-
-    // C++ wrapper for user_selected_shape_elements
-    struct user_selected_shape_elements : user_selected_elements, ObjectHelper<user_selected_shape_elements,0> { user_selected_shape_elements() : Object("user_selected_shape_elements") {}
-
-    };
-
-    // C++ wrapper for value_range
-    struct value_range : compound_representation_item, ObjectHelper<value_range,0> { value_range() : Object("value_range") {}
-
-    };
-
-    // C++ wrapper for value_representation_item
-    struct value_representation_item : representation_item, ObjectHelper<value_representation_item,1> { value_representation_item() : Object("value_representation_item") {}
-		measure_value::Out value_component;
-    };
-
-    // C++ wrapper for variable_semantics
-    struct variable_semantics :  ObjectHelper<variable_semantics,0> { variable_semantics() : Object("variable_semantics") {}
-
-    };
-
-    // C++ wrapper for variational_representation_item
-    struct variational_representation_item : representation_item, ObjectHelper<variational_representation_item,0> { variational_representation_item() : Object("variational_representation_item") {}
-
-    };
-
-    // C++ wrapper for vector
-    struct vector : geometric_representation_item, ObjectHelper<vector,2> { vector() : Object("vector") {}
-		Lazy< direction > orientation;
-		length_measure::Out magnitude;
-    };
-
-    // C++ wrapper for vector_style
-    struct vector_style :  ObjectHelper<vector_style,0> { vector_style() : Object("vector_style") {}
-
-    };
-
-    // C++ wrapper for velocity_measure_with_unit
-    struct velocity_measure_with_unit : measure_with_unit, ObjectHelper<velocity_measure_with_unit,0> { velocity_measure_with_unit() : Object("velocity_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for velocity_unit
-    struct velocity_unit : derived_unit, ObjectHelper<velocity_unit,0> { velocity_unit() : Object("velocity_unit") {}
-
-    };
-
-    // C++ wrapper for vertex
-    struct vertex : topological_representation_item, ObjectHelper<vertex,0> { vertex() : Object("vertex") {}
-
-    };
-
-    // C++ wrapper for vertex_loop
-    struct vertex_loop : loop, ObjectHelper<vertex_loop,1> { vertex_loop() : Object("vertex_loop") {}
-		Lazy< vertex > loop_vertex;
-    };
-
-    // C++ wrapper for vertex_point
-    struct vertex_point :  ObjectHelper<vertex_point,1> { vertex_point() : Object("vertex_point") {}
-		Lazy< point > vertex_geometry;
-    };
-
-    // C++ wrapper for vertex_shell
-    struct vertex_shell : topological_representation_item, ObjectHelper<vertex_shell,1> { vertex_shell() : Object("vertex_shell") {}
-		Lazy< vertex_loop > vertex_shell_extent;
-    };
-
-    // C++ wrapper for view_volume
-    struct view_volume : founded_item, ObjectHelper<view_volume,9> { view_volume() : Object("view_volume") {}
-		central_or_parallel::Out projection_type;
-		Lazy< cartesian_point > projection_point;
-		length_measure::Out view_plane_distance;
-		length_measure::Out front_plane_distance;
-		BOOLEAN::Out front_plane_clipping;
-		length_measure::Out back_plane_distance;
-		BOOLEAN::Out back_plane_clipping;
-		BOOLEAN::Out view_volume_sides_clipping;
-		Lazy< planar_box > view_window;
-    };
-
-    // C++ wrapper for visual_appearance_representation
-    struct visual_appearance_representation : representation, ObjectHelper<visual_appearance_representation,0> { visual_appearance_representation() : Object("visual_appearance_representation") {}
-
-    };
-
-    // C++ wrapper for volume_measure_with_unit
-    struct volume_measure_with_unit : measure_with_unit, ObjectHelper<volume_measure_with_unit,0> { volume_measure_with_unit() : Object("volume_measure_with_unit") {}
-
-    };
-
-    // C++ wrapper for volume_unit
-    struct volume_unit : derived_unit, ObjectHelper<volume_unit,0> { volume_unit() : Object("volume_unit") {}
-
-    };
-
-    // C++ wrapper for week_of_year_and_day_date
-    struct week_of_year_and_day_date : date, ObjectHelper<week_of_year_and_day_date,2> { week_of_year_and_day_date() : Object("week_of_year_and_day_date") {}
-		week_in_year_number::Out week_component;
-		Maybe< day_in_week_number::Out > day_component;
-    };
-
-    // C++ wrapper for wire_shell
-    struct wire_shell : topological_representation_item, ObjectHelper<wire_shell,1> { wire_shell() : Object("wire_shell") {}
-		ListOf< Lazy< loop >, 1, 0 > wire_shell_extent;
-    };
-
-    // C++ wrapper for year_month
-    struct year_month : date, ObjectHelper<year_month,1> { year_month() : Object("year_month") {}
-		month_in_year_number::Out month_component;
-    };
-
-	void GetSchema(EXPRESS::ConversionSchema& out);
-
-} //! StepFile
-namespace STEP {
-
-	// ******************************************************************************
-	// Converter stubs
-	// ******************************************************************************
-	
-#define DECL_CONV_STUB(type) template <> size_t GenericFill<StepFile::type>(const STEP::DB& db, const EXPRESS::LIST& params, StepFile::type* in)
-	
-	DECL_CONV_STUB(measure_with_unit);
-	DECL_CONV_STUB(absorbed_dose_measure_with_unit);
-	DECL_CONV_STUB(derived_unit);
-	DECL_CONV_STUB(absorbed_dose_unit);
-	DECL_CONV_STUB(abstract_variable);
-	DECL_CONV_STUB(acceleration_measure_with_unit);
-	DECL_CONV_STUB(acceleration_unit);
-	DECL_CONV_STUB(action);
-	DECL_CONV_STUB(action_assignment);
-	DECL_CONV_STUB(action_method);
-	DECL_CONV_STUB(action_method_assignment);
-	DECL_CONV_STUB(action_method_relationship);
-	DECL_CONV_STUB(action_request_assignment);
-	DECL_CONV_STUB(address);
-	DECL_CONV_STUB(representation);
-	DECL_CONV_STUB(shape_representation);
-	DECL_CONV_STUB(advanced_brep_shape_representation);
-	DECL_CONV_STUB(face_surface);
-	DECL_CONV_STUB(advanced_face);
-	DECL_CONV_STUB(amount_of_substance_measure_with_unit);
-	DECL_CONV_STUB(named_unit);
-	DECL_CONV_STUB(amount_of_substance_unit);
-	DECL_CONV_STUB(angle_direction_reference);
-	DECL_CONV_STUB(representation_item);
-	DECL_CONV_STUB(geometric_representation_item);
-	DECL_CONV_STUB(draughting_callout);
-	DECL_CONV_STUB(dimension_curve_directed_callout);
-	DECL_CONV_STUB(angular_dimension);
-	DECL_CONV_STUB(shape_aspect_relationship);
-	DECL_CONV_STUB(dimensional_location);
-	DECL_CONV_STUB(angular_location);
-	DECL_CONV_STUB(dimensional_size);
-	DECL_CONV_STUB(angular_size);
-	DECL_CONV_STUB(geometric_tolerance);
-	DECL_CONV_STUB(geometric_tolerance_with_datum_reference);
-	DECL_CONV_STUB(angularity_tolerance);
-	DECL_CONV_STUB(styled_item);
-	DECL_CONV_STUB(annotation_occurrence);
-	DECL_CONV_STUB(annotation_curve_occurrence);
-	DECL_CONV_STUB(annotation_fill_area);
-	DECL_CONV_STUB(annotation_fill_area_occurrence);
-	DECL_CONV_STUB(annotation_occurrence_relationship);
-	DECL_CONV_STUB(annotation_occurrence_associativity);
-	DECL_CONV_STUB(annotation_plane);
-	DECL_CONV_STUB(annotation_symbol_occurrence);
-	DECL_CONV_STUB(annotation_subfigure_occurrence);
-	DECL_CONV_STUB(mapped_item);
-	DECL_CONV_STUB(annotation_symbol);
-	DECL_CONV_STUB(annotation_text);
-	DECL_CONV_STUB(annotation_text_character);
-	DECL_CONV_STUB(annotation_text_occurrence);
-	DECL_CONV_STUB(shape_aspect);
-	DECL_CONV_STUB(derived_shape_aspect);
-	DECL_CONV_STUB(apex);
-	DECL_CONV_STUB(application_context_element);
-	DECL_CONV_STUB(applied_action_assignment);
-	DECL_CONV_STUB(applied_action_method_assignment);
-	DECL_CONV_STUB(applied_action_request_assignment);
-	DECL_CONV_STUB(approval_assignment);
-	DECL_CONV_STUB(applied_approval_assignment);
-	DECL_CONV_STUB(attribute_classification_assignment);
-	DECL_CONV_STUB(applied_attribute_classification_assignment);
-	DECL_CONV_STUB(certification_assignment);
-	DECL_CONV_STUB(applied_certification_assignment);
-	DECL_CONV_STUB(classification_assignment);
-	DECL_CONV_STUB(applied_classification_assignment);
-	DECL_CONV_STUB(contract_assignment);
-	DECL_CONV_STUB(applied_contract_assignment);
-	DECL_CONV_STUB(date_and_time_assignment);
-	DECL_CONV_STUB(applied_date_and_time_assignment);
-	DECL_CONV_STUB(date_assignment);
-	DECL_CONV_STUB(applied_date_assignment);
-	DECL_CONV_STUB(document_reference);
-	DECL_CONV_STUB(applied_document_reference);
-	DECL_CONV_STUB(document_usage_constraint_assignment);
-	DECL_CONV_STUB(applied_document_usage_constraint_assignment);
-	DECL_CONV_STUB(effectivity_assignment);
-	DECL_CONV_STUB(applied_effectivity_assignment);
-	DECL_CONV_STUB(event_occurrence_assignment);
-	DECL_CONV_STUB(applied_event_occurrence_assignment);
-	DECL_CONV_STUB(identification_assignment);
-	DECL_CONV_STUB(external_identification_assignment);
-	DECL_CONV_STUB(applied_external_identification_assignment);
-	DECL_CONV_STUB(group_assignment);
-	DECL_CONV_STUB(applied_group_assignment);
-	DECL_CONV_STUB(applied_identification_assignment);
-	DECL_CONV_STUB(name_assignment);
-	DECL_CONV_STUB(applied_name_assignment);
-	DECL_CONV_STUB(organization_assignment);
-	DECL_CONV_STUB(applied_organization_assignment);
-	DECL_CONV_STUB(organizational_project_assignment);
-	DECL_CONV_STUB(applied_organizational_project_assignment);
-	DECL_CONV_STUB(person_and_organization_assignment);
-	DECL_CONV_STUB(applied_person_and_organization_assignment);
-	DECL_CONV_STUB(presented_item);
-	DECL_CONV_STUB(applied_presented_item);
-	DECL_CONV_STUB(security_classification_assignment);
-	DECL_CONV_STUB(applied_security_classification_assignment);
-	DECL_CONV_STUB(time_interval_assignment);
-	DECL_CONV_STUB(applied_time_interval_assignment);
-	DECL_CONV_STUB(applied_usage_right);
-	DECL_CONV_STUB(area_in_set);
-	DECL_CONV_STUB(area_measure_with_unit);
-	DECL_CONV_STUB(area_unit);
-	DECL_CONV_STUB(product_definition_relationship);
-	DECL_CONV_STUB(product_definition_usage);
-	DECL_CONV_STUB(assembly_component_usage);
-	DECL_CONV_STUB(assigned_requirement);
-	DECL_CONV_STUB(compound_representation_item);
-	DECL_CONV_STUB(atomic_formula);
-	DECL_CONV_STUB(attribute_assertion);
-	DECL_CONV_STUB(attribute_language_assignment);
-	DECL_CONV_STUB(attribute_value_assignment);
-	DECL_CONV_STUB(auxiliary_geometric_representation_item);
-	DECL_CONV_STUB(placement);
-	DECL_CONV_STUB(axis1_placement);
-	DECL_CONV_STUB(axis2_placement_2d);
-	DECL_CONV_STUB(axis2_placement_3d);
-	DECL_CONV_STUB(curve);
-	DECL_CONV_STUB(bounded_curve);
-	DECL_CONV_STUB(b_spline_curve);
-	DECL_CONV_STUB(b_spline_curve_with_knots);
-	DECL_CONV_STUB(surface);
-	DECL_CONV_STUB(bounded_surface);
-	DECL_CONV_STUB(b_spline_surface);
-	DECL_CONV_STUB(b_spline_surface_with_knots);
-	DECL_CONV_STUB(product_definition);
-	DECL_CONV_STUB(rule_software_definition);
-	DECL_CONV_STUB(rule_definition);
-	DECL_CONV_STUB(back_chaining_rule);
-	DECL_CONV_STUB(back_chaining_rule_body);
-	DECL_CONV_STUB(colour);
-	DECL_CONV_STUB(background_colour);
-	DECL_CONV_STUB(beveled_sheet_representation);
-	DECL_CONV_STUB(bezier_curve);
-	DECL_CONV_STUB(bezier_surface);
-	DECL_CONV_STUB(generic_expression);
-	DECL_CONV_STUB(binary_generic_expression);
-	DECL_CONV_STUB(binary_numeric_expression);
-	DECL_CONV_STUB(binary_representation_item);
-	DECL_CONV_STUB(block);
-	DECL_CONV_STUB(expression);
-	DECL_CONV_STUB(boolean_expression);
-	DECL_CONV_STUB(boolean_literal);
-	DECL_CONV_STUB(boolean_representation_item);
-	DECL_CONV_STUB(boolean_result);
-	DECL_CONV_STUB(composite_curve);
-	DECL_CONV_STUB(composite_curve_on_surface);
-	DECL_CONV_STUB(boundary_curve);
-	DECL_CONV_STUB(bounded_pcurve);
-	DECL_CONV_STUB(bounded_surface_curve);
-	DECL_CONV_STUB(founded_item);
-	DECL_CONV_STUB(box_domain);
-	DECL_CONV_STUB(half_space_solid);
-	DECL_CONV_STUB(boxed_half_space);
-	DECL_CONV_STUB(breakdown_context);
-	DECL_CONV_STUB(breakdown_element_group_assignment);
-	DECL_CONV_STUB(breakdown_element_realization);
-	DECL_CONV_STUB(breakdown_element_usage);
-	DECL_CONV_STUB(breakdown_of);
-	DECL_CONV_STUB(solid_model);
-	DECL_CONV_STUB(manifold_solid_brep);
-	DECL_CONV_STUB(brep_with_voids);
-	DECL_CONV_STUB(bytes_representation_item);
-	DECL_CONV_STUB(date);
-	DECL_CONV_STUB(calendar_date);
-	DECL_CONV_STUB(camera_image);
-	DECL_CONV_STUB(camera_image_3d_with_scale);
-	DECL_CONV_STUB(camera_model);
-	DECL_CONV_STUB(camera_model_d3);
-	DECL_CONV_STUB(camera_model_d3_multi_clipping);
-	DECL_CONV_STUB(camera_model_d3_multi_clipping_intersection);
-	DECL_CONV_STUB(camera_model_d3_multi_clipping_union);
-	DECL_CONV_STUB(camera_model_d3_with_hlhsr);
-	DECL_CONV_STUB(camera_model_with_light_sources);
-	DECL_CONV_STUB(representation_map);
-	DECL_CONV_STUB(camera_usage);
-	DECL_CONV_STUB(capacitance_measure_with_unit);
-	DECL_CONV_STUB(capacitance_unit);
-	DECL_CONV_STUB(point);
-	DECL_CONV_STUB(cartesian_point);
-	DECL_CONV_STUB(cartesian_transformation_operator);
-	DECL_CONV_STUB(cartesian_transformation_operator_2d);
-	DECL_CONV_STUB(cartesian_transformation_operator_3d);
-	DECL_CONV_STUB(cc_design_approval);
-	DECL_CONV_STUB(cc_design_certification);
-	DECL_CONV_STUB(cc_design_contract);
-	DECL_CONV_STUB(cc_design_date_and_time_assignment);
-	DECL_CONV_STUB(cc_design_person_and_organization_assignment);
-	DECL_CONV_STUB(cc_design_security_classification);
-	DECL_CONV_STUB(cc_design_specification_reference);
-	DECL_CONV_STUB(celsius_temperature_measure_with_unit);
-	DECL_CONV_STUB(centre_of_symmetry);
-	DECL_CONV_STUB(change);
-	DECL_CONV_STUB(change_request);
-	DECL_CONV_STUB(character_glyph_style_outline);
-	DECL_CONV_STUB(character_glyph_style_stroke);
-	DECL_CONV_STUB(symbol_representation);
-	DECL_CONV_STUB(generic_character_glyph_symbol);
-	DECL_CONV_STUB(character_glyph_symbol);
-	DECL_CONV_STUB(character_glyph_symbol_outline);
-	DECL_CONV_STUB(character_glyph_symbol_stroke);
-	DECL_CONV_STUB(general_property);
-	DECL_CONV_STUB(characteristic_data_column_header);
-	DECL_CONV_STUB(general_property_relationship);
-	DECL_CONV_STUB(characteristic_data_column_header_link);
-	DECL_CONV_STUB(characteristic_data_table_header);
-	DECL_CONV_STUB(characteristic_data_table_header_decomposition);
-	DECL_CONV_STUB(group);
-	DECL_CONV_STUB(characteristic_type);
-	DECL_CONV_STUB(characterized_class);
-	DECL_CONV_STUB(characterized_object);
-	DECL_CONV_STUB(conic);
-	DECL_CONV_STUB(circle);
-	DECL_CONV_STUB(circular_runout_tolerance);
-	DECL_CONV_STUB(class_by_extension);
-	DECL_CONV_STUB(class_by_intension);
-	DECL_CONV_STUB(class_system);
-	DECL_CONV_STUB(effectivity_context_assignment);
-	DECL_CONV_STUB(class_usage_effectivity_context_assignment);
-	DECL_CONV_STUB(topological_representation_item);
-	DECL_CONV_STUB(connected_face_set);
-	DECL_CONV_STUB(closed_shell);
-	DECL_CONV_STUB(coaxiality_tolerance);
-	DECL_CONV_STUB(colour_specification);
-	DECL_CONV_STUB(colour_rgb);
-	DECL_CONV_STUB(common_datum);
-	DECL_CONV_STUB(comparison_expression);
-	DECL_CONV_STUB(complex_clause);
-	DECL_CONV_STUB(complex_conjunctive_clause);
-	DECL_CONV_STUB(complex_disjunctive_clause);
-	DECL_CONV_STUB(modified_solid);
-	DECL_CONV_STUB(shelled_solid);
-	DECL_CONV_STUB(complex_shelled_solid);
-	DECL_CONV_STUB(composite_assembly_definition);
-	DECL_CONV_STUB(composite_assembly_sequence_definition);
-	DECL_CONV_STUB(laminate_table);
-	DECL_CONV_STUB(part_laminate_table);
-	DECL_CONV_STUB(composite_assembly_table);
-	DECL_CONV_STUB(composite_curve_segment);
-	DECL_CONV_STUB(material_designation);
-	DECL_CONV_STUB(composite_material_designation);
-	DECL_CONV_STUB(composite_shape_aspect);
-	DECL_CONV_STUB(composite_sheet_representation);
-	DECL_CONV_STUB(composite_text);
-	DECL_CONV_STUB(composite_text_with_associated_curves);
-	DECL_CONV_STUB(composite_text_with_blanking_box);
-	DECL_CONV_STUB(composite_text_with_delineation);
-	DECL_CONV_STUB(composite_text_with_extent);
-	DECL_CONV_STUB(compound_shape_representation);
-	DECL_CONV_STUB(concentricity_tolerance);
-	DECL_CONV_STUB(concept_feature_relationship);
-	DECL_CONV_STUB(concept_feature_relationship_with_condition);
-	DECL_CONV_STUB(product_concept_feature);
-	DECL_CONV_STUB(conditional_concept_feature);
-	DECL_CONV_STUB(conductance_measure_with_unit);
-	DECL_CONV_STUB(conductance_unit);
-	DECL_CONV_STUB(configuration_item);
-	DECL_CONV_STUB(configurable_item);
-	DECL_CONV_STUB(effectivity);
-	DECL_CONV_STUB(product_definition_effectivity);
-	DECL_CONV_STUB(configuration_effectivity);
-	DECL_CONV_STUB(configuration_item_relationship);
-	DECL_CONV_STUB(configuration_item_hierarchical_relationship);
-	DECL_CONV_STUB(configuration_item_revision_sequence);
-	DECL_CONV_STUB(configured_effectivity_assignment);
-	DECL_CONV_STUB(configured_effectivity_context_assignment);
-	DECL_CONV_STUB(conical_stepped_hole_transition);
-	DECL_CONV_STUB(elementary_surface);
-	DECL_CONV_STUB(conical_surface);
-	DECL_CONV_STUB(connected_edge_set);
-	DECL_CONV_STUB(connected_face_sub_set);
-	DECL_CONV_STUB(constructive_geometry_representation);
-	DECL_CONV_STUB(representation_relationship);
-	DECL_CONV_STUB(constructive_geometry_representation_relationship);
-	DECL_CONV_STUB(contact_ratio_representation);
-	DECL_CONV_STUB(invisibility);
-	DECL_CONV_STUB(context_dependent_invisibility);
-	DECL_CONV_STUB(over_riding_styled_item);
-	DECL_CONV_STUB(context_dependent_over_riding_styled_item);
-	DECL_CONV_STUB(context_dependent_unit);
-	DECL_CONV_STUB(conversion_based_unit);
-	DECL_CONV_STUB(csg_shape_representation);
-	DECL_CONV_STUB(csg_solid);
-	DECL_CONV_STUB(currency);
-	DECL_CONV_STUB(currency_measure_with_unit);
-	DECL_CONV_STUB(curve_bounded_surface);
-	DECL_CONV_STUB(curve_dimension);
-	DECL_CONV_STUB(curve_replica);
-	DECL_CONV_STUB(curve_style);
-	DECL_CONV_STUB(curve_style_font);
-	DECL_CONV_STUB(curve_style_font_and_scaling);
-	DECL_CONV_STUB(curve_style_font_pattern);
-	DECL_CONV_STUB(curve_swept_solid_shape_representation);
-	DECL_CONV_STUB(cylindrical_surface);
-	DECL_CONV_STUB(cylindricity_tolerance);
-	DECL_CONV_STUB(date_representation_item);
-	DECL_CONV_STUB(date_time_representation_item);
-	DECL_CONV_STUB(dated_effectivity);
-	DECL_CONV_STUB(datum);
-	DECL_CONV_STUB(datum_feature);
-	DECL_CONV_STUB(datum_feature_callout);
-	DECL_CONV_STUB(datum_reference);
-	DECL_CONV_STUB(datum_target);
-	DECL_CONV_STUB(datum_target_callout);
-	DECL_CONV_STUB(default_tolerance_table);
-	DECL_CONV_STUB(default_tolerance_table_cell);
-	DECL_CONV_STUB(defined_symbol);
-	DECL_CONV_STUB(definitional_representation);
-	DECL_CONV_STUB(definitional_representation_relationship);
-	DECL_CONV_STUB(definitional_representation_relationship_with_same_context);
-	DECL_CONV_STUB(degenerate_pcurve);
-	DECL_CONV_STUB(toroidal_surface);
-	DECL_CONV_STUB(degenerate_toroidal_surface);
-	DECL_CONV_STUB(descriptive_representation_item);
-	DECL_CONV_STUB(product_definition_context);
-	DECL_CONV_STUB(design_context);
-	DECL_CONV_STUB(design_make_from_relationship);
-	DECL_CONV_STUB(diameter_dimension);
-	DECL_CONV_STUB(ratio_measure_with_unit);
-	DECL_CONV_STUB(dielectric_constant_measure_with_unit);
-	DECL_CONV_STUB(dimension_callout);
-	DECL_CONV_STUB(draughting_callout_relationship);
-	DECL_CONV_STUB(dimension_callout_component_relationship);
-	DECL_CONV_STUB(dimension_callout_relationship);
-	DECL_CONV_STUB(dimension_curve);
-	DECL_CONV_STUB(terminator_symbol);
-	DECL_CONV_STUB(dimension_curve_terminator);
-	DECL_CONV_STUB(dimension_curve_terminator_to_projection_curve_associativity);
-	DECL_CONV_STUB(dimension_pair);
-	DECL_CONV_STUB(dimension_text_associativity);
-	DECL_CONV_STUB(dimensional_location_with_path);
-	DECL_CONV_STUB(dimensional_size_with_path);
-	DECL_CONV_STUB(executed_action);
-	DECL_CONV_STUB(directed_action);
-	DECL_CONV_STUB(directed_dimensional_location);
-	DECL_CONV_STUB(direction);
-	DECL_CONV_STUB(document_file);
-	DECL_CONV_STUB(document_identifier);
-	DECL_CONV_STUB(document_identifier_assignment);
-	DECL_CONV_STUB(document_product_association);
-	DECL_CONV_STUB(document_product_equivalence);
-	DECL_CONV_STUB(dose_equivalent_measure_with_unit);
-	DECL_CONV_STUB(dose_equivalent_unit);
-	DECL_CONV_STUB(double_offset_shelled_solid);
-	DECL_CONV_STUB(item_defined_transformation);
-	DECL_CONV_STUB(transformation_with_derived_angle);
-	DECL_CONV_STUB(draped_defined_transformation);
-	DECL_CONV_STUB(draughting_annotation_occurrence);
-	DECL_CONV_STUB(draughting_elements);
-	DECL_CONV_STUB(draughting_model);
-	DECL_CONV_STUB(item_identified_representation_usage);
-	DECL_CONV_STUB(draughting_model_item_association);
-	DECL_CONV_STUB(pre_defined_colour);
-	DECL_CONV_STUB(draughting_pre_defined_colour);
-	DECL_CONV_STUB(pre_defined_item);
-	DECL_CONV_STUB(pre_defined_curve_font);
-	DECL_CONV_STUB(draughting_pre_defined_curve_font);
-	DECL_CONV_STUB(pre_defined_text_font);
-	DECL_CONV_STUB(draughting_pre_defined_text_font);
-	DECL_CONV_STUB(draughting_subfigure_representation);
-	DECL_CONV_STUB(draughting_symbol_representation);
-	DECL_CONV_STUB(text_literal);
-	DECL_CONV_STUB(text_literal_with_delineation);
-	DECL_CONV_STUB(draughting_text_literal_with_delineation);
-	DECL_CONV_STUB(presentation_set);
-	DECL_CONV_STUB(drawing_revision);
-	DECL_CONV_STUB(presentation_representation);
-	DECL_CONV_STUB(presentation_area);
-	DECL_CONV_STUB(drawing_sheet_revision);
-	DECL_CONV_STUB(drawing_sheet_revision_sequence);
-	DECL_CONV_STUB(drawing_sheet_revision_usage);
-	DECL_CONV_STUB(edge);
-	DECL_CONV_STUB(edge_based_wireframe_model);
-	DECL_CONV_STUB(edge_based_wireframe_shape_representation);
-	DECL_CONV_STUB(edge_blended_solid);
-	DECL_CONV_STUB(edge_curve);
-	DECL_CONV_STUB(edge_loop);
-	DECL_CONV_STUB(electric_charge_measure_with_unit);
-	DECL_CONV_STUB(electric_charge_unit);
-	DECL_CONV_STUB(electric_current_measure_with_unit);
-	DECL_CONV_STUB(electric_current_unit);
-	DECL_CONV_STUB(electric_potential_measure_with_unit);
-	DECL_CONV_STUB(electric_potential_unit);
-	DECL_CONV_STUB(elementary_brep_shape_representation);
-	DECL_CONV_STUB(ellipse);
-	DECL_CONV_STUB(energy_measure_with_unit);
-	DECL_CONV_STUB(energy_unit);
-	DECL_CONV_STUB(property_definition);
-	DECL_CONV_STUB(fact_type);
-	DECL_CONV_STUB(entity_assertion);
-	DECL_CONV_STUB(enum_reference_prefix);
-	DECL_CONV_STUB(evaluated_characteristic);
-	DECL_CONV_STUB(evaluated_degenerate_pcurve);
-	DECL_CONV_STUB(evaluation_product_definition);
-	DECL_CONV_STUB(event_occurrence);
-	DECL_CONV_STUB(product_concept_feature_category);
-	DECL_CONV_STUB(exclusive_product_concept_feature_category);
-	DECL_CONV_STUB(uncertainty_qualifier);
-	DECL_CONV_STUB(standard_uncertainty);
-	DECL_CONV_STUB(expanded_uncertainty);
-	DECL_CONV_STUB(representation_item_relationship);
-	DECL_CONV_STUB(explicit_procedural_representation_item_relationship);
-	DECL_CONV_STUB(explicit_procedural_geometric_representation_item_relationship);
-	DECL_CONV_STUB(explicit_procedural_representation_relationship);
-	DECL_CONV_STUB(explicit_procedural_shape_representation_relationship);
-	DECL_CONV_STUB(expression_conversion_based_unit);
-	DECL_CONV_STUB(extension);
-	DECL_CONV_STUB(extent);
-	DECL_CONV_STUB(external_source);
-	DECL_CONV_STUB(external_class_library);
-	DECL_CONV_STUB(externally_defined_class);
-	DECL_CONV_STUB(externally_defined_colour);
-	DECL_CONV_STUB(externally_defined_context_dependent_unit);
-	DECL_CONV_STUB(externally_defined_conversion_based_unit);
-	DECL_CONV_STUB(externally_defined_currency);
-	DECL_CONV_STUB(externally_defined_item);
-	DECL_CONV_STUB(externally_defined_curve_font);
-	DECL_CONV_STUB(externally_defined_dimension_definition);
-	DECL_CONV_STUB(externally_defined_general_property);
-	DECL_CONV_STUB(externally_defined_hatch_style);
-	DECL_CONV_STUB(externally_defined_marker);
-	DECL_CONV_STUB(picture_representation_item);
-	DECL_CONV_STUB(externally_defined_picture_representation_item);
-	DECL_CONV_STUB(externally_defined_representation_item);
-	DECL_CONV_STUB(externally_defined_string);
-	DECL_CONV_STUB(externally_defined_symbol);
-	DECL_CONV_STUB(externally_defined_terminator_symbol);
-	DECL_CONV_STUB(externally_defined_text_font);
-	DECL_CONV_STUB(externally_defined_tile);
-	DECL_CONV_STUB(externally_defined_tile_style);
-	DECL_CONV_STUB(swept_area_solid);
-	DECL_CONV_STUB(extruded_area_solid);
-	DECL_CONV_STUB(swept_face_solid);
-	DECL_CONV_STUB(extruded_face_solid);
-	DECL_CONV_STUB(extruded_face_solid_with_trim_conditions);
-	DECL_CONV_STUB(extruded_face_solid_with_draft_angle);
-	DECL_CONV_STUB(extruded_face_solid_with_multiple_draft_angles);
-	DECL_CONV_STUB(face);
-	DECL_CONV_STUB(face_based_surface_model);
-	DECL_CONV_STUB(face_bound);
-	DECL_CONV_STUB(face_outer_bound);
-	DECL_CONV_STUB(faceted_brep);
-	DECL_CONV_STUB(faceted_brep_shape_representation);
-	DECL_CONV_STUB(fill_area_style);
-	DECL_CONV_STUB(fill_area_style_hatching);
-	DECL_CONV_STUB(fill_area_style_tile_coloured_region);
-	DECL_CONV_STUB(fill_area_style_tile_curve_with_style);
-	DECL_CONV_STUB(fill_area_style_tile_symbol_with_style);
-	DECL_CONV_STUB(fill_area_style_tiles);
-	DECL_CONV_STUB(shape_representation_relationship);
-	DECL_CONV_STUB(flat_pattern_ply_representation_relationship);
-	DECL_CONV_STUB(flatness_tolerance);
-	DECL_CONV_STUB(force_measure_with_unit);
-	DECL_CONV_STUB(force_unit);
-	DECL_CONV_STUB(forward_chaining_rule);
-	DECL_CONV_STUB(forward_chaining_rule_premise);
-	DECL_CONV_STUB(frequency_measure_with_unit);
-	DECL_CONV_STUB(frequency_unit);
-	DECL_CONV_STUB(func);
-	DECL_CONV_STUB(functional_breakdown_context);
-	DECL_CONV_STUB(functional_element_usage);
-	DECL_CONV_STUB(general_material_property);
-	DECL_CONV_STUB(simple_generic_expression);
-	DECL_CONV_STUB(generic_literal);
-	DECL_CONV_STUB(generic_variable);
-	DECL_CONV_STUB(geometric_alignment);
-	DECL_CONV_STUB(geometric_set);
-	DECL_CONV_STUB(geometric_curve_set);
-	DECL_CONV_STUB(geometric_intersection);
-	DECL_CONV_STUB(geometric_item_specific_usage);
-	DECL_CONV_STUB(geometric_model_element_relationship);
-	DECL_CONV_STUB(representation_context);
-	DECL_CONV_STUB(geometric_representation_context);
-	DECL_CONV_STUB(geometric_tolerance_with_defined_unit);
-	DECL_CONV_STUB(geometrical_tolerance_callout);
-	DECL_CONV_STUB(geometrically_bounded_2d_wireframe_representation);
-	DECL_CONV_STUB(geometrically_bounded_surface_shape_representation);
-	DECL_CONV_STUB(geometrically_bounded_wireframe_shape_representation);
-	DECL_CONV_STUB(global_assignment);
-	DECL_CONV_STUB(global_uncertainty_assigned_context);
-	DECL_CONV_STUB(global_unit_assigned_context);
-	DECL_CONV_STUB(ground_fact);
-	DECL_CONV_STUB(hardness_representation);
-	DECL_CONV_STUB(hidden_element_over_riding_styled_item);
-	DECL_CONV_STUB(hyperbola);
-	DECL_CONV_STUB(illuminance_measure_with_unit);
-	DECL_CONV_STUB(illuminance_unit);
-	DECL_CONV_STUB(included_text_block);
-	DECL_CONV_STUB(inclusion_product_concept_feature);
-	DECL_CONV_STUB(user_selected_elements);
-	DECL_CONV_STUB(indirectly_selected_elements);
-	DECL_CONV_STUB(indirectly_selected_shape_elements);
-	DECL_CONV_STUB(inductance_measure_with_unit);
-	DECL_CONV_STUB(inductance_unit);
-	DECL_CONV_STUB(information_right);
-	DECL_CONV_STUB(information_usage_right);
-	DECL_CONV_STUB(instance_usage_context_assignment);
-	DECL_CONV_STUB(instanced_feature);
-	DECL_CONV_STUB(literal_number);
-	DECL_CONV_STUB(int_literal);
-	DECL_CONV_STUB(integer_representation_item);
-	DECL_CONV_STUB(surface_curve);
-	DECL_CONV_STUB(intersection_curve);
-	DECL_CONV_STUB(interval_expression);
-	DECL_CONV_STUB(iso4217_currency);
-	DECL_CONV_STUB(known_source);
-	DECL_CONV_STUB(laid_defined_transformation);
-	DECL_CONV_STUB(language);
-	DECL_CONV_STUB(leader_curve);
-	DECL_CONV_STUB(leader_directed_callout);
-	DECL_CONV_STUB(leader_directed_dimension);
-	DECL_CONV_STUB(leader_terminator);
-	DECL_CONV_STUB(length_measure_with_unit);
-	DECL_CONV_STUB(length_unit);
-	DECL_CONV_STUB(light_source);
-	DECL_CONV_STUB(light_source_ambient);
-	DECL_CONV_STUB(light_source_directional);
-	DECL_CONV_STUB(light_source_positional);
-	DECL_CONV_STUB(light_source_spot);
-	DECL_CONV_STUB(line);
-	DECL_CONV_STUB(line_profile_tolerance);
-	DECL_CONV_STUB(linear_dimension);
-	DECL_CONV_STUB(simple_clause);
-	DECL_CONV_STUB(literal_conjunction);
-	DECL_CONV_STUB(literal_disjunction);
-	DECL_CONV_STUB(logical_literal);
-	DECL_CONV_STUB(logical_representation_item);
-	DECL_CONV_STUB(loop);
-	DECL_CONV_STUB(loss_tangent_measure_with_unit);
-	DECL_CONV_STUB(lot_effectivity);
-	DECL_CONV_STUB(luminous_flux_measure_with_unit);
-	DECL_CONV_STUB(luminous_flux_unit);
-	DECL_CONV_STUB(luminous_intensity_measure_with_unit);
-	DECL_CONV_STUB(luminous_intensity_unit);
-	DECL_CONV_STUB(magnetic_flux_density_measure_with_unit);
-	DECL_CONV_STUB(magnetic_flux_density_unit);
-	DECL_CONV_STUB(magnetic_flux_measure_with_unit);
-	DECL_CONV_STUB(magnetic_flux_unit);
-	DECL_CONV_STUB(make_from_usage_option);
-	DECL_CONV_STUB(manifold_subsurface_shape_representation);
-	DECL_CONV_STUB(manifold_surface_shape_representation);
-	DECL_CONV_STUB(mass_measure_with_unit);
-	DECL_CONV_STUB(mass_unit);
-	DECL_CONV_STUB(material_property);
-	DECL_CONV_STUB(property_definition_representation);
-	DECL_CONV_STUB(material_property_representation);
-	DECL_CONV_STUB(measure_representation_item);
-	DECL_CONV_STUB(product_context);
-	DECL_CONV_STUB(mechanical_context);
-	DECL_CONV_STUB(mechanical_design_and_draughting_relationship);
-	DECL_CONV_STUB(mechanical_design_geometric_presentation_area);
-	DECL_CONV_STUB(mechanical_design_geometric_presentation_representation);
-	DECL_CONV_STUB(mechanical_design_presentation_representation_with_draughting);
-	DECL_CONV_STUB(mechanical_design_shaded_presentation_area);
-	DECL_CONV_STUB(mechanical_design_shaded_presentation_representation);
-	DECL_CONV_STUB(min_and_major_ply_orientation_basis);
-	DECL_CONV_STUB(modified_geometric_tolerance);
-	DECL_CONV_STUB(modified_solid_with_placed_configuration);
-	DECL_CONV_STUB(moments_of_inertia_representation);
-	DECL_CONV_STUB(multi_language_attribute_assignment);
-	DECL_CONV_STUB(multiple_arity_boolean_expression);
-	DECL_CONV_STUB(multiple_arity_generic_expression);
-	DECL_CONV_STUB(multiple_arity_numeric_expression);
-	DECL_CONV_STUB(next_assembly_usage_occurrence);
-	DECL_CONV_STUB(non_manifold_surface_shape_representation);
-	DECL_CONV_STUB(null_representation_item);
-	DECL_CONV_STUB(numeric_expression);
-	DECL_CONV_STUB(offset_curve_2d);
-	DECL_CONV_STUB(offset_curve_3d);
-	DECL_CONV_STUB(offset_surface);
-	DECL_CONV_STUB(one_direction_repeat_factor);
-	DECL_CONV_STUB(open_shell);
-	DECL_CONV_STUB(ordinal_date);
-	DECL_CONV_STUB(projection_directed_callout);
-	DECL_CONV_STUB(ordinate_dimension);
-	DECL_CONV_STUB(organizational_address);
-	DECL_CONV_STUB(oriented_closed_shell);
-	DECL_CONV_STUB(oriented_edge);
-	DECL_CONV_STUB(oriented_face);
-	DECL_CONV_STUB(oriented_open_shell);
-	DECL_CONV_STUB(path);
-	DECL_CONV_STUB(oriented_path);
-	DECL_CONV_STUB(oriented_surface);
-	DECL_CONV_STUB(outer_boundary_curve);
-	DECL_CONV_STUB(package_product_concept_feature);
-	DECL_CONV_STUB(parabola);
-	DECL_CONV_STUB(parallel_offset);
-	DECL_CONV_STUB(parallelism_tolerance);
-	DECL_CONV_STUB(parametric_representation_context);
-	DECL_CONV_STUB(partial_document_with_structured_text_representation_assignment);
-	DECL_CONV_STUB(pcurve);
-	DECL_CONV_STUB(percentage_laminate_definition);
-	DECL_CONV_STUB(zone_structural_makeup);
-	DECL_CONV_STUB(percentage_laminate_table);
-	DECL_CONV_STUB(percentage_ply_definition);
-	DECL_CONV_STUB(perpendicular_to);
-	DECL_CONV_STUB(perpendicularity_tolerance);
-	DECL_CONV_STUB(person_and_organization_address);
-	DECL_CONV_STUB(personal_address);
-	DECL_CONV_STUB(physical_breakdown_context);
-	DECL_CONV_STUB(physical_element_usage);
-	DECL_CONV_STUB(presentation_view);
-	DECL_CONV_STUB(picture_representation);
-	DECL_CONV_STUB(placed_datum_target_feature);
-	DECL_CONV_STUB(placed_feature);
-	DECL_CONV_STUB(planar_extent);
-	DECL_CONV_STUB(planar_box);
-	DECL_CONV_STUB(plane);
-	DECL_CONV_STUB(plane_angle_measure_with_unit);
-	DECL_CONV_STUB(plane_angle_unit);
-	DECL_CONV_STUB(ply_laminate_definition);
-	DECL_CONV_STUB(ply_laminate_sequence_definition);
-	DECL_CONV_STUB(ply_laminate_table);
-	DECL_CONV_STUB(point_and_vector);
-	DECL_CONV_STUB(point_on_curve);
-	DECL_CONV_STUB(point_on_surface);
-	DECL_CONV_STUB(point_path);
-	DECL_CONV_STUB(point_replica);
-	DECL_CONV_STUB(point_style);
-	DECL_CONV_STUB(polar_complex_number_literal);
-	DECL_CONV_STUB(poly_loop);
-	DECL_CONV_STUB(polyline);
-	DECL_CONV_STUB(position_tolerance);
-	DECL_CONV_STUB(positioned_sketch);
-	DECL_CONV_STUB(power_measure_with_unit);
-	DECL_CONV_STUB(power_unit);
-	DECL_CONV_STUB(pre_defined_symbol);
-	DECL_CONV_STUB(pre_defined_dimension_symbol);
-	DECL_CONV_STUB(pre_defined_geometrical_tolerance_symbol);
-	DECL_CONV_STUB(pre_defined_marker);
-	DECL_CONV_STUB(pre_defined_point_marker_symbol);
-	DECL_CONV_STUB(pre_defined_surface_condition_symbol);
-	DECL_CONV_STUB(pre_defined_surface_side_style);
-	DECL_CONV_STUB(pre_defined_terminator_symbol);
-	DECL_CONV_STUB(pre_defined_tile);
-	DECL_CONV_STUB(predefined_picture_representation_item);
-	DECL_CONV_STUB(presentation_style_assignment);
-	DECL_CONV_STUB(presentation_style_by_context);
-	DECL_CONV_STUB(pressure_measure_with_unit);
-	DECL_CONV_STUB(pressure_unit);
-	DECL_CONV_STUB(procedural_representation);
-	DECL_CONV_STUB(procedural_representation_sequence);
-	DECL_CONV_STUB(procedural_shape_representation);
-	DECL_CONV_STUB(procedural_shape_representation_sequence);
-	DECL_CONV_STUB(product_category);
-	DECL_CONV_STUB(product_class);
-	DECL_CONV_STUB(product_concept_context);
-	DECL_CONV_STUB(product_concept_feature_category_usage);
-	DECL_CONV_STUB(product_definition_element_relationship);
-	DECL_CONV_STUB(product_definition_formation);
-	DECL_CONV_STUB(product_definition_formation_with_specified_source);
-	DECL_CONV_STUB(product_definition_group_assignment);
-	DECL_CONV_STUB(product_definition_shape);
-	DECL_CONV_STUB(product_definition_with_associated_documents);
-	DECL_CONV_STUB(product_identification);
-	DECL_CONV_STUB(product_material_composition_relationship);
-	DECL_CONV_STUB(product_related_product_category);
-	DECL_CONV_STUB(product_specification);
-	DECL_CONV_STUB(tolerance_zone_definition);
-	DECL_CONV_STUB(projected_zone_definition);
-	DECL_CONV_STUB(projection_curve);
-	DECL_CONV_STUB(promissory_usage_occurrence);
-	DECL_CONV_STUB(qualified_representation_item);
-	DECL_CONV_STUB(qualitative_uncertainty);
-	DECL_CONV_STUB(quantified_assembly_component_usage);
-	DECL_CONV_STUB(quasi_uniform_curve);
-	DECL_CONV_STUB(quasi_uniform_surface);
-	DECL_CONV_STUB(radioactivity_measure_with_unit);
-	DECL_CONV_STUB(radioactivity_unit);
-	DECL_CONV_STUB(radius_dimension);
-	DECL_CONV_STUB(range_characteristic);
-	DECL_CONV_STUB(ratio_unit);
-	DECL_CONV_STUB(rational_b_spline_curve);
-	DECL_CONV_STUB(rational_b_spline_surface);
-	DECL_CONV_STUB(rational_representation_item);
-	DECL_CONV_STUB(real_literal);
-	DECL_CONV_STUB(real_representation_item);
-	DECL_CONV_STUB(rectangular_composite_surface);
-	DECL_CONV_STUB(rectangular_trimmed_surface);
-	DECL_CONV_STUB(referenced_modified_datum);
-	DECL_CONV_STUB(relative_event_occurrence);
-	DECL_CONV_STUB(rep_item_group);
-	DECL_CONV_STUB(reparametrised_composite_curve_segment);
-	DECL_CONV_STUB(representation_relationship_with_transformation);
-	DECL_CONV_STUB(requirement_assigned_object);
-	DECL_CONV_STUB(requirement_assignment);
-	DECL_CONV_STUB(requirement_source);
-	DECL_CONV_STUB(requirement_view_definition_relationship);
-	DECL_CONV_STUB(resistance_measure_with_unit);
-	DECL_CONV_STUB(resistance_unit);
-	DECL_CONV_STUB(revolved_area_solid);
-	DECL_CONV_STUB(revolved_face_solid);
-	DECL_CONV_STUB(revolved_face_solid_with_trim_conditions);
-	DECL_CONV_STUB(right_angular_wedge);
-	DECL_CONV_STUB(right_circular_cone);
-	DECL_CONV_STUB(right_circular_cylinder);
-	DECL_CONV_STUB(right_to_usage_association);
-	DECL_CONV_STUB(roundness_tolerance);
-	DECL_CONV_STUB(row_representation_item);
-	DECL_CONV_STUB(row_value);
-	DECL_CONV_STUB(row_variable);
-	DECL_CONV_STUB(rule_action);
-	DECL_CONV_STUB(rule_condition);
-	DECL_CONV_STUB(rule_set);
-	DECL_CONV_STUB(rule_set_group);
-	DECL_CONV_STUB(rule_superseded_assignment);
-	DECL_CONV_STUB(rule_supersedence);
-	DECL_CONV_STUB(surface_curve_swept_area_solid);
-	DECL_CONV_STUB(ruled_surface_swept_area_solid);
-	DECL_CONV_STUB(runout_zone_definition);
-	DECL_CONV_STUB(runout_zone_orientation);
-	DECL_CONV_STUB(runout_zone_orientation_reference_direction);
-	DECL_CONV_STUB(satisfied_requirement);
-	DECL_CONV_STUB(satisfies_requirement);
-	DECL_CONV_STUB(satisfying_item);
-	DECL_CONV_STUB(scalar_variable);
-	DECL_CONV_STUB(scattering_parameter);
-	DECL_CONV_STUB(sculptured_solid);
-	DECL_CONV_STUB(seam_curve);
-	DECL_CONV_STUB(serial_numbered_effectivity);
-	DECL_CONV_STUB(shape_aspect_associativity);
-	DECL_CONV_STUB(shape_aspect_deriving_relationship);
-	DECL_CONV_STUB(shape_definition_representation);
-	DECL_CONV_STUB(shape_dimension_representation);
-	DECL_CONV_STUB(shape_feature_definition);
-	DECL_CONV_STUB(shape_representation_with_parameters);
-	DECL_CONV_STUB(shell_based_surface_model);
-	DECL_CONV_STUB(shell_based_wireframe_model);
-	DECL_CONV_STUB(shell_based_wireframe_shape_representation);
-	DECL_CONV_STUB(si_absorbed_dose_unit);
-	DECL_CONV_STUB(si_capacitance_unit);
-	DECL_CONV_STUB(si_conductance_unit);
-	DECL_CONV_STUB(si_dose_equivalent_unit);
-	DECL_CONV_STUB(si_electric_charge_unit);
-	DECL_CONV_STUB(si_electric_potential_unit);
-	DECL_CONV_STUB(si_energy_unit);
-	DECL_CONV_STUB(si_force_unit);
-	DECL_CONV_STUB(si_frequency_unit);
-	DECL_CONV_STUB(si_illuminance_unit);
-	DECL_CONV_STUB(si_inductance_unit);
-	DECL_CONV_STUB(si_magnetic_flux_density_unit);
-	DECL_CONV_STUB(si_magnetic_flux_unit);
-	DECL_CONV_STUB(si_power_unit);
-	DECL_CONV_STUB(si_pressure_unit);
-	DECL_CONV_STUB(si_radioactivity_unit);
-	DECL_CONV_STUB(si_resistance_unit);
-	DECL_CONV_STUB(si_unit);
-	DECL_CONV_STUB(simple_boolean_expression);
-	DECL_CONV_STUB(simple_numeric_expression);
-	DECL_CONV_STUB(slash_expression);
-	DECL_CONV_STUB(smeared_material_definition);
-	DECL_CONV_STUB(solid_angle_measure_with_unit);
-	DECL_CONV_STUB(solid_angle_unit);
-	DECL_CONV_STUB(solid_curve_font);
-	DECL_CONV_STUB(solid_replica);
-	DECL_CONV_STUB(solid_with_chamfered_edges);
-	DECL_CONV_STUB(solid_with_angle_based_chamfer);
-	DECL_CONV_STUB(solid_with_shape_element_pattern);
-	DECL_CONV_STUB(solid_with_circular_pattern);
-	DECL_CONV_STUB(solid_with_depression);
-	DECL_CONV_STUB(solid_with_pocket);
-	DECL_CONV_STUB(solid_with_circular_pocket);
-	DECL_CONV_STUB(solid_with_protrusion);
-	DECL_CONV_STUB(solid_with_circular_protrusion);
-	DECL_CONV_STUB(solid_with_hole);
-	DECL_CONV_STUB(solid_with_stepped_round_hole);
-	DECL_CONV_STUB(solid_with_conical_bottom_round_hole);
-	DECL_CONV_STUB(solid_with_constant_radius_edge_blend);
-	DECL_CONV_STUB(solid_with_slot);
-	DECL_CONV_STUB(solid_with_curved_slot);
-	DECL_CONV_STUB(solid_with_double_offset_chamfer);
-	DECL_CONV_STUB(solid_with_flat_bottom_round_hole);
-	DECL_CONV_STUB(solid_with_general_pocket);
-	DECL_CONV_STUB(solid_with_general_protrusion);
-	DECL_CONV_STUB(solid_with_groove);
-	DECL_CONV_STUB(solid_with_incomplete_circular_pattern);
-	DECL_CONV_STUB(solid_with_rectangular_pattern);
-	DECL_CONV_STUB(solid_with_incomplete_rectangular_pattern);
-	DECL_CONV_STUB(solid_with_rectangular_pocket);
-	DECL_CONV_STUB(solid_with_rectangular_protrusion);
-	DECL_CONV_STUB(solid_with_single_offset_chamfer);
-	DECL_CONV_STUB(solid_with_spherical_bottom_round_hole);
-	DECL_CONV_STUB(solid_with_stepped_round_hole_and_conical_transitions);
-	DECL_CONV_STUB(solid_with_straight_slot);
-	DECL_CONV_STUB(solid_with_tee_section_slot);
-	DECL_CONV_STUB(solid_with_through_depression);
-	DECL_CONV_STUB(solid_with_trapezoidal_section_slot);
-	DECL_CONV_STUB(solid_with_variable_radius_edge_blend);
-	DECL_CONV_STUB(source_for_requirement);
-	DECL_CONV_STUB(sourced_requirement);
-	DECL_CONV_STUB(specification_definition);
-	DECL_CONV_STUB(specified_higher_usage_occurrence);
-	DECL_CONV_STUB(sphere);
-	DECL_CONV_STUB(spherical_surface);
-	DECL_CONV_STUB(start_request);
-	DECL_CONV_STUB(start_work);
-	DECL_CONV_STUB(straightness_tolerance);
-	DECL_CONV_STUB(structured_dimension_callout);
-	DECL_CONV_STUB(structured_text_composition);
-	DECL_CONV_STUB(structured_text_representation);
-	DECL_CONV_STUB(subedge);
-	DECL_CONV_STUB(subface);
-	DECL_CONV_STUB(supplied_part_relationship);
-	DECL_CONV_STUB(surface_condition_callout);
-	DECL_CONV_STUB(swept_surface);
-	DECL_CONV_STUB(surface_of_linear_extrusion);
-	DECL_CONV_STUB(surface_of_revolution);
-	DECL_CONV_STUB(surface_patch);
-	DECL_CONV_STUB(surface_profile_tolerance);
-	DECL_CONV_STUB(surface_replica);
-	DECL_CONV_STUB(surface_side_style);
-	DECL_CONV_STUB(surface_style_boundary);
-	DECL_CONV_STUB(surface_style_control_grid);
-	DECL_CONV_STUB(surface_style_fill_area);
-	DECL_CONV_STUB(surface_style_parameter_line);
-	DECL_CONV_STUB(surface_style_reflectance_ambient);
-	DECL_CONV_STUB(surface_style_reflectance_ambient_diffuse);
-	DECL_CONV_STUB(surface_style_reflectance_ambient_diffuse_specular);
-	DECL_CONV_STUB(surface_style_rendering);
-	DECL_CONV_STUB(surface_style_rendering_with_properties);
-	DECL_CONV_STUB(surface_style_segmentation_curve);
-	DECL_CONV_STUB(surface_style_silhouette);
-	DECL_CONV_STUB(surface_style_usage);
-	DECL_CONV_STUB(surface_texture_representation);
-	DECL_CONV_STUB(surfaced_open_shell);
-	DECL_CONV_STUB(swept_disk_solid);
-	DECL_CONV_STUB(symbol);
-	DECL_CONV_STUB(symbol_representation_map);
-	DECL_CONV_STUB(symbol_style);
-	DECL_CONV_STUB(symbol_target);
-	DECL_CONV_STUB(symmetric_shape_aspect);
-	DECL_CONV_STUB(symmetry_tolerance);
-	DECL_CONV_STUB(table_representation_item);
-	DECL_CONV_STUB(tactile_appearance_representation);
-	DECL_CONV_STUB(tagged_text_format);
-	DECL_CONV_STUB(tagged_text_item);
-	DECL_CONV_STUB(tangent);
-	DECL_CONV_STUB(text_literal_with_associated_curves);
-	DECL_CONV_STUB(text_literal_with_blanking_box);
-	DECL_CONV_STUB(text_literal_with_extent);
-	DECL_CONV_STUB(text_string_representation);
-	DECL_CONV_STUB(text_style);
-	DECL_CONV_STUB(text_style_with_box_characteristics);
-	DECL_CONV_STUB(text_style_with_mirror);
-	DECL_CONV_STUB(text_style_with_spacing);
-	DECL_CONV_STUB(thermal_resistance_measure_with_unit);
-	DECL_CONV_STUB(thermal_resistance_unit);
-	DECL_CONV_STUB(thermodynamic_temperature_measure_with_unit);
-	DECL_CONV_STUB(thermodynamic_temperature_unit);
-	DECL_CONV_STUB(thickened_face_solid);
-	DECL_CONV_STUB(thickness_laminate_definition);
-	DECL_CONV_STUB(thickness_laminate_table);
-	DECL_CONV_STUB(time_interval);
-	DECL_CONV_STUB(time_interval_based_effectivity);
-	DECL_CONV_STUB(time_interval_with_bounds);
-	DECL_CONV_STUB(time_measure_with_unit);
-	DECL_CONV_STUB(time_unit);
-	DECL_CONV_STUB(tolerance_zone);
-	DECL_CONV_STUB(torus);
-	DECL_CONV_STUB(total_runout_tolerance);
-	DECL_CONV_STUB(track_blended_solid);
-	DECL_CONV_STUB(track_blended_solid_with_end_conditions);
-	DECL_CONV_STUB(trimmed_curve);
-	DECL_CONV_STUB(two_direction_repeat_factor);
-	DECL_CONV_STUB(unary_generic_expression);
-	DECL_CONV_STUB(unary_numeric_expression);
-	DECL_CONV_STUB(uncertainty_assigned_representation);
-	DECL_CONV_STUB(uncertainty_measure_with_unit);
-	DECL_CONV_STUB(uniform_curve);
-	DECL_CONV_STUB(uniform_resource_identifier);
-	DECL_CONV_STUB(uniform_surface);
-	DECL_CONV_STUB(usage_association);
-	DECL_CONV_STUB(user_defined_curve_font);
-	DECL_CONV_STUB(user_defined_marker);
-	DECL_CONV_STUB(user_defined_terminator_symbol);
-	DECL_CONV_STUB(user_selected_shape_elements);
-	DECL_CONV_STUB(value_range);
-	DECL_CONV_STUB(value_representation_item);
-	DECL_CONV_STUB(variable_semantics);
-	DECL_CONV_STUB(variational_representation_item);
-	DECL_CONV_STUB(vector);
-	DECL_CONV_STUB(vector_style);
-	DECL_CONV_STUB(velocity_measure_with_unit);
-	DECL_CONV_STUB(velocity_unit);
-	DECL_CONV_STUB(vertex);
-	DECL_CONV_STUB(vertex_loop);
-	DECL_CONV_STUB(vertex_point);
-	DECL_CONV_STUB(vertex_shell);
-	DECL_CONV_STUB(view_volume);
-	DECL_CONV_STUB(visual_appearance_representation);
-	DECL_CONV_STUB(volume_measure_with_unit);
-	DECL_CONV_STUB(volume_unit);
-	DECL_CONV_STUB(week_of_year_and_day_date);
-	DECL_CONV_STUB(wire_shell);
-	DECL_CONV_STUB(year_month);
-
-
-#undef DECL_CONV_STUB
-
-} //! STEP
-} //! Assimp
-
-#endif // INCLUDED_STEPFILE_READER_GEN_H
diff --git a/code/AssetLib/glTF/glTFAsset.h b/code/AssetLib/glTF/glTFAsset.h
index f24e35a16..4c7aaa908 100644
--- a/code/AssetLib/glTF/glTFAsset.h
+++ b/code/AssetLib/glTF/glTFAsset.h
@@ -1,4 +1,4 @@
-/*
+/*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
diff --git a/code/AssetLib/glTF/glTFExporter.cpp b/code/AssetLib/glTF/glTFExporter.cpp
index 57207e8c7..e6c14e7dd 100644
--- a/code/AssetLib/glTF/glTFExporter.cpp
+++ b/code/AssetLib/glTF/glTFExporter.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
diff --git a/code/AssetLib/glTF/glTFImporter.cpp b/code/AssetLib/glTF/glTFImporter.cpp
index 32ce8b227..7bf43b6ad 100644
--- a/code/AssetLib/glTF/glTFImporter.cpp
+++ b/code/AssetLib/glTF/glTFImporter.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
diff --git a/code/AssetLib/glTF2/glTF2Asset.h b/code/AssetLib/glTF2/glTF2Asset.h
index 48dab24a7..bfd4e4342 100644
--- a/code/AssetLib/glTF2/glTF2Asset.h
+++ b/code/AssetLib/glTF2/glTF2Asset.h
@@ -363,20 +363,44 @@ struct Object {
 // Classes for each glTF top-level object type
 //
 
+//! Base class for types that access binary data from a BufferView, such as accessors
+//! or sparse accessors' indices.
+//! N.B. not a virtual class. All owned pointers to BufferViewClient instances should
+//! be to their most derived types (which may of course be just BufferViewClient).
+struct BufferViewClient : public Object {
+    Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
+    size_t byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
+
+    inline uint8_t *GetPointer();
+
+    void Read(Value &obj, Asset &r);
+};
+
+//! BufferViewClient with component type information.
+//! N.B. not a virtual class. All owned pointers to ComponentTypedBufferViewClient
+//! instances should be to their most derived types (which may of course be just
+//! ComponentTypedBufferViewClient).
+struct ComponentTypedBufferViewClient : public BufferViewClient {
+    ComponentType componentType; //!< The datatype of components in the attribute. (required)
+
+    unsigned int GetBytesPerComponent();
+
+    void Read(Value &obj, Asset &r);
+};
+
 //! A typed view into a BufferView. A BufferView contains raw binary data.
 //! An accessor provides a typed view into a BufferView or a subset of a BufferView
 //! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
-struct Accessor : public Object {
-    Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
-    size_t byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
-    ComponentType componentType; //!< The datatype of components in the attribute. (required)
+struct Accessor : public ComponentTypedBufferViewClient {
+    struct Sparse;
+
     size_t count; //!< The number of attributes referenced by this accessor. (required)
     AttribType::Value type; //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
     std::vector<double> max; //!< Maximum value of each component in this attribute.
     std::vector<double> min; //!< Minimum value of each component in this attribute.
+    std::unique_ptr<Sparse> sparse; //!< Sparse accessor information
 
     unsigned int GetNumComponents();
-    unsigned int GetBytesPerComponent();
     unsigned int GetElementSize();
 
     inline uint8_t *GetPointer();
@@ -417,11 +441,61 @@ struct Accessor : public Object {
         }
     };
 
+    //! Sparse accessor information
+    struct Sparse {
+        size_t count;
+        ComponentTypedBufferViewClient indices;
+        BufferViewClient values;
+
+        std::vector<uint8_t> data; //!< Actual data, which may be defaulted to an array of zeros or the original data, with the sparse buffer view applied on top of it.
+
+        inline void PopulateData(size_t numBytes, uint8_t *bytes) {
+            if (bytes) {
+                data.assign(bytes, bytes + numBytes);
+            } else {
+                data.resize(numBytes, 0x00);
+            }
+        }
+
+        inline void PatchData(unsigned int elementSize)
+        {
+            uint8_t *pIndices = indices.GetPointer();
+            const unsigned int indexSize = indices.GetBytesPerComponent();
+            uint8_t *indicesEnd = pIndices + count * indexSize;
+
+            uint8_t *pValues = values.GetPointer();
+            while (pIndices != indicesEnd) {
+                size_t offset;
+                switch (indices.componentType) {
+                case ComponentType_UNSIGNED_BYTE:
+                    offset = *pIndices;
+                    break;
+                case ComponentType_UNSIGNED_SHORT:
+                    offset = *reinterpret_cast<uint16_t *>(pIndices);
+                    break;
+                case ComponentType_UNSIGNED_INT:
+                    offset = *reinterpret_cast<uint32_t *>(pIndices);
+                    break;
+                default:
+                    // have fun with float and negative values from signed types as indices.
+                    throw DeadlyImportError("Unsupported component type in index.");
+                }
+
+                offset *= elementSize;
+                std::memcpy(data.data() + offset, pValues, elementSize);
+
+                pValues += elementSize;
+                pIndices += indexSize;
+            }
+        }
+    };
+
     inline Indexer GetIndexer() {
         return Indexer(*this);
     }
 
     Accessor() {}
+
     void Read(Value &obj, Asset &r);
 };
 
diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index 0c99d059b..5e1cc42d6 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -551,36 +551,10 @@ inline void BufferView::Read(Value &obj, Asset &r) {
 }
 
 //
-// struct Accessor
+// struct BufferViewClient
 //
 
-inline void Accessor::Read(Value &obj, Asset &r) {
-
-    if (Value *bufferViewVal = FindUInt(obj, "bufferView")) {
-        bufferView = r.bufferViews.Retrieve(bufferViewVal->GetUint());
-    }
-
-    byteOffset = MemberOrDefault(obj, "byteOffset", size_t(0));
-    componentType = MemberOrDefault(obj, "componentType", ComponentType_BYTE);
-    count = MemberOrDefault(obj, "count", size_t(0));
-
-    const char *typestr;
-    type = ReadMember(obj, "type", typestr) ? AttribType::FromString(typestr) : AttribType::SCALAR;
-}
-
-inline unsigned int Accessor::GetNumComponents() {
-    return AttribType::GetNumComponents(type);
-}
-
-inline unsigned int Accessor::GetBytesPerComponent() {
-    return int(ComponentTypeSize(componentType));
-}
-
-inline unsigned int Accessor::GetElementSize() {
-    return GetNumComponents() * GetBytesPerComponent();
-}
-
-inline uint8_t *Accessor::GetPointer() {
+inline uint8_t *BufferViewClient::GetPointer() {
     if (!bufferView || !bufferView->buffer) return 0;
     uint8_t *basePtr = bufferView->buffer->GetPointer();
     if (!basePtr) return 0;
@@ -599,6 +573,76 @@ inline uint8_t *Accessor::GetPointer() {
     return basePtr + offset;
 }
 
+inline void BufferViewClient::Read(Value &obj, Asset &r) {
+
+    if (Value *bufferViewVal = FindUInt(obj, "bufferView")) {
+        bufferView = r.bufferViews.Retrieve(bufferViewVal->GetUint());
+    }
+
+    byteOffset = MemberOrDefault(obj, "byteOffset", size_t(0));
+}
+
+//
+// struct ComponentTypedBufferViewClient
+//
+
+inline unsigned int ComponentTypedBufferViewClient::GetBytesPerComponent() {
+    return int(ComponentTypeSize(componentType));
+}
+
+inline void ComponentTypedBufferViewClient::Read(Value &obj, Asset &r) {
+
+    BufferViewClient::Read(obj, r);
+
+    componentType = MemberOrDefault(obj, "componentType", ComponentType_BYTE);
+}
+
+//
+// struct Accessor
+//
+
+inline uint8_t *Accessor::GetPointer() {
+    if (!sparse) return BufferViewClient::GetPointer();
+
+    return sparse->data.data();
+}
+
+inline void Accessor::Read(Value &obj, Asset &r) {
+
+    ComponentTypedBufferViewClient::Read(obj, r);
+
+    count = MemberOrDefault(obj, "count", size_t(0));
+
+    const char *typestr;
+    type = ReadMember(obj, "type", typestr) ? AttribType::FromString(typestr) : AttribType::SCALAR;
+
+    if (Value *sparseValue = FindObject(obj, "sparse")) {
+        sparse.reset(new Sparse);
+        ReadMember(*sparseValue, "count", sparse->count);
+
+        if (Value *indicesValue = FindObject(*sparseValue, "indices")) {
+            sparse->indices.Read(*indicesValue, r);
+        }
+
+        if (Value *valuesValue = FindObject(*sparseValue, "values")) {
+            sparse->values.Read(*valuesValue, r);
+        }
+
+        const unsigned int elementSize = GetElementSize();
+        const size_t dataSize = count * elementSize;
+        sparse->PopulateData(dataSize, BufferViewClient::GetPointer());
+        sparse->PatchData(elementSize);
+    }
+}
+
+inline unsigned int Accessor::GetNumComponents() {
+    return AttribType::GetNumComponents(type);
+}
+
+inline unsigned int Accessor::GetElementSize() {
+    return GetNumComponents() * GetBytesPerComponent();
+}
+
 namespace {
 inline void CopyData(size_t count,
         const uint8_t *src, size_t src_stride,
@@ -635,7 +679,7 @@ void Accessor::ExtractData(T *&outData)
     const size_t targetElemSize = sizeof(T);
     ai_assert(elemSize <= targetElemSize);
 
-    ai_assert(count * stride <= bufferView->byteLength);
+    ai_assert(count * stride <= (bufferView ? bufferView->byteLength : sparse->data.size()));
 
     outData = new T[count];
     if (stride == elemSize && targetElemSize == elemSize) {
@@ -1002,7 +1046,7 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                         // Valid attribute semantics include POSITION, NORMAL, TANGENT
                         int undPos = 0;
                         Mesh::AccessorList *vec = 0;
-                        if (GetAttribTargetVector(prim, i, attr, vec, undPos)) {
+                        if (GetAttribTargetVector(prim, j, attr, vec, undPos)) {
                             size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
                             if ((*vec).size() <= idx) {
                                 (*vec).resize(idx + 1);
@@ -1067,10 +1111,10 @@ inline void Camera::Read(Value &obj, Asset & /*r*/) {
         cameraProperties.perspective.zfar = MemberOrDefault(*it, "zfar", 100.f);
         cameraProperties.perspective.znear = MemberOrDefault(*it, "znear", 0.01f);
     } else {
-        cameraProperties.ortographic.xmag = MemberOrDefault(obj, "xmag", 1.f);
-        cameraProperties.ortographic.ymag = MemberOrDefault(obj, "ymag", 1.f);
-        cameraProperties.ortographic.zfar = MemberOrDefault(obj, "zfar", 100.f);
-        cameraProperties.ortographic.znear = MemberOrDefault(obj, "znear", 0.01f);
+        cameraProperties.ortographic.xmag = MemberOrDefault(*it, "xmag", 1.f);
+        cameraProperties.ortographic.ymag = MemberOrDefault(*it, "ymag", 1.f);
+        cameraProperties.ortographic.zfar = MemberOrDefault(*it, "zfar", 100.f);
+        cameraProperties.ortographic.znear = MemberOrDefault(*it, "znear", 0.01f);
     }
 }
 
diff --git a/code/AssetLib/glTF2/glTF2Exporter.cpp b/code/AssetLib/glTF2/glTF2Exporter.cpp
index a6128b032..da6d9ab2e 100644
--- a/code/AssetLib/glTF2/glTF2Exporter.cpp
+++ b/code/AssetLib/glTF2/glTF2Exporter.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
diff --git a/code/CApi/CInterfaceIOWrapper.cpp b/code/CApi/CInterfaceIOWrapper.cpp
index 91dd07f37..9d8b79c5d 100644
--- a/code/CApi/CInterfaceIOWrapper.cpp
+++ b/code/CApi/CInterfaceIOWrapper.cpp
@@ -45,10 +45,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "CInterfaceIOWrapper.h"
 
-namespace Assimp    {
+namespace Assimp {
 
-CIOStreamWrapper::~CIOStreamWrapper(void)
-{
+CIOStreamWrapper::~CIOStreamWrapper(void) {
     /* Various places depend on this destructor to close the file */
     if (mFile) {
         mIO->mFileSystem->CloseProc(mIO->mFileSystem, mFile);
@@ -57,28 +56,25 @@ CIOStreamWrapper::~CIOStreamWrapper(void)
 }
 
 // ...................................................................
-size_t CIOStreamWrapper::Read(void* pvBuffer,
-    size_t pSize,
-    size_t pCount
-){
+size_t CIOStreamWrapper::Read(void *pvBuffer,
+        size_t pSize,
+        size_t pCount) {
     // need to typecast here as C has no void*
-    return mFile->ReadProc(mFile,(char*)pvBuffer,pSize,pCount);
+    return mFile->ReadProc(mFile, (char *)pvBuffer, pSize, pCount);
 }
 
 // ...................................................................
-size_t CIOStreamWrapper::Write(const void* pvBuffer,
-    size_t pSize,
-    size_t pCount
-){
+size_t CIOStreamWrapper::Write(const void *pvBuffer,
+        size_t pSize,
+        size_t pCount) {
     // need to typecast here as C has no void*
-    return mFile->WriteProc(mFile,(const char*)pvBuffer,pSize,pCount);
+    return mFile->WriteProc(mFile, (const char *)pvBuffer, pSize, pCount);
 }
 
 // ...................................................................
 aiReturn CIOStreamWrapper::Seek(size_t pOffset,
-    aiOrigin pOrigin
-){
-    return mFile->SeekProc(mFile,pOffset,pOrigin);
+        aiOrigin pOrigin) {
+    return mFile->SeekProc(mFile, pOffset, pOrigin);
 }
 
 // ...................................................................
@@ -92,16 +88,16 @@ size_t CIOStreamWrapper::FileSize() const {
 }
 
 // ...................................................................
-void CIOStreamWrapper::Flush () {
+void CIOStreamWrapper::Flush() {
     return mFile->FlushProc(mFile);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Custom IOStream implementation for the C-API
-bool CIOSystemWrapper::Exists( const char* pFile) const {
-    aiFile* p = mFileSystem->OpenProc(mFileSystem,pFile,"rb");
-    if (p){
-        mFileSystem->CloseProc(mFileSystem,p);
+bool CIOSystemWrapper::Exists(const char *pFile) const {
+    aiFile *p = mFileSystem->OpenProc(mFileSystem, pFile, "rb");
+    if (p) {
+        mFileSystem->CloseProc(mFileSystem, p);
         return true;
     }
     return false;
@@ -117,8 +113,8 @@ char CIOSystemWrapper::getOsSeparator() const {
 }
 
 // ...................................................................
-IOStream* CIOSystemWrapper::Open(const char* pFile,const char* pMode) {
-    aiFile* p = mFileSystem->OpenProc(mFileSystem,pFile,pMode);
+IOStream *CIOSystemWrapper::Open(const char *pFile, const char *pMode) {
+    aiFile *p = mFileSystem->OpenProc(mFileSystem, pFile, pMode);
     if (!p) {
         return NULL;
     }
@@ -126,11 +122,11 @@ IOStream* CIOSystemWrapper::Open(const char* pFile,const char* pMode) {
 }
 
 // ...................................................................
-void CIOSystemWrapper::Close( IOStream* pFile) {
+void CIOSystemWrapper::Close(IOStream *pFile) {
     if (!pFile) {
         return;
     }
     delete pFile;
 }
 
-}
+} // namespace Assimp
diff --git a/code/CApi/CInterfaceIOWrapper.h b/code/CApi/CInterfaceIOWrapper.h
index 298847494..c899840fc 100644
--- a/code/CApi/CInterfaceIOWrapper.h
+++ b/code/CApi/CInterfaceIOWrapper.h
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -50,50 +48,47 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 
-namespace Assimp    {
+namespace Assimp {
 
 class CIOSystemWrapper;
 
 // ------------------------------------------------------------------------------------------------
 // Custom IOStream implementation for the C-API
-class CIOStreamWrapper : public IOStream
-{
+class CIOStreamWrapper : public IOStream {
 public:
-    explicit CIOStreamWrapper(aiFile* pFile, CIOSystemWrapper* io)
-        : mFile(pFile),
-        mIO(io)
-    {}
+    explicit CIOStreamWrapper(aiFile *pFile, CIOSystemWrapper *io) :
+            mFile(pFile),
+            mIO(io) {}
     ~CIOStreamWrapper(void);
 
-    size_t Read(void* pvBuffer, size_t pSize, size_t pCount);
-    size_t Write(const void* pvBuffer, size_t pSize, size_t pCount);
+    size_t Read(void *pvBuffer, size_t pSize, size_t pCount);
+    size_t Write(const void *pvBuffer, size_t pSize, size_t pCount);
     aiReturn Seek(size_t pOffset, aiOrigin pOrigin);
     size_t Tell(void) const;
     size_t FileSize() const;
     void Flush();
 
 private:
-    aiFile* mFile;
-    CIOSystemWrapper* mIO;
+    aiFile *mFile;
+    CIOSystemWrapper *mIO;
 };
 
-class CIOSystemWrapper : public IOSystem
-{
+class CIOSystemWrapper : public IOSystem {
     friend class CIOStreamWrapper;
-public:
-    explicit CIOSystemWrapper(aiFileIO* pFile)
-        : mFileSystem(pFile)
-    {}
 
-    bool Exists( const char* pFile) const;
+public:
+    explicit CIOSystemWrapper(aiFileIO *pFile) :
+            mFileSystem(pFile) {}
+
+    bool Exists(const char *pFile) const;
     char getOsSeparator() const;
-    IOStream* Open(const char* pFile,const char* pMode = "rb");
-    void Close( IOStream* pFile);
+    IOStream *Open(const char *pFile, const char *pMode = "rb");
+    void Close(IOStream *pFile);
+
 private:
-    aiFileIO* mFileSystem;
+    aiFileIO *mFileSystem;
 };
 
-}
+} // namespace Assimp
 
 #endif
-
diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt
index 42d079cbf..000ebad6c 100644
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1233,7 +1233,7 @@ if (APPLE)
     # add ./Compiler/*.h to assimp.framework via copy command
     ADD_CUSTOM_COMMAND(TARGET assimp POST_BUILD
       COMMAND "${CMAKE_COMMAND}" -E copy_directory
-         "../${HEADER_PATH}/Compiler"
+         "${HEADER_PATH}/Compiler"
          assimp.framework/Headers/Compiler
       COMMENT "Copying public ./Compiler/ header files to framework bundle's Headers/Compiler/")
   ENDIF()
diff --git a/code/Collada/ColladaExporter.cpp b/code/Collada/ColladaExporter.cpp
new file mode 100644
index 000000000..05df6fc94
--- /dev/null
+++ b/code/Collada/ColladaExporter.cpp
@@ -0,0 +1,1704 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
+
+#include "ColladaExporter.h"
+#include <assimp/Bitmap.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/fast_atof.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XMLTools.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/scene.h>
+
+#include <assimp/Exceptional.h>
+
+#include <memory>
+#include <ctime>
+#include <set>
+#include <vector>
+#include <iostream>
+
+using namespace Assimp;
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
+void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
+    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
+    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
+
+    // invoke the exporter
+    ColladaExporter iDoTheExportThing( pScene, pIOSystem, path, file);
+    
+    if (iDoTheExportThing.mOutput.fail()) {
+        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
+    }
+
+    // we're still here - export successfully completed. Write result to the given IOSYstem
+    std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+    if(outfile == NULL) {
+        throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
+    }
+
+    // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
+    outfile->Write( iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()),1);
+}
+
+} // end of namespace Assimp
+
+// ------------------------------------------------------------------------------------------------
+// Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
+static const std::string XMLIDEncode(const std::string& name) {
+    const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
+    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
+
+    if (name.length() == 0) {
+        return name;
+    }
+
+    std::stringstream idEncoded;
+
+    // xsd:ID must start with letter or underscore
+    if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) {
+        idEncoded << '_';
+    }
+
+    for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) {
+        // xsd:ID can only contain letters, digits, underscores, hyphens and periods
+        if (strchr(XML_ID_CHARS, *it) != nullptr) {
+            idEncoded << *it;
+        } else {
+            // Select placeholder character based on invalid character to prevent name collisions 
+            idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT];
+        }
+    }
+
+    return idEncoded.str();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor for a specific scene to export
+ColladaExporter::ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file) 
+: mIOSystem(pIOSystem)
+, mPath(path)
+, mFile(file) {
+    // make sure that all formatting happens using the standard, C locale and not the user's current locale
+    mOutput.imbue( std::locale("C") );
+    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+
+    mScene = pScene;
+    mSceneOwned = false;
+
+    // set up strings
+    endstr = "\n";
+
+    // start writing the file
+    WriteFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor
+ColladaExporter::~ColladaExporter() {
+    if ( mSceneOwned ) {
+        delete mScene;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Starts writing the contents
+void ColladaExporter::WriteFile() {
+    // write the DTD
+    mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
+    // COLLADA element start
+    mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
+    PushTag();
+
+    WriteTextures();
+    WriteHeader();
+
+    WriteCamerasLibrary();
+    WriteLightsLibrary();
+    WriteMaterials();
+    WriteGeometryLibrary();
+    WriteControllerLibrary();
+
+    WriteSceneLibrary();
+	
+	// customized, Writes the animation library
+	WriteAnimationsLibrary();
+
+    // useless Collada fu at the end, just in case we haven't had enough indirections, yet.
+    mOutput << startstr << "<scene>" << endstr;
+    PushTag();
+    mOutput << startstr << "<instance_visual_scene url=\"#" + XMLIDEncode(mScene->mRootNode->mName.C_Str()) + "\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</scene>" << endstr;
+    PopTag();
+    mOutput << "</COLLADA>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the asset header
+void ColladaExporter::WriteHeader() {
+    static const ai_real epsilon = Math::getEpsilon<ai_real>();
+    static const aiQuaternion x_rot(aiMatrix3x3(
+        0, -1,  0,
+        1,  0,  0,
+        0,  0,  1));
+    static const aiQuaternion y_rot(aiMatrix3x3(
+        1,  0,  0,
+        0,  1,  0,
+        0,  0,  1));
+    static const aiQuaternion z_rot(aiMatrix3x3(
+        1,  0,  0,
+        0,  0,  1,
+        0, -1,  0));
+
+    static const unsigned int date_nb_chars = 20;
+    char date_str[date_nb_chars];
+    std::time_t date = std::time(NULL);
+    std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
+
+    aiVector3D scaling;
+    aiQuaternion rotation;
+    aiVector3D position;
+    mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
+    rotation.Normalize();
+
+    bool add_root_node = false;
+
+    ai_real scale = 1.0;
+    if(std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
+        scale = (ai_real) ((((double) scaling.x) + ((double) scaling.y) + ((double) scaling.z)) / 3.0);
+    } else {
+        add_root_node = true;
+    }
+
+    std::string up_axis = "Y_UP";
+    if(rotation.Equal(x_rot, epsilon)) {
+        up_axis = "X_UP";
+    } else if(rotation.Equal(y_rot, epsilon)) {
+        up_axis = "Y_UP";
+    } else if(rotation.Equal(z_rot, epsilon)) {
+        up_axis = "Z_UP";
+    } else {
+        add_root_node = true;
+    }
+
+    if(! position.Equal(aiVector3D(0, 0, 0))) {
+        add_root_node = true;
+    }
+
+    if(mScene->mRootNode->mNumChildren == 0) {
+        add_root_node = true;
+    }
+
+    if(add_root_node) {
+        aiScene* scene;
+        SceneCombiner::CopyScene(&scene, mScene);
+
+        aiNode* root = new aiNode("Scene");
+
+        root->mNumChildren = 1;
+        root->mChildren = new aiNode*[root->mNumChildren];
+
+        root->mChildren[0] = scene->mRootNode;
+        scene->mRootNode->mParent = root;
+        scene->mRootNode = root;
+
+        mScene = scene;
+        mSceneOwned = true;
+
+        up_axis = "Y_UP";
+        scale = 1.0;
+    }
+
+    mOutput << startstr << "<asset>" << endstr;
+    PushTag();
+    mOutput << startstr << "<contributor>" << endstr;
+    PushTag();
+
+    // If no Scene metadata, use root node metadata
+    aiMetadata* meta = mScene->mMetaData;
+    if (nullptr == meta) {
+        meta = mScene->mRootNode->mMetaData;
+    }
+
+    aiString value;
+    if (!meta || !meta->Get("Author", value)) {
+        mOutput << startstr << "<author>" << "Assimp" << "</author>" << endstr;
+    } else {
+        mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
+    }
+
+    if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
+        mOutput << startstr << "<authoring_tool>" << "Assimp Exporter" << "</authoring_tool>" << endstr;
+    } else {
+        mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
+    }
+
+    if (meta) {
+        if (meta->Get("Comments", value)) {
+            mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
+        }
+        if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
+            mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
+        }
+        if (meta->Get("SourceData", value)) {
+            mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</contributor>" << endstr;
+
+    if (nullptr == meta || !meta->Get("Created", value)) {
+        mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
+    } else {
+        mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
+    }
+
+    // Modified date is always the date saved
+    mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
+
+    if (meta) {
+        if (meta->Get("Keywords", value)) {
+            mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
+        }
+        if (meta->Get("Revision", value)) {
+            mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
+        }
+        if (meta->Get("Subject", value)) {
+            mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
+        }
+        if (meta->Get("Title", value)) {
+            mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
+        }
+    }
+
+    mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
+    mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
+    PopTag();
+    mOutput << startstr << "</asset>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteTextures() {
+    static const unsigned int buffer_size = 1024;
+    char str[buffer_size];
+
+    if (mScene->HasTextures()) {
+        for(unsigned int i = 0; i < mScene->mNumTextures; i++) {
+            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
+            // so we just write the textures in the current directory.
+
+            aiTexture* texture = mScene->mTextures[i];
+            if ( nullptr == texture ) {
+                continue;
+            }
+
+            ASSIMP_itoa10(str, buffer_size, i + 1);
+
+            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char*) texture->achFormatHint);
+
+            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
+            if(outfile == NULL) {
+                throw DeadlyExportError("could not open output texture file: " + mPath + name);
+            }
+
+            if(texture->mHeight == 0) {
+                outfile->Write((void*) texture->pcData, texture->mWidth, 1);
+            } else {
+                Bitmap::Save(texture, outfile.get());
+            }
+
+            outfile->Flush();
+
+            textures.insert(std::make_pair(i, name));
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteCamerasLibrary() {
+    if(mScene->HasCameras()) {
+
+        mOutput << startstr << "<library_cameras>" << endstr;
+        PushTag();
+
+        for( size_t a = 0; a < mScene->mNumCameras; ++a)
+            WriteCamera( a);
+
+        PopTag();
+        mOutput << startstr << "</library_cameras>" << endstr;
+
+    }
+}
+
+void ColladaExporter::WriteCamera(size_t pIndex){
+
+    const aiCamera *cam = mScene->mCameras[pIndex];
+    const std::string cameraName = XMLEscape(cam->mName.C_Str());
+    const std::string cameraId = XMLIDEncode(cam->mName.C_Str());
+
+    mOutput << startstr << "<camera id=\"" << cameraId << "-camera\" name=\"" << cameraName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<optics>" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    //assimp doesn't support the import of orthographic cameras! se we write
+    //always perspective
+    mOutput << startstr << "<perspective>" << endstr;
+    PushTag();
+    mOutput << startstr << "<xfov sid=\"xfov\">"<<
+                                AI_RAD_TO_DEG(cam->mHorizontalFOV)
+                        <<"</xfov>" << endstr;
+    mOutput << startstr << "<aspect_ratio>"
+                        <<      cam->mAspect
+                        << "</aspect_ratio>" << endstr;
+    mOutput << startstr << "<znear sid=\"znear\">"
+                        <<      cam->mClipPlaneNear
+                        <<  "</znear>" << endstr;
+    mOutput << startstr << "<zfar sid=\"zfar\">"
+                        <<      cam->mClipPlaneFar
+                        << "</zfar>" << endstr;
+    PopTag();
+    mOutput << startstr << "</perspective>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</optics>" << endstr;
+    PopTag();
+    mOutput << startstr << "</camera>" << endstr;
+
+}
+
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteLightsLibrary() {
+    if(mScene->HasLights()) {
+
+        mOutput << startstr << "<library_lights>" << endstr;
+        PushTag();
+
+        for( size_t a = 0; a < mScene->mNumLights; ++a)
+            WriteLight( a);
+
+        PopTag();
+        mOutput << startstr << "</library_lights>" << endstr;
+
+    }
+}
+
+void ColladaExporter::WriteLight(size_t pIndex){
+
+    const aiLight *light = mScene->mLights[pIndex];
+    const std::string lightName = XMLEscape(light->mName.C_Str());
+    const std::string lightId = XMLIDEncode(light->mName.C_Str());
+
+    mOutput << startstr << "<light id=\"" << lightId << "-light\" name=\""
+            << lightName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    switch(light->mType){
+        case aiLightSource_AMBIENT:
+            WriteAmbienttLight(light);
+            break;
+        case aiLightSource_DIRECTIONAL:
+            WriteDirectionalLight(light);
+            break;
+        case aiLightSource_POINT:
+            WritePointLight(light);
+            break;
+        case aiLightSource_SPOT:
+            WriteSpotLight(light);
+            break;
+        case aiLightSource_AREA:
+        case aiLightSource_UNDEFINED:
+        case _aiLightSource_Force32Bit:
+            break;
+    }
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</light>" << endstr;
+
+}
+
+void ColladaExporter::WritePointLight(const aiLight *const light){
+    const aiColor3D &color=  light->mColorDiffuse;
+    mOutput << startstr << "<point>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+                            << color.r<<" "<<color.g<<" "<<color.b
+                        <<"</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+                            << light->mAttenuationConstant
+                        <<"</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+                            << light->mAttenuationLinear
+                        <<"</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+                            << light->mAttenuationQuadratic
+                        <<"</quadratic_attenuation>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</point>" << endstr;
+
+}
+
+void ColladaExporter::WriteDirectionalLight(const aiLight *const light){
+    const aiColor3D &color=  light->mColorDiffuse;
+    mOutput << startstr << "<directional>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+                            << color.r<<" "<<color.g<<" "<<color.b
+                        <<"</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</directional>" << endstr;
+
+}
+
+void ColladaExporter::WriteSpotLight(const aiLight *const light){
+
+    const aiColor3D &color=  light->mColorDiffuse;
+    mOutput << startstr << "<spot>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+                            << color.r<<" "<<color.g<<" "<<color.b
+                        <<"</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+                                << light->mAttenuationConstant
+                            <<"</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+                            << light->mAttenuationLinear
+                        <<"</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+                            << light->mAttenuationQuadratic
+                        <<"</quadratic_attenuation>" << endstr;
+
+    const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
+    mOutput << startstr <<"<falloff_angle sid=\"fall_off_angle\">"
+                                << fallOffAngle
+                        <<"</falloff_angle>" << endstr;
+    double temp = light->mAngleOuterCone-light->mAngleInnerCone;
+
+    temp = std::cos(temp);
+    temp = std::log(temp)/std::log(0.1);
+    temp = 1/temp;
+    mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
+                            << temp
+                        <<"</falloff_exponent>" << endstr;
+
+
+    PopTag();
+    mOutput << startstr << "</spot>" << endstr;
+
+}
+
+void ColladaExporter::WriteAmbienttLight(const aiLight *const light){
+
+    const aiColor3D &color=  light->mColorAmbient;
+    mOutput << startstr << "<ambient>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+                            << color.r<<" "<<color.g<<" "<<color.b
+                        <<"</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</ambient>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single surface entry from the given material keys
+void ColladaExporter::ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, 
+                                          aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex) {
+  if( pSrcMat->GetTextureCount( pTexture) > 0 ) {
+    aiString texfile;
+    unsigned int uvChannel = 0;
+    pSrcMat->GetTexture( pTexture, 0, &texfile, NULL, &uvChannel);
+
+    std::string index_str(texfile.C_Str());
+
+    if(index_str.size() != 0 && index_str[0] == '*') {
+        unsigned int index;
+
+        index_str = index_str.substr(1, std::string::npos);
+
+        try {
+            index = (unsigned int) strtoul10_64(index_str.c_str());
+        } catch(std::exception& error) {
+            throw DeadlyExportError(error.what());
+        }
+
+        std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
+
+        if(name != textures.end()) {
+            poSurface.texture = name->second;
+        } else {
+            throw DeadlyExportError("could not find embedded texture at index " + index_str);
+        }
+    } else {
+        poSurface.texture = texfile.C_Str();
+    }
+
+    poSurface.channel = uvChannel;
+    poSurface.exist = true;
+  } else {
+    if( pKey )
+      poSurface.exist = pSrcMat->Get( pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
+  }
+}
+
+static bool isalnum_C(char c) {
+  return ( nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",c) );
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes an image entry for the given surface
+void ColladaExporter::WriteImageEntry( const Surface& pSurface, const std::string& pNameAdd) {
+  if( !pSurface.texture.empty() )
+  {
+    mOutput << startstr << "<image id=\"" << XMLIDEncode(pNameAdd) << "\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<init_from>";
+
+    // URL encode image file name first, then XML encode on top
+    std::stringstream imageUrlEncoded;
+    for( std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it )
+    {
+      if( isalnum_C( (unsigned char) *it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\' )
+        imageUrlEncoded << *it;
+      else
+        imageUrlEncoded << '%' << std::hex << size_t( (unsigned char) *it) << std::dec;
+    }
+    mOutput << XMLEscape(imageUrlEncoded.str());
+    mOutput << "</init_from>" << endstr;
+    PopTag();
+    mOutput << startstr << "</image>" << endstr;
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a color-or-texture entry into an effect definition
+void ColladaExporter::WriteTextureColorEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pImageName)
+{
+  if(pSurface.exist) {
+    mOutput << startstr << "<" << pTypeName << ">" << endstr;
+    PushTag();
+    if( pSurface.texture.empty() )
+    {
+      mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
+    }
+    else
+    {
+      mOutput << startstr << "<texture texture=\"" << XMLIDEncode(pImageName) << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+    }
+    PopTag();
+    mOutput << startstr << "</" << pTypeName << ">" << endstr;
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the two parameters necessary for referencing a texture in an effect entry
+void ColladaExporter::WriteTextureParamEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pMatName)
+{
+  // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
+  if( !pSurface.texture.empty() )
+  {
+    mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<surface type=\"2D\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<init_from>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-image</init_from>" << endstr;
+    PopTag();
+    mOutput << startstr << "</surface>" << endstr;
+    PopTag();
+    mOutput << startstr << "</newparam>" << endstr;
+
+    mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-sampler\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<sampler2D>" << endstr;
+    PushTag();
+    mOutput << startstr << "<source>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface</source>" << endstr;
+    PopTag();
+    mOutput << startstr << "</sampler2D>" << endstr;
+    PopTag();
+    mOutput << startstr << "</newparam>" << endstr;
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a scalar property
+void ColladaExporter::WriteFloatEntry( const Property& pProperty, const std::string& pTypeName)
+{
+    if(pProperty.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the material setup
+void ColladaExporter::WriteMaterials()
+{
+  materials.resize( mScene->mNumMaterials);
+
+  /// collect all materials from the scene
+  size_t numTextures = 0;
+  for( size_t a = 0; a < mScene->mNumMaterials; ++a )
+  {
+    const aiMaterial* mat = mScene->mMaterials[a];
+
+    aiString name;
+    if( mat->Get( AI_MATKEY_NAME, name) != aiReturn_SUCCESS ) {
+      name = "mat";
+      materials[a].name = std::string( "m") + to_string(a) + name.C_Str();
+    } else {
+      // try to use the material's name if no other material has already taken it, else append #
+      std::string testName = name.C_Str();
+      size_t materialCountWithThisName = 0;
+      for( size_t i = 0; i < a; i ++ ) {
+        if( materials[i].name == testName ) {
+          materialCountWithThisName ++;
+        }
+      }
+      if( materialCountWithThisName == 0 ) {
+        materials[a].name = name.C_Str();
+      } else {
+        materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);
+      }
+    }
+
+    aiShadingMode shading = aiShadingMode_Flat;
+    materials[a].shading_model = "phong";
+    if(mat->Get( AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) {
+        if(shading == aiShadingMode_Phong) {
+            materials[a].shading_model = "phong";
+        } else if(shading == aiShadingMode_Blinn) {
+            materials[a].shading_model = "blinn";
+        } else if(shading == aiShadingMode_NoShading) {
+            materials[a].shading_model = "constant";
+        } else if(shading == aiShadingMode_Gouraud) {
+            materials[a].shading_model = "lambert";
+        }
+    }
+
+    ReadMaterialSurface( materials[a].ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT);
+    if( !materials[a].ambient.texture.empty() ) numTextures++;
+    ReadMaterialSurface( materials[a].diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE);
+    if( !materials[a].diffuse.texture.empty() ) numTextures++;
+    ReadMaterialSurface( materials[a].specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR);
+    if( !materials[a].specular.texture.empty() ) numTextures++;
+    ReadMaterialSurface( materials[a].emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE);
+    if( !materials[a].emissive.texture.empty() ) numTextures++;
+    ReadMaterialSurface( materials[a].reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE);
+    if( !materials[a].reflective.texture.empty() ) numTextures++;
+    ReadMaterialSurface( materials[a].transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT);
+    if( !materials[a].transparent.texture.empty() ) numTextures++;
+    ReadMaterialSurface( materials[a].normal, mat, aiTextureType_NORMALS, NULL, 0, 0);
+    if( !materials[a].normal.texture.empty() ) numTextures++;
+
+    materials[a].shininess.exist = mat->Get( AI_MATKEY_SHININESS, materials[a].shininess.value) == aiReturn_SUCCESS;
+    materials[a].transparency.exist = mat->Get( AI_MATKEY_OPACITY, materials[a].transparency.value) == aiReturn_SUCCESS;
+    materials[a].index_refraction.exist = mat->Get( AI_MATKEY_REFRACTI, materials[a].index_refraction.value) == aiReturn_SUCCESS;
+  }
+
+  // output textures if present
+  if( numTextures > 0 )
+  {
+    mOutput << startstr << "<library_images>" << endstr;
+    PushTag();
+    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
+    {
+      const Material& mat = *it;
+      WriteImageEntry( mat.ambient, mat.name + "-ambient-image");
+      WriteImageEntry( mat.diffuse, mat.name + "-diffuse-image");
+      WriteImageEntry( mat.specular, mat.name + "-specular-image");
+      WriteImageEntry( mat.emissive, mat.name + "-emission-image");
+      WriteImageEntry( mat.reflective, mat.name + "-reflective-image");
+      WriteImageEntry( mat.transparent, mat.name + "-transparent-image");
+      WriteImageEntry( mat.normal, mat.name + "-normal-image");
+    }
+    PopTag();
+    mOutput << startstr << "</library_images>" << endstr;
+  }
+
+  // output effects - those are the actual carriers of information
+  if( !materials.empty() )
+  {
+    mOutput << startstr << "<library_effects>" << endstr;
+    PushTag();
+    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
+    {
+      const Material& mat = *it;
+      // this is so ridiculous it must be right
+      mOutput << startstr << "<effect id=\"" << XMLIDEncode(mat.name) << "-fx\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
+      PushTag();
+      mOutput << startstr << "<profile_COMMON>" << endstr;
+      PushTag();
+
+      // write sampler- and surface params for the texture entries
+      WriteTextureParamEntry( mat.emissive, "emission", mat.name);
+      WriteTextureParamEntry( mat.ambient, "ambient", mat.name);
+      WriteTextureParamEntry( mat.diffuse, "diffuse", mat.name);
+      WriteTextureParamEntry( mat.specular, "specular", mat.name);
+      WriteTextureParamEntry( mat.reflective, "reflective", mat.name);
+      WriteTextureParamEntry( mat.transparent, "transparent", mat.name);
+      WriteTextureParamEntry( mat.normal, "normal", mat.name);
+
+      mOutput << startstr << "<technique sid=\"standard\">" << endstr;
+      PushTag();
+      mOutput << startstr << "<" << mat.shading_model << ">" << endstr;
+      PushTag();
+
+      WriteTextureColorEntry( mat.emissive, "emission", mat.name + "-emission-sampler");
+      WriteTextureColorEntry( mat.ambient, "ambient", mat.name + "-ambient-sampler");
+      WriteTextureColorEntry( mat.diffuse, "diffuse", mat.name + "-diffuse-sampler");
+      WriteTextureColorEntry( mat.specular, "specular", mat.name + "-specular-sampler");
+      WriteFloatEntry(mat.shininess, "shininess");
+      WriteTextureColorEntry( mat.reflective, "reflective", mat.name + "-reflective-sampler");
+      WriteTextureColorEntry( mat.transparent, "transparent", mat.name + "-transparent-sampler");
+      WriteFloatEntry(mat.transparency, "transparency");
+      WriteFloatEntry(mat.index_refraction, "index_of_refraction");
+
+      if(! mat.normal.texture.empty()) {
+        WriteTextureColorEntry( mat.normal, "bump", mat.name + "-normal-sampler");
+      }
+
+      PopTag();
+      mOutput << startstr << "</" << mat.shading_model << ">" << endstr;
+      PopTag();
+      mOutput << startstr << "</technique>" << endstr;
+      PopTag();
+      mOutput << startstr << "</profile_COMMON>" << endstr;
+      PopTag();
+      mOutput << startstr << "</effect>" << endstr;
+    }
+    PopTag();
+    mOutput << startstr << "</library_effects>" << endstr;
+
+    // write materials - they're just effect references
+    mOutput << startstr << "<library_materials>" << endstr;
+    PushTag();
+    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
+    {
+      const Material& mat = *it;
+      mOutput << startstr << "<material id=\"" << XMLIDEncode(mat.name) << "\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
+      PushTag();
+      mOutput << startstr << "<instance_effect url=\"#" << XMLIDEncode(mat.name) << "-fx\"/>" << endstr;
+      PopTag();
+      mOutput << startstr << "</material>" << endstr;
+    }
+    PopTag();
+    mOutput << startstr << "</library_materials>" << endstr;
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the controller library
+void ColladaExporter::WriteControllerLibrary()
+{
+    mOutput << startstr << "<library_controllers>" << endstr;
+    PushTag();
+    
+    for( size_t a = 0; a < mScene->mNumMeshes; ++a) {
+        WriteController( a);
+    }
+
+    PopTag();
+    mOutput << startstr << "</library_controllers>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a skin controller of the given mesh
+void ColladaExporter::WriteController( size_t pIndex)
+{
+    const aiMesh* mesh = mScene->mMeshes[pIndex];
+    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
+    const std::string idstrEscaped = XMLIDEncode(idstr);
+
+    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
+        return;
+
+    if ( mesh->mNumBones == 0 )
+        return;
+
+    mOutput << startstr << "<controller id=\"" << idstrEscaped << "-skin\" ";
+    mOutput << "name=\"skinCluster" << pIndex << "\">"<< endstr;
+    PushTag();
+
+    mOutput << startstr << "<skin source=\"#" << idstrEscaped << "\">" << endstr;
+    PushTag();
+
+    // bind pose matrix
+    mOutput << startstr << "<bind_shape_matrix>" << endstr;
+    PushTag();
+
+    // I think it is identity in general cases.
+    aiMatrix4x4 mat;
+    mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr;
+    mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr;
+    mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr;
+    mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr;
+
+    PopTag();
+    mOutput << startstr << "</bind_shape_matrix>" << endstr;
+
+    mOutput << startstr << "<source id=\"" << idstrEscaped << "-skin-joints\" name=\"" << idstrEscaped << "-skin-joints\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<Name_array id=\"" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
+
+    for( size_t i = 0; i < mesh->mNumBones; ++i )
+        mOutput << XMLIDEncode(mesh->mBones[i]->mName.C_Str()) << " ";
+
+    mOutput << "</Name_array>" << endstr;
+
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    
+    mOutput << startstr << "<accessor source=\"#" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+
+    std::vector<ai_real> bind_poses;
+    bind_poses.reserve(mesh->mNumBones * 16);
+    for(unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for( unsigned int j = 0; j < 4; ++j)
+            bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
+
+    WriteFloatArray( idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real*) bind_poses.data(), bind_poses.size() / 16);
+
+    bind_poses.clear();
+    
+    std::vector<ai_real> skin_weights;
+    skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
+    for( size_t i = 0; i < mesh->mNumBones; ++i)
+        for( size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
+
+    WriteFloatArray( idstr + "-skin-weights", FloatType_Weight, (const ai_real*) skin_weights.data(), skin_weights.size());
+
+    skin_weights.clear();
+
+    mOutput << startstr << "<joints>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstrEscaped << "-skin-bind_poses\"></input>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</joints>" << endstr;
+
+    mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\" offset=\"0\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstrEscaped << "-skin-weights\" offset=\"1\"></input>" << endstr;
+
+    mOutput << startstr << "<vcount>";
+
+    std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
+    for( size_t i = 0; i < mesh->mNumBones; ++i)
+        for( size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
+
+    for( size_t i = 0; i < mesh->mNumVertices; ++i)
+        mOutput << num_influences[i] << " ";
+
+    mOutput << "</vcount>" << endstr;
+
+    mOutput << startstr << "<v>";
+
+    ai_uint joint_weight_indices_length = 0;
+    std::vector<ai_uint> accum_influences;
+    accum_influences.reserve(num_influences.size());
+    for( size_t i = 0; i < num_influences.size(); ++i)
+    {
+        accum_influences.push_back(joint_weight_indices_length);
+        joint_weight_indices_length += num_influences[i];
+    }
+
+    ai_uint weight_index = 0;
+    std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
+    for( unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for( unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+        {
+            unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
+            for( ai_uint k = 0; k < num_influences[vId]; ++k)
+            {
+                if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1)
+                {
+                    joint_weight_indices[2 * (accum_influences[vId] + k)] = i;
+                    joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index;
+                    break;
+                }
+            }
+            ++weight_index;
+        }
+
+    for( size_t i = 0; i < joint_weight_indices.size(); ++i)
+        mOutput << joint_weight_indices[i] << " ";
+
+    num_influences.clear();
+    accum_influences.clear();
+    joint_weight_indices.clear();
+
+    mOutput << "</v>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</vertex_weights>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</skin>" << endstr;
+    
+    PopTag();
+    mOutput << startstr << "</controller>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the geometry library
+void ColladaExporter::WriteGeometryLibrary()
+{
+    mOutput << startstr << "<library_geometries>" << endstr;
+    PushTag();
+
+    for( size_t a = 0; a < mScene->mNumMeshes; ++a)
+        WriteGeometry( a);
+
+    PopTag();
+    mOutput << startstr << "</library_geometries>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the given mesh
+void ColladaExporter::WriteGeometry( size_t pIndex)
+{
+    const aiMesh* mesh = mScene->mMeshes[pIndex];
+    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
+    const std::string geometryName = XMLEscape(idstr);
+    const std::string geometryId = XMLIDEncode(idstr);
+
+    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
+        return;
+
+    // opening tag
+    mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<mesh>" << endstr;
+    PushTag();
+
+    // Positions
+    WriteFloatArray( idstr + "-positions", FloatType_Vector, (ai_real*) mesh->mVertices, mesh->mNumVertices);
+    // Normals, if any
+    if( mesh->HasNormals() )
+        WriteFloatArray( idstr + "-normals", FloatType_Vector, (ai_real*) mesh->mNormals, mesh->mNumVertices);
+
+    // texture coords
+    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
+    {
+        if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
+        {
+            WriteFloatArray( idstr + "-tex" + to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
+                (ai_real*) mesh->mTextureCoords[a], mesh->mNumVertices);
+        }
+    }
+
+    // vertex colors
+    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
+    {
+        if( mesh->HasVertexColors(static_cast<unsigned int>(a)) )
+            WriteFloatArray( idstr + "-color" + to_string(a), FloatType_Color, (ai_real*) mesh->mColors[a], mesh->mNumVertices);
+    }
+
+    // assemble vertex structure
+    // Only write input for POSITION since we will write other as shared inputs in polygon definition
+    mOutput << startstr << "<vertices id=\"" << geometryId << "-vertices" << "\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</vertices>" << endstr;
+
+    // count the number of lines, triangles and polygon meshes
+    int countLines = 0;
+    int countPoly = 0;
+    for( size_t a = 0; a < mesh->mNumFaces; ++a )
+    {
+        if (mesh->mFaces[a].mNumIndices == 2) countLines++;
+        else if (mesh->mFaces[a].mNumIndices >= 3) countPoly++;
+    }
+
+    // lines
+    if (countLines)
+    {
+        mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if( mesh->HasNormals() )
+            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
+        {
+            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
+                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
+        {
+            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
+                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+
+        mOutput << startstr << "<p>";
+        for( size_t a = 0; a < mesh->mNumFaces; ++a )
+        {
+            const aiFace& face = mesh->mFaces[a];
+            if (face.mNumIndices != 2) continue;
+            for( size_t b = 0; b < face.mNumIndices; ++b )
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</lines>" << endstr;
+    }
+
+    // triangle - don't use it, because compatibility problems
+
+    // polygons
+    if (countPoly)
+    {
+        mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if( mesh->HasNormals() )
+            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
+        {
+            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
+                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
+        {
+            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
+                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+
+        mOutput << startstr << "<vcount>";
+        for( size_t a = 0; a < mesh->mNumFaces; ++a )
+        {
+            if (mesh->mFaces[a].mNumIndices < 3) continue;
+            mOutput << mesh->mFaces[a].mNumIndices << " ";
+        }
+        mOutput << "</vcount>" << endstr;
+
+        mOutput << startstr << "<p>";
+        for( size_t a = 0; a < mesh->mNumFaces; ++a )
+        {
+            const aiFace& face = mesh->mFaces[a];
+            if (face.mNumIndices < 3) continue;
+            for( size_t b = 0; b < face.mNumIndices; ++b )
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</polylist>" << endstr;
+    }
+
+    // closing tags
+    PopTag();
+    mOutput << startstr << "</mesh>" << endstr;
+    PopTag();
+    mOutput << startstr << "</geometry>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a float array of the given type
+void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount)
+{
+    size_t floatsPerElement = 0;
+    switch( pType )
+    {
+        case FloatType_Vector: floatsPerElement = 3; break;
+        case FloatType_TexCoord2: floatsPerElement = 2; break;
+        case FloatType_TexCoord3: floatsPerElement = 3; break;
+        case FloatType_Color: floatsPerElement = 3; break;
+        case FloatType_Mat4x4: floatsPerElement = 16; break;
+        case FloatType_Weight: floatsPerElement = 1; break;
+		case FloatType_Time: floatsPerElement = 1; break;
+        default:
+            return;
+    }
+
+    std::string arrayId = XMLIDEncode(pIdString) + "-array";
+
+    mOutput << startstr << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
+    PushTag();
+
+    // source array
+    mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
+    PushTag();
+
+    if( pType == FloatType_TexCoord2 )
+    {
+        for( size_t a = 0; a < pElementCount; ++a )
+        {
+            mOutput << pData[a*3+0] << " ";
+            mOutput << pData[a*3+1] << " ";
+        }
+    }
+    else if( pType == FloatType_Color )
+    {
+        for( size_t a = 0; a < pElementCount; ++a )
+        {
+            mOutput << pData[a*4+0] << " ";
+            mOutput << pData[a*4+1] << " ";
+            mOutput << pData[a*4+2] << " ";
+        }
+    }
+    else
+    {
+        for( size_t a = 0; a < pElementCount * floatsPerElement; ++a )
+            mOutput << pData[a] << " ";
+    }
+    mOutput << "</float_array>" << endstr;
+    PopTag();
+
+    // the usual Collada fun. Let's bloat it even more!
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
+    PushTag();
+
+    switch( pType )
+    {
+        case FloatType_Vector:
+            mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
+            break;
+
+        case FloatType_TexCoord2:
+            mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+            break;
+
+        case FloatType_TexCoord3:
+            mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
+            break;
+
+        case FloatType_Color:
+            mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
+            mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
+            break;
+
+        case FloatType_Mat4x4:
+            mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
+            break;
+
+        case FloatType_Weight:
+            mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
+            break;
+
+		// customized, add animation related
+		case FloatType_Time:
+			mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
+			break;
+
+	}
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the scene library
+void ColladaExporter::WriteSceneLibrary()
+{
+    const std::string sceneName = XMLEscape(mScene->mRootNode->mName.C_Str());
+    const std::string sceneId = XMLIDEncode(mScene->mRootNode->mName.C_Str());
+
+    mOutput << startstr << "<library_visual_scenes>" << endstr;
+    PushTag();
+    mOutput << startstr << "<visual_scene id=\"" + sceneId + "\" name=\"" + sceneName + "\">" << endstr;
+    PushTag();
+
+    // start recursive write at the root node
+    for( size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a )
+        WriteNode( mScene, mScene->mRootNode->mChildren[a]);
+
+    PopTag();
+    mOutput << startstr << "</visual_scene>" << endstr;
+    PopTag();
+    mOutput << startstr << "</library_visual_scenes>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
+{
+    static const float kSecondsFromMilliseconds = .001f;
+
+    const aiAnimation * anim = mScene->mAnimations[pIndex];
+	
+    if ( anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels ==0 ) {
+        return;
+    }
+	
+	const std::string animation_name_escaped = XMLEscape( anim->mName.C_Str() );
+	std::string idstr = anim->mName.C_Str();
+	std::string ending = std::string( "AnimId" ) + to_string(pIndex);
+	if (idstr.length() >= ending.length()) {
+		if (0 != idstr.compare (idstr.length() - ending.length(), ending.length(), ending)) {
+			idstr = idstr + ending;
+		}
+	} else {
+		idstr = idstr + ending;
+	}
+
+	const std::string idstrEscaped = XMLIDEncode(idstr);
+	
+	mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animation_name_escaped + "\">" << endstr;
+	PushTag();
+
+    std::string cur_node_idstr;
+	for (size_t a = 0; a < anim->mNumChannels; ++a) {
+		const aiNodeAnim * nodeAnim = anim->mChannels[a];
+		
+		// sanity check
+        if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) {
+            continue;
+        }
+		
+		{
+            cur_node_idstr.clear();
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-input");
+
+			std::vector<ai_real> frames;
+			for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+				frames.push_back(static_cast<ai_real>(nodeAnim->mPositionKeys[i].mTime) * kSecondsFromMilliseconds);
+			}
+			
+			WriteFloatArray(cur_node_idstr, FloatType_Time, (const ai_real *)frames.data(), frames.size());
+			frames.clear();
+		}
+		
+		{
+            cur_node_idstr.clear();
+
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-output");
+			
+			std::vector<ai_real> keyframes;
+			keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
+			for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+				aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
+				aiMatrix4x4 ScalingM;  // identity
+				ScalingM[0][0] = Scaling.x; ScalingM[1][1] = Scaling.y; ScalingM[2][2] = Scaling.z;
+				
+				aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
+				aiMatrix4x4 s = aiMatrix4x4( RotationQ.GetMatrix() );
+				aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
+				
+				aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
+				aiMatrix4x4 TranslationM;	// identity
+				TranslationM[0][3] = Translation.x; TranslationM[1][3] = Translation.y; TranslationM[2][3] = Translation.z;
+				
+				// Combine the above transformations
+				aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
+				
+				for( unsigned int j = 0; j < 4; ++j) {
+					keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
+                }
+			}
+			
+			WriteFloatArray(cur_node_idstr, FloatType_Mat4x4, (const ai_real *)keyframes.data(), keyframes.size() / 16);
+		}
+		
+		{
+			std::vector<std::string> names;
+			for ( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+				if ( nodeAnim->mPreState == aiAnimBehaviour_DEFAULT
+					|| nodeAnim->mPreState == aiAnimBehaviour_LINEAR
+					|| nodeAnim->mPreState == aiAnimBehaviour_REPEAT
+					) {
+					names.push_back( "LINEAR" );
+				} else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
+					names.push_back( "STEP" );
+				}
+			}
+			
+			const std::string cur_node_idstr2 = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
+            std::string arrayId = XMLIDEncode(cur_node_idstr2) + "-array";
+			
+			mOutput << startstr << "<source id=\"" << XMLIDEncode(cur_node_idstr2) << "\">" << endstr;
+			PushTag();
+			
+			// source array
+			mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
+			for( size_t aa = 0; aa < names.size(); ++aa ) {
+				mOutput << names[aa] << " ";
+            }
+			mOutput << "</Name_array>" << endstr;
+			
+			mOutput << startstr << "<technique_common>" << endstr;
+			PushTag();
+
+			mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
+			PushTag();
+			
+			mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
+			
+			PopTag();
+			mOutput << startstr << "</accessor>" << endstr;
+			
+			PopTag();
+			mOutput << startstr << "</technique_common>" << endstr;
+
+			PopTag();
+			mOutput << startstr << "</source>" << endstr;
+		}
+	}
+	
+	for (size_t a = 0; a < anim->mNumChannels; ++a) {
+		const aiNodeAnim * nodeAnim = anim->mChannels[a];
+		
+		{
+		// samplers
+			const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
+			mOutput << startstr << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+			PushTag();
+			
+			mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-input") ) << "\"/>" << endstr;
+			mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-output") ) << "\"/>" << endstr;
+			mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-interpolation") ) << "\"/>" << endstr;
+			
+			PopTag();
+			mOutput << startstr << "</sampler>" << endstr;
+		}
+	}
+	
+	for (size_t a = 0; a < anim->mNumChannels; ++a) {
+		const aiNodeAnim * nodeAnim = anim->mChannels[a];
+		
+		{
+		// channels
+			mOutput << startstr << "<channel source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-sampler") ) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+		}
+	}
+	
+	PopTag();
+	mOutput << startstr << "</animation>" << endstr;
+	
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationsLibrary()
+{
+	if ( mScene->mNumAnimations > 0 ) {
+		mOutput << startstr << "<library_animations>" << endstr;
+		PushTag();
+		
+		// start recursive write at the root node
+		for( size_t a = 0; a < mScene->mNumAnimations; ++a)
+			WriteAnimationLibrary( a );
+
+		PopTag();
+		mOutput << startstr << "</library_animations>" << endstr;
+	}
+}
+// ------------------------------------------------------------------------------------------------
+// Helper to find a bone by name in the scene
+aiBone* findBone( const aiScene* scene, const char * name) {
+    for (size_t m=0; m<scene->mNumMeshes; m++) {
+        aiMesh * mesh = scene->mMeshes[m];
+        for (size_t b=0; b<mesh->mNumBones; b++) {
+            aiBone * bone = mesh->mBones[b];
+            if (0 == strcmp(name, bone->mName.C_Str())) {
+                return bone;
+            }
+        }
+    }
+    return NULL;
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiNode * findBoneNode( const aiNode* aNode, const aiBone* bone)
+{
+	if ( aNode && bone && aNode->mName == bone->mName ) {
+		return aNode;
+	}
+	
+	if ( aNode && bone ) {
+		for (unsigned int i=0; i < aNode->mNumChildren; ++i) {
+			aiNode * aChild = aNode->mChildren[i];
+			const aiNode * foundFromChild = 0;
+			if ( aChild ) {
+				foundFromChild = findBoneNode( aChild, bone );
+				if ( foundFromChild ) return foundFromChild;
+			}
+		}
+	}
+	
+	return NULL;
+}
+
+const aiNode * findSkeletonRootNode( const aiScene* scene, const aiMesh * mesh)
+{
+	std::set<const aiNode*> topParentBoneNodes;
+	if ( mesh && mesh->mNumBones > 0 ) {
+		for (unsigned int i=0; i < mesh->mNumBones; ++i) {
+			aiBone * bone = mesh->mBones[i];
+
+			const aiNode * node = findBoneNode( scene->mRootNode, bone);
+			if ( node ) {
+				while ( node->mParent && findBone(scene, node->mParent->mName.C_Str() ) != 0 ) {
+					node = node->mParent;
+				}
+				topParentBoneNodes.insert( node );
+			}
+		}
+	}
+	
+	if ( !topParentBoneNodes.empty() ) {
+		const aiNode * parentBoneNode = *topParentBoneNodes.begin();
+		if ( topParentBoneNodes.size() == 1 ) {
+			return parentBoneNode;
+		} else {
+			for (auto it : topParentBoneNodes) {
+				if ( it->mParent ) return it->mParent;
+			}
+			return parentBoneNode;
+		}
+	}
+	
+	return NULL;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Recursively writes the given node
+void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
+{
+    // the node must have a name
+    if (pNode->mName.length == 0)
+    {
+        std::stringstream ss;
+        ss << "Node_" << pNode;
+        pNode->mName.Set(ss.str());
+    }
+
+    // If the node is associated with a bone, it is a joint node (JOINT)
+    // otherwise it is a normal node (NODE)
+    const char * node_type;
+    bool is_joint, is_skeleton_root = false;
+    if (nullptr == findBone(pScene, pNode->mName.C_Str())) {
+        node_type = "NODE";
+        is_joint = false;
+    } else {
+        node_type = "JOINT";
+        is_joint = true;
+        if (!pNode->mParent || nullptr == findBone(pScene, pNode->mParent->mName.C_Str())) {
+            is_skeleton_root = true;
+        }
+    }
+
+    const std::string node_id = XMLIDEncode(pNode->mName.data);
+    const std::string node_name = XMLEscape(pNode->mName.data);
+	mOutput << startstr << "<node ";
+	if(is_skeleton_root) {
+		mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id +"\"" : "") ; // For now, only support one skeleton in a scene.
+		mFoundSkeletonRootNodeID = node_id;
+	} else {
+		mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id +"\"": "") ;
+	}
+	
+    mOutput << " name=\"" << node_name
+            << "\" type=\"" << node_type
+            << "\">" << endstr;
+    PushTag();
+
+    // write transformation - we can directly put the matrix there
+    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
+    aiMatrix4x4 mat = pNode->mTransformation;
+
+    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
+    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
+    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
+    // coordinate system must be changed to matche the Collada specification.
+    for (size_t i = 0; i<mScene->mNumCameras; i++){
+        if (mScene->mCameras[i]->mName == pNode->mName){
+            aiMatrix4x4 sourceView;
+            mScene->mCameras[i]->GetCameraMatrix(sourceView);
+
+            aiMatrix4x4 colladaView;
+            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
+            mat *= (sourceView * colladaView);
+            break;
+        }
+    }
+	
+	// customized, sid should be 'matrix' to match with loader code.
+    //mOutput << startstr << "<matrix sid=\"transform\">";
+	mOutput << startstr << "<matrix sid=\"matrix\">";
+	
+    mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
+    mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
+    mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
+    mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
+    mOutput << "</matrix>" << endstr;
+
+    if(pNode->mNumMeshes==0){
+        //check if it is a camera node
+        for(size_t i=0; i<mScene->mNumCameras; i++){
+            if(mScene->mCameras[i]->mName == pNode->mName){
+                mOutput << startstr <<"<instance_camera url=\"#" << node_id << "-camera\"/>" << endstr;
+                break;
+            }
+        }
+        //check if it is a light node
+        for(size_t i=0; i<mScene->mNumLights; i++){
+            if(mScene->mLights[i]->mName == pNode->mName){
+                mOutput << startstr <<"<instance_light url=\"#" << node_id << "-light\"/>" << endstr;
+                break;
+            }
+        }
+
+    }else
+    // instance every geometry
+    for( size_t a = 0; a < pNode->mNumMeshes; ++a )
+    {
+        const aiMesh* mesh = mScene->mMeshes[pNode->mMeshes[a]];
+        // do not instantiate mesh if empty. I wonder how this could happen
+        if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
+            continue;
+
+        const std::string meshName = mesh->mName.length == 0 ? GetMeshId(pNode->mMeshes[a]) : mesh->mName.C_Str();
+
+        if( mesh->mNumBones == 0 )
+        {
+            mOutput << startstr << "<instance_geometry url=\"#" << XMLIDEncode(meshName) << "\">" << endstr;
+            PushTag();
+        }
+        else
+        {
+            mOutput << startstr
+                    << "<instance_controller url=\"#" << XMLIDEncode(meshName) << "-skin\">"
+                    << endstr;
+            PushTag();
+
+			// note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
+			// use the first bone to find skeleton root
+			const aiNode * skeletonRootBoneNode = findSkeletonRootNode( pScene, mesh );
+			if ( skeletonRootBoneNode ) {
+				mFoundSkeletonRootNodeID = XMLIDEncode( skeletonRootBoneNode->mName.C_Str() );
+			}
+            mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
+        }
+        mOutput << startstr << "<bind_material>" << endstr;
+        PushTag();
+        mOutput << startstr << "<technique_common>" << endstr;
+        PushTag();
+        mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << XMLIDEncode(materials[mesh->mMaterialIndex].name) << "\">" << endstr;
+        PushTag();
+        for( size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa )
+        {
+            if( mesh->HasTextureCoords( static_cast<unsigned int>(aa) ) )
+                // semantic       as in <texture texcoord=...>
+                // input_semantic as in <input semantic=...>
+                // input_set      as in <input set=...>
+                mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << aa << "\" input_semantic=\"TEXCOORD\" input_set=\"" << aa << "\"/>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</instance_material>" << endstr;
+        PopTag();
+        mOutput << startstr << "</technique_common>" << endstr;
+        PopTag();
+        mOutput << startstr << "</bind_material>" << endstr;
+        
+        PopTag();
+        if( mesh->mNumBones == 0)
+            mOutput << startstr << "</instance_geometry>" << endstr;
+        else
+            mOutput << startstr << "</instance_controller>" << endstr;
+    }
+
+    // recurse into subnodes
+    for( size_t a = 0; a < pNode->mNumChildren; ++a )
+        WriteNode( pScene, pNode->mChildren[a]);
+
+    PopTag();
+    mOutput << startstr << "</node>" << endstr;
+}
+
+#endif
+#endif
diff --git a/code/Common/ImporterRegistry.cpp b/code/Common/ImporterRegistry.cpp
index d66d7de8d..da51696bc 100644
--- a/code/Common/ImporterRegistry.cpp
+++ b/code/Common/ImporterRegistry.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/code/PostProcessing/ArmaturePopulate.h b/code/PostProcessing/ArmaturePopulate.h
index 8985e1d1d..877d8b0d1 100644
--- a/code/PostProcessing/ArmaturePopulate.h
+++ b/code/PostProcessing/ArmaturePopulate.h
@@ -109,4 +109,4 @@ public:
 } // Namespace Assimp
 
 
-#endif // SCALE_PROCESS_H_
\ No newline at end of file
+#endif // SCALE_PROCESS_H_
diff --git a/code/PostProcessing/ScaleProcess.h b/code/PostProcessing/ScaleProcess.h
index 9cc664c6a..5799dd22c 100644
--- a/code/PostProcessing/ScaleProcess.h
+++ b/code/PostProcessing/ScaleProcess.h
@@ -94,4 +94,4 @@ private:
 } // Namespace Assimp
 
 
-#endif // SCALE_PROCESS_H_
\ No newline at end of file
+#endif // SCALE_PROCESS_H_
diff --git a/code/PostProcessing/SplitByBoneCountProcess.cpp b/code/PostProcessing/SplitByBoneCountProcess.cpp
index ab7a1fe00..1fd26c757 100644
--- a/code/PostProcessing/SplitByBoneCountProcess.cpp
+++ b/code/PostProcessing/SplitByBoneCountProcess.cpp
@@ -52,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <limits>
 #include <assimp/TinyFormatter.h>
 #include <assimp/Exceptional.h>
+#include <set>
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -172,7 +173,15 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         const aiBone* bone = pMesh->mBones[a];
         for( unsigned int b = 0; b < bone->mNumWeights; ++b)
         {
-            vertexBones[ bone->mWeights[b].mVertexId ].push_back( BoneWeight( a, bone->mWeights[b].mWeight));
+          if (bone->mWeights[b].mWeight > 0.0f)
+          {
+            int vertexId = bone->mWeights[b].mVertexId;
+            vertexBones[vertexId].push_back( BoneWeight( a, bone->mWeights[b].mWeight));
+            if (vertexBones[vertexId].size() > mMaxBoneCount)
+            {
+              throw DeadlyImportError("SplitByBoneCountProcess: Single face requires more bones than specified max bone count!");
+            }
+          }
         }
     }
 
@@ -188,9 +197,6 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
         subMeshFaces.reserve( pMesh->mNumFaces);
         // accumulated vertex count of all the faces in this submesh
         unsigned int numSubMeshVertices = 0;
-        // a small local array of new bones for the current face. State of all used bones for that face
-        // can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
-        std::vector<unsigned int> newBonesAtCurrentFace;
 
         // add faces to the new submesh as long as all bones affecting the faces' vertices fit in the limit
         for( unsigned int a = 0; a < pMesh->mNumFaces; ++a)
@@ -200,33 +206,25 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
             {
                 continue;
             }
-
+            // a small local set of new bones for the current face. State of all used bones for that face
+            // can only be updated AFTER the face is completely analysed. Thanks to imre for the fix.
+            std::set<unsigned int> newBonesAtCurrentFace;
+          
             const aiFace& face = pMesh->mFaces[a];
             // check every vertex if its bones would still fit into the current submesh
             for( unsigned int b = 0; b < face.mNumIndices; ++b )
             {
-                const std::vector<BoneWeight>& vb = vertexBones[face.mIndices[b]];
-                for( unsigned int c = 0; c < vb.size(); ++c)
+              const std::vector<BoneWeight>& vb = vertexBones[face.mIndices[b]];
+              for( unsigned int c = 0; c < vb.size(); ++c)
+              {
+                unsigned int boneIndex = vb[c].first;
+                if( !isBoneUsed[boneIndex] )
                 {
-                    unsigned int boneIndex = vb[c].first;
-                    // if the bone is already used in this submesh, it's ok
-                    if( isBoneUsed[boneIndex] )
-                    {
-                        continue;
-                    }
-
-                    // if it's not used, yet, we would need to add it. Store its bone index
-                    if( std::find( newBonesAtCurrentFace.begin(), newBonesAtCurrentFace.end(), boneIndex) == newBonesAtCurrentFace.end() )
-                    {
-                        newBonesAtCurrentFace.push_back( boneIndex);
-                    }
-                }
+                  newBonesAtCurrentFace.insert(boneIndex);
+                }   
+              }
             }
 
-            if (newBonesAtCurrentFace.size() > mMaxBoneCount)
-            {
-                throw DeadlyImportError("SplitByBoneCountProcess: Single face requires more bones than specified max bone count!");
-            }
             // leave out the face if the new bones required for this face don't fit the bone count limit anymore
             if( numBones + newBonesAtCurrentFace.size() > mMaxBoneCount )
             {
@@ -234,17 +232,13 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
             }
 
             // mark all new bones as necessary
-            while( !newBonesAtCurrentFace.empty() )
+            for (std::set<unsigned int>::iterator it = newBonesAtCurrentFace.begin(); it != newBonesAtCurrentFace.end(); ++it)
             {
-                unsigned int newIndex = newBonesAtCurrentFace.back();
-                newBonesAtCurrentFace.pop_back(); // this also avoids the deallocation which comes with a clear()
-                if( isBoneUsed[newIndex] )
-                {
-                    continue;
-                }
-
-                isBoneUsed[newIndex] = true;
+              if (!isBoneUsed[*it])
+              {
+                isBoneUsed[*it] = true;
                 numBones++;
+              }
             }
 
             // store the face index and the vertex count
diff --git a/code/PostProcessing/ValidateDataStructure.cpp b/code/PostProcessing/ValidateDataStructure.cpp
index ba31f36d6..03989c1e5 100644
--- a/code/PostProcessing/ValidateDataStructure.cpp
+++ b/code/PostProcessing/ValidateDataStructure.cpp
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/contrib/Open3DGC/o3dgcSC3DMCDecoder.h b/contrib/Open3DGC/o3dgcSC3DMCDecoder.h
index f3f1617c4..e6f803b94 100644
--- a/contrib/Open3DGC/o3dgcSC3DMCDecoder.h
+++ b/contrib/Open3DGC/o3dgcSC3DMCDecoder.h
@@ -1,4 +1,4 @@
-/*
+/*
 Copyright (c) 2013 Khaled Mammou - Advanced Micro Devices, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
diff --git a/contrib/android-cmake/README.md b/contrib/android-cmake/README.md
index ee6302128..395131daf 100644
--- a/contrib/android-cmake/README.md
+++ b/contrib/android-cmake/README.md
@@ -237,4 +237,4 @@ The _android-cmake_ should correctly handle projects with assembler sources (`*.
 
 ## Copying
 
-_android-cmake_ is distributed under the terms of [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause)
\ No newline at end of file
+_android-cmake_ is distributed under the terms of [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause)
diff --git a/contrib/gtest/docs/Documentation.md b/contrib/gtest/docs/Documentation.md
index 8ca1aac75..e5d041f3a 100644
--- a/contrib/gtest/docs/Documentation.md
+++ b/contrib/gtest/docs/Documentation.md
@@ -11,4 +11,4 @@ documentation for that specific version instead.**
 To contribute code to Google Test, read:
 
   * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/contrib/gtest/docs/V1_5_Documentation.md b/contrib/gtest/docs/V1_5_Documentation.md
index 46bba2ec8..6febc65c9 100644
--- a/contrib/gtest/docs/V1_5_Documentation.md
+++ b/contrib/gtest/docs/V1_5_Documentation.md
@@ -9,4 +9,4 @@ This page lists all official documentation wiki pages for Google Test **1.5.0**
 To contribute code to Google Test, read:
 
   * DevGuide -- read this _before_ writing your first patch.
-  * [PumpManual](V1_5_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](V1_5_PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/contrib/gtest/docs/V1_5_PumpManual.md b/contrib/gtest/docs/V1_5_PumpManual.md
index 15710789d..e6485a01d 100644
--- a/contrib/gtest/docs/V1_5_PumpManual.md
+++ b/contrib/gtest/docs/V1_5_PumpManual.md
@@ -174,4 +174,4 @@ You can find real-world applications of Pump in [Google Test](http://www.google.
 ## Tips ##
 
   * If a meta variable is followed by a letter or digit, you can separate them using `[[]]`, which inserts an empty string. For example `Foo$j[[]]Helper` generate `Foo1Helper` when `j` is 1.
-  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
\ No newline at end of file
+  * To avoid extra-long Pump source lines, you can break a line anywhere you want by inserting `[[]]` followed by a new line. Since any new-line character next to `[[` or `]]` is ignored, the generated code won't contain this new line.
diff --git a/contrib/gtest/docs/V1_5_XcodeGuide.md b/contrib/gtest/docs/V1_5_XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/contrib/gtest/docs/V1_5_XcodeGuide.md
+++ b/contrib/gtest/docs/V1_5_XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/contrib/gtest/docs/V1_6_Documentation.md b/contrib/gtest/docs/V1_6_Documentation.md
index ca924660a..1085673d1 100644
--- a/contrib/gtest/docs/V1_6_Documentation.md
+++ b/contrib/gtest/docs/V1_6_Documentation.md
@@ -11,4 +11,4 @@ documentation for that specific version instead.**
 To contribute code to Google Test, read:
 
   * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](V1_6_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](V1_6_PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/contrib/gtest/docs/V1_6_XcodeGuide.md b/contrib/gtest/docs/V1_6_XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/contrib/gtest/docs/V1_6_XcodeGuide.md
+++ b/contrib/gtest/docs/V1_6_XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/contrib/gtest/docs/V1_7_Documentation.md b/contrib/gtest/docs/V1_7_Documentation.md
index 282697a50..6dc7d05b4 100644
--- a/contrib/gtest/docs/V1_7_Documentation.md
+++ b/contrib/gtest/docs/V1_7_Documentation.md
@@ -11,4 +11,4 @@ documentation for that specific version instead.**
 To contribute code to Google Test, read:
 
   * [DevGuide](DevGuide.md) -- read this _before_ writing your first patch.
-  * [PumpManual](V1_7_PumpManual.md) -- how we generate some of Google Test's source files.
\ No newline at end of file
+  * [PumpManual](V1_7_PumpManual.md) -- how we generate some of Google Test's source files.
diff --git a/contrib/gtest/docs/V1_7_XcodeGuide.md b/contrib/gtest/docs/V1_7_XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/contrib/gtest/docs/V1_7_XcodeGuide.md
+++ b/contrib/gtest/docs/V1_7_XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/contrib/gtest/docs/XcodeGuide.md b/contrib/gtest/docs/XcodeGuide.md
index bf24bf51b..21d7f5c05 100644
--- a/contrib/gtest/docs/XcodeGuide.md
+++ b/contrib/gtest/docs/XcodeGuide.md
@@ -90,4 +90,4 @@ The Debugger has exited with status 0.
 
 # Summary #
 
-Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
\ No newline at end of file
+Unit testing is a valuable way to ensure your data model stays valid even during rapid development or refactoring. The Google Testing Framework is a great unit testing framework for C and C++ which integrates well with an Xcode development environment.
diff --git a/contrib/poly2tri/README b/contrib/poly2tri/README
index 2857e2983..883e9a581 100644
--- a/contrib/poly2tri/README
+++ b/contrib/poly2tri/README
@@ -1,4 +1,4 @@
-==================
+==================
 INSTALLATION GUIDE
 ==================
 
@@ -48,4 +48,4 @@ Examples:
   ./p2t nazca_monkey.dat 0 0 9
   
   ./p2t random 10 100 5.0
-  ./p2t random 1000 20000 0.025
\ No newline at end of file
+  ./p2t random 1000 20000 0.025
diff --git a/contrib/poly2tri/poly2tri/common/shapes.cc b/contrib/poly2tri/poly2tri/common/shapes.cc
index d0de13e64..c94e11c03 100644
--- a/contrib/poly2tri/poly2tri/common/shapes.cc
+++ b/contrib/poly2tri/poly2tri/common/shapes.cc
@@ -362,4 +362,4 @@ void Triangle::DebugPrint()
   cout << points_[2]->x << "," << points_[2]->y << endl;
 }
 
-}
\ No newline at end of file
+}
diff --git a/contrib/poly2tri/poly2tri/common/shapes.h b/contrib/poly2tri/poly2tri/common/shapes.h
index ac7389a2d..d3660f716 100644
--- a/contrib/poly2tri/poly2tri/common/shapes.h
+++ b/contrib/poly2tri/poly2tri/common/shapes.h
@@ -324,4 +324,4 @@ inline void Triangle::IsInterior(bool b)
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/contrib/poly2tri/poly2tri/poly2tri.h b/contrib/poly2tri/poly2tri/poly2tri.h
index 29a08d052..ba5cc159e 100644
--- a/contrib/poly2tri/poly2tri/poly2tri.h
+++ b/contrib/poly2tri/poly2tri/poly2tri.h
@@ -35,4 +35,4 @@
 #include "common/shapes.h"
 #include "sweep/cdt.h"
 
-#endif
\ No newline at end of file
+#endif
diff --git a/contrib/poly2tri/poly2tri/sweep/advancing_front.cc b/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
index 38723beef..9739babce 100644
--- a/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
+++ b/contrib/poly2tri/poly2tri/sweep/advancing_front.cc
@@ -105,4 +105,4 @@ AdvancingFront::~AdvancingFront()
 {
 }
 
-}
\ No newline at end of file
+}
diff --git a/contrib/poly2tri/poly2tri/sweep/advancing_front.h b/contrib/poly2tri/poly2tri/sweep/advancing_front.h
index 645dcec97..3bfec5368 100644
--- a/contrib/poly2tri/poly2tri/sweep/advancing_front.h
+++ b/contrib/poly2tri/poly2tri/sweep/advancing_front.h
@@ -115,4 +115,4 @@ inline void AdvancingFront::set_search(Node* node)
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/contrib/poly2tri/poly2tri/sweep/cdt.cc b/contrib/poly2tri/poly2tri/sweep/cdt.cc
index 09d088ae3..b79f5a8de 100644
--- a/contrib/poly2tri/poly2tri/sweep/cdt.cc
+++ b/contrib/poly2tri/poly2tri/sweep/cdt.cc
@@ -68,4 +68,4 @@ CDT::~CDT()
   delete sweep_;
 }
 
-}
\ No newline at end of file
+}
diff --git a/contrib/poly2tri/poly2tri/sweep/cdt.h b/contrib/poly2tri/poly2tri/sweep/cdt.h
index ea3286d9a..4a9a292d3 100644
--- a/contrib/poly2tri/poly2tri/sweep/cdt.h
+++ b/contrib/poly2tri/poly2tri/sweep/cdt.h
@@ -102,4 +102,4 @@ public:
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/contrib/poly2tri/poly2tri/sweep/sweep.h b/contrib/poly2tri/poly2tri/sweep/sweep.h
index 33e34a714..ad429fd96 100644
--- a/contrib/poly2tri/poly2tri/sweep/sweep.h
+++ b/contrib/poly2tri/poly2tri/sweep/sweep.h
@@ -282,4 +282,4 @@ private:
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/contrib/stb_image/stb_image.h b/contrib/stb_image/stb_image.h
index 571b0dcea..d9c21bc81 100644
--- a/contrib/stb_image/stb_image.h
+++ b/contrib/stb_image/stb_image.h
@@ -7459,4 +7459,4 @@ AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ------------------------------------------------------------------------------
-*/
\ No newline at end of file
+*/
diff --git a/contrib/zip/.travis.sh b/contrib/zip/.travis.sh
index 22974b1ff..9cb03ee87 100755
--- a/contrib/zip/.travis.sh
+++ b/contrib/zip/.travis.sh
@@ -15,4 +15,4 @@ else
     make -j 8
     make install
     ASAN_OPTIONS=detect_leaks=0 LSAN_OPTIONS=verbosity=1:log_threads=1 ctest -V
-fi
\ No newline at end of file
+fi
diff --git a/contrib/zip/.travis.yml b/contrib/zip/.travis.yml
index 86bac1cca..42f84dd25 100644
--- a/contrib/zip/.travis.yml
+++ b/contrib/zip/.travis.yml
@@ -19,4 +19,4 @@ after_success:
   - make
   - make test
   # Uploading report to CodeCov
-  - bash <(curl -s https://codecov.io/bash)
\ No newline at end of file
+  - bash <(curl -s https://codecov.io/bash)
diff --git a/contrib/zlib/CMakeLists.txt b/contrib/zlib/CMakeLists.txt
index c90996c0b..664c83a71 100644
--- a/contrib/zlib/CMakeLists.txt
+++ b/contrib/zlib/CMakeLists.txt
@@ -196,10 +196,7 @@ if(MINGW)
     set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
 endif(MINGW)
 
-add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
-set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
-set_target_properties(zlib PROPERTIES SOVERSION 1)
 
 INSTALL( TARGETS zlibstatic
          LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
diff --git a/contrib/zlib/contrib/blast/test.txt b/contrib/zlib/contrib/blast/test.txt
index bfdf1c5dc..159002de5 100644
--- a/contrib/zlib/contrib/blast/test.txt
+++ b/contrib/zlib/contrib/blast/test.txt
@@ -1 +1 @@
-AIAIAIAIAIAIA
\ No newline at end of file
+AIAIAIAIAIAIA
diff --git a/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt b/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
index 127a5bc39..36b7cd93c 100644
--- a/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
+++ b/contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
@@ -20,4 +20,4 @@ FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
\ No newline at end of file
+DEALINGS IN THE SOFTWARE.
diff --git a/contrib/zlib/contrib/testzlib/testzlib.txt b/contrib/zlib/contrib/testzlib/testzlib.txt
index e508bb22f..ba1bb3db6 100644
--- a/contrib/zlib/contrib/testzlib/testzlib.txt
+++ b/contrib/zlib/contrib/testzlib/testzlib.txt
@@ -7,4 +7,4 @@ copy to a directory file from :
 - contrib/masmx64
 - contrib/vstudio/vc7
 
-and open testzlib8.sln
\ No newline at end of file
+and open testzlib8.sln
diff --git a/contrib/zlib_note.txt b/contrib/zlib_note.txt
index cc274f0bf..a7ca98634 100644
--- a/contrib/zlib_note.txt
+++ b/contrib/zlib_note.txt
@@ -8,4 +8,4 @@ This is a heavily modified and shrinked version of zlib 1.2.3
 
 Assimp itself does not use the compression part yet, so
 it needn't be compiled (trees.c, deflate.c, compress.c).
-Currently these units are just used by assimp_cmd.
\ No newline at end of file
+Currently these units are just used by assimp_cmd.
diff --git a/doc/architecture/Assimp_Arch_Import.class.violet.html b/doc/architecture/Assimp_Arch_Import.class.violet.html
index 264468f98..b4e3a9a6e 100644
--- a/doc/architecture/Assimp_Arch_Import.class.violet.html
+++ b/doc/architecture/Assimp_Arch_Import.class.violet.html
@@ -351,4 +351,4 @@ BI8AxOURXedNEuG6jMiRPHKQsuuS4BGAuDzS0NCQlZV18JFlRI7qkRRdlwSPAHzCIynKaa5LgkcA
 ETwCgEfwCAAewSMAeASP4BEAPIJHAPAIHgFItrEBsYNHAD7BK4gZPAKAR/AIAB7BIwCQBvwfU/j0
 jy2hMWgAAAAASUVORK5C" />
 </BODY>
-</HTML>
\ No newline at end of file
+</HTML>
diff --git a/doc/architecture/Assimp_Arch_export.class.violet.html b/doc/architecture/Assimp_Arch_export.class.violet.html
index 85f68d68d..ee567caaa 100644
--- a/doc/architecture/Assimp_Arch_export.class.violet.html
+++ b/doc/architecture/Assimp_Arch_export.class.violet.html
@@ -645,4 +645,4 @@ tQ2gtkFtg9oGQG2jtkFtA6C2UduA2gZQ26C2QW0DoLZR26C2AVDbqG1AbQMoKg8CahvUNgBqG7UN
 ahsAtY3aBtQ2AGobtQ1qGwC1jdoGtQ2A2kZtA2obALWN2ga1DUA1igr2o7ZBbQPw0/wD+/DsALUN
 gNpGbYPaBkBto7ZBbQMAAD/R/wDNluGGIxSgmAAAAABJRU5ErkJg" />
 </BODY>
-</HTML>
\ No newline at end of file
+</HTML>
diff --git a/doc/architecture/assimp.object.violet.html b/doc/architecture/assimp.object.violet.html
index 1d82fa05f..dee9d2208 100644
--- a/doc/architecture/assimp.object.violet.html
+++ b/doc/architecture/assimp.object.violet.html
@@ -104,4 +104,4 @@ tfMWuhaZfgHUw0Q32sDAwIcPH4I/C1fbaJVKRX0GBwft4RA5hXdkNepJqndpKD2R7TlrjeqmxkKh
 oLOf5O8VrfC7XlrtOvYCO77PYocddthhhx122GGHHXbYYYcddthhhx122GGHHXbYYYdd29q1c83s
 I9m5B21Yuxg77FJtRzQV/wEjVLA5JUDyfgAAAABJRU5ErkJg" />
 </BODY>
-</HTML>
\ No newline at end of file
+</HTML>
diff --git a/doc/architecture/assimp_usecase.ucase.violet.html b/doc/architecture/assimp_usecase.ucase.violet.html
index 3045add42..c4df02533 100644
--- a/doc/architecture/assimp_usecase.ucase.violet.html
+++ b/doc/architecture/assimp_usecase.ucase.violet.html
@@ -872,4 +872,4 @@ DYMQQgghNAxCCCGEEBoGIYQQQmgYhBBCCKFhEEIIIYTQMAghhBBCwyCEEEIIDYMQQgghNAxCCCGE
 EBoGIYQQQmgYhBBCCKFhEEIIIYTQMAghhBBCwyCEEEJI/PP/A0zci3P89Qf2AAAAAElFTkSuQmCC
 " />
 </BODY>
-</HTML>
\ No newline at end of file
+</HTML>
diff --git a/doc/architecture/process.class.violet.html b/doc/architecture/process.class.violet.html
index d4f77d909..662daf4a8 100644
--- a/doc/architecture/process.class.violet.html
+++ b/doc/architecture/process.class.violet.html
@@ -334,4 +334,4 @@ CQCsyZpgTQCsyZpgTQCsyZpgTQCsyZpgTQCsCdZkTQBgTdZkTQBgTdZkTQBgTdYEawJgTdYEawJg
 TdYEawJgTbAmawIAa7ImawIAa7ImawIAa7ImWBMAa7ImWBMAa7ImWBPAvDIByoc1WRMA/uU3lI1q
 YU0ArAnWZE0AYE3WZE0AABY4/wVVY1WTrOVxIAAAAABJRU5ErkJg" />
 </BODY>
-</HTML>
\ No newline at end of file
+</HTML>
diff --git a/code/AssetLib/StepFile/StepFileImporter.h b/fuzz/assimp_fuzzer.cpp
similarity index 75%
rename from code/AssetLib/StepFile/StepFileImporter.h
rename to fuzz/assimp_fuzzer.cpp
index c6ac08bb6..86ffe18ed 100644
--- a/code/AssetLib/StepFile/StepFileImporter.h
+++ b/fuzz/assimp_fuzzer.cpp
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -40,30 +38,19 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
+#include <assimp/cimport.h>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
 
-#pragma once
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize) {
+	aiLogStream stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
+	aiAttachLogStream(&stream);
 
-#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
+    Importer importer;
+    const aiScene *sc = importer.ReadFileFromMemory(data, dataSize,
+        aiProcessPreset_TargetRealtime_Quality, nullptr );
 
-#include <assimp/BaseImporter.h>
-
-namespace Assimp {
-namespace StepFile {
-
-class StepFileImporter : public BaseImporter {
-public:
-    StepFileImporter();
-    ~StepFileImporter();
-    bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
-    const aiImporterDesc* GetInfo() const override;
-
-protected:
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) override;
-
-private:
-};
-
-} // Namespace StepFile
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_STEP_IMPORTER
+    aiDetachLogStream(&stream);
+    
+    return 0;
+}
diff --git a/include/assimp/scene.h b/include/assimp/scene.h
index 93d04eee6..a189f5700 100644
--- a/include/assimp/scene.h
+++ b/include/assimp/scene.h
@@ -1,4 +1,4 @@
-/*
+/*
 ---------------------------------------------------------------------------
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
diff --git a/packaging/windows-innosetup/WEB b/packaging/windows-innosetup/WEB
index 8840d232d..d14d6ed9a 100644
--- a/packaging/windows-innosetup/WEB
+++ b/packaging/windows-innosetup/WEB
@@ -1,8 +1,6 @@
-
-Project home page:
-http://assimp.sourceforge.net
-
-Sourceforge.net project page:
-http://www.sourceforge.net/projects/assimp
-
-
+
+Project home page:
+http://assimp.sourceforge.net
+
+Sourceforge.net project page:
+http://www.sourceforge.net/projects/assimp
diff --git a/packaging/windows-innosetup/readme_installer_vieweronly.txt b/packaging/windows-innosetup/readme_installer_vieweronly.txt
index bfa4f8c9e..1e84c577d 100644
--- a/packaging/windows-innosetup/readme_installer_vieweronly.txt
+++ b/packaging/windows-innosetup/readme_installer_vieweronly.txt
@@ -29,4 +29,4 @@ Reinstall Microsoft Visual C++ 2005 SP1 Redistributable (x86 or x64, depending o
 Add it to PATH. That's not a bug, the installer does not alter the PATH.
 
 4. Crashes immediately
-You CPU lacks SSE2 support. Build Assimp from scratch to suit your CPU, sorry.
\ No newline at end of file
+You CPU lacks SSE2 support. Build Assimp from scratch to suit your CPU, sorry.
diff --git a/packaging/windows-mkzip/bin_readme.txt b/packaging/windows-mkzip/bin_readme.txt
index 10839a3d9..5cff1f30e 100644
--- a/packaging/windows-mkzip/bin_readme.txt
+++ b/packaging/windows-mkzip/bin_readme.txt
@@ -26,4 +26,4 @@ Install the latest DirectX runtime or grab the file from somewhere (that's evil
 (Re)install Microsoft Visual C++ 2005 SP1 Redistributable (x86 or x64, depending on your system)
 
 3. Crashes immediately
-You CPU lacks SSE2 support. Build Assimp from scratch to suit your CPU, sorry.
\ No newline at end of file
+You CPU lacks SSE2 support. Build Assimp from scratch to suit your CPU, sorry.
diff --git a/port/PyAssimp/pyassimp/errors.py b/port/PyAssimp/pyassimp/errors.py
index 9d776860f..e017b5145 100644
--- a/port/PyAssimp/pyassimp/errors.py
+++ b/port/PyAssimp/pyassimp/errors.py
@@ -1,11 +1,11 @@
-#-*- coding: UTF-8 -*-
-
-"""
-All possible errors.
-"""
-
-class AssimpError(BaseException):
-    """
-    If an internal error occurs.
-    """
-    pass
\ No newline at end of file
+#-*- coding: UTF-8 -*-
+
+"""
+All possible errors.
+"""
+
+class AssimpError(BaseException):
+    """
+    If an internal error occurs.
+    """
+    pass
diff --git a/port/assimp_rs/Cargo.lock b/port/assimp_rs/Cargo.lock
new file mode 100644
index 000000000..4f571f362
--- /dev/null
+++ b/port/assimp_rs/Cargo.lock
@@ -0,0 +1,6 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "assimp_rs"
+version = "0.1.0"
+
diff --git a/port/assimp_rs/Cargo.toml b/port/assimp_rs/Cargo.toml
new file mode 100644
index 000000000..073a2b283
--- /dev/null
+++ b/port/assimp_rs/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "assimp_rs"
+version = "0.1.0"
+authors = ["David Golembiowski <dmgolembiowski@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/port/assimp_rs/src/camera/mod.rs b/port/assimp_rs/src/camera/mod.rs
new file mode 100644
index 000000000..26ca1185b
--- /dev/null
+++ b/port/assimp_rs/src/camera/mod.rs
@@ -0,0 +1 @@
+pub use self::structs::{Camera};
diff --git a/port/assimp_rs/src/core/mod.rs b/port/assimp_rs/src/core/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/errors/mod.rs b/port/assimp_rs/src/errors/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/formats/mod.rs b/port/assimp_rs/src/formats/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/lib.rs b/port/assimp_rs/src/lib.rs
new file mode 100644
index 000000000..dbb648876
--- /dev/null
+++ b/port/assimp_rs/src/lib.rs
@@ -0,0 +1,17 @@
+pub mod camera;
+pub mod core;
+pub mod errors;
+pub mod formats;
+pub mod material;
+pub mod postprocess;
+pub mod shims;
+pub mod socket;
+pub mod structs;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(true, true);
+    }
+}
diff --git a/port/assimp_rs/src/material/mod.rs b/port/assimp_rs/src/material/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/postprocess/mod.rs b/port/assimp_rs/src/postprocess/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/shims/mod.rs b/port/assimp_rs/src/shims/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/socket/mod.rs b/port/assimp_rs/src/socket/mod.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/anim/anim.rs b/port/assimp_rs/src/structs/anim/anim.rs
new file mode 100644
index 000000000..5374151eb
--- /dev/null
+++ b/port/assimp_rs/src/structs/anim/anim.rs
@@ -0,0 +1,44 @@
+pub struct Animation<'mA, 'mMA, 'nA> {
+    /* The name of the animation. If the modeling package this data was
+     * exported from does support only a single animation channel, this
+     * name is usually empty (length is zero).
+     */
+    m_name: Option<String>,
+    // Duration of the animation in ticks
+    m_duration: f64,
+    // Ticks per second. Zero (0.000... ticks/second) if not
+    // specified in the imported file
+    m_ticks_per_second: Option<f64>,
+    /* Number of bone animation channels.
+       Each channel affects a single node.
+       */
+    m_num_channels: u64,
+    /* Node animation channels. Each channel
+       affects a single node. 
+       ?? -> The array is m_num_channels in size.
+       (maybe refine to a derivative type of usize?)
+       */
+    m_channels: &'nA NodeAnim,
+    /* Number of mesh animation channels. Each
+       channel affects a single mesh and defines
+       vertex-based animation.
+       */
+    m_num_mesh_channels: u64,
+    /* The mesh animation channels. Each channel
+       affects a single mesh.
+       The array is m_num_mesh_channels in size
+       (maybe refine to a derivative of usize?)
+       */
+    m_mesh_channels: &'mA MeshAnim,
+    /* The number of mesh animation channels. Each channel
+       affects a single mesh and defines some morphing animation.
+       */
+    m_num_morph_mesh_channels: u64,
+    /* The morph mesh animation channels. Each channel affects a single mesh.
+       The array is mNumMorphMeshChannels in size.
+       */
+    m_morph_mesh_channels: &'mMA MeshMorphAnim    
+}
+pub struct NodeAnim {}
+pub struct MeshAnim {}
+pub struct MeshMorphAnim {}
diff --git a/port/assimp_rs/src/structs/anim/mod.rs b/port/assimp_rs/src/structs/anim/mod.rs
new file mode 100644
index 000000000..a0d4b7daf
--- /dev/null
+++ b/port/assimp_rs/src/structs/anim/mod.rs
@@ -0,0 +1,6 @@
+mod anim;
+pub use self::anim::{
+    Animation,
+    NodeAnim,
+    MeshAnim,
+    MeshMorphAnim};
diff --git a/port/assimp_rs/src/structs/blob/blob.rs b/port/assimp_rs/src/structs/blob/blob.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/blob/mod.rs b/port/assimp_rs/src/structs/blob/mod.rs
new file mode 100644
index 000000000..ad7612c0a
--- /dev/null
+++ b/port/assimp_rs/src/structs/blob/mod.rs
@@ -0,0 +1,2 @@
+mod blob;
+
diff --git a/port/assimp_rs/src/structs/bone/bone.rs b/port/assimp_rs/src/structs/bone/bone.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/bone/mod.rs b/port/assimp_rs/src/structs/bone/mod.rs
new file mode 100644
index 000000000..758a15afc
--- /dev/null
+++ b/port/assimp_rs/src/structs/bone/mod.rs
@@ -0,0 +1,2 @@
+mod bone;
+
diff --git a/port/assimp_rs/src/structs/camera/camera.rs b/port/assimp_rs/src/structs/camera/camera.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/camera/mod.rs b/port/assimp_rs/src/structs/camera/mod.rs
new file mode 100644
index 000000000..d4d79d026
--- /dev/null
+++ b/port/assimp_rs/src/structs/camera/mod.rs
@@ -0,0 +1,2 @@
+mod camera;
+
diff --git a/port/assimp_rs/src/structs/color/color.rs b/port/assimp_rs/src/structs/color/color.rs
new file mode 100644
index 000000000..0b5fc6413
--- /dev/null
+++ b/port/assimp_rs/src/structs/color/color.rs
@@ -0,0 +1,27 @@
+#[derive(Clone, Debug, Copy)]
+struct Color3D {
+    r: f32,
+    g: f32,
+    b: f32
+}
+
+impl Color3D {
+    pub fn new(r_f32: f32, g_f32: f32, b_f32: f32) -> Color3D {
+        Color3D {r: r_f32, g: g_f32, b: b_f32 }
+    }
+}
+
+#[derive(Clone, Debug, Copy)]
+struct Color4D {
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32
+}
+
+impl Color4D {
+    pub fn new(r_f32: f32, g_f32: f32, b_f32: f32, a_f32: f32) -> Color4D {
+        Color4D {r: r_f32, g: g_f32, b: b_f32, a: a_f32 }
+    }
+}
+
diff --git a/port/assimp_rs/src/structs/color/mod.rs b/port/assimp_rs/src/structs/color/mod.rs
new file mode 100644
index 000000000..d88527ed1
--- /dev/null
+++ b/port/assimp_rs/src/structs/color/mod.rs
@@ -0,0 +1,5 @@
+mod color;
+pub use self::color::{
+    Color3D,
+    Color4D
+};
diff --git a/port/assimp_rs/src/structs/face/face.rs b/port/assimp_rs/src/structs/face/face.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/face/mod.rs b/port/assimp_rs/src/structs/face/mod.rs
new file mode 100644
index 000000000..ae5aa5bdb
--- /dev/null
+++ b/port/assimp_rs/src/structs/face/mod.rs
@@ -0,0 +1,2 @@
+mod face;
+
diff --git a/port/assimp_rs/src/structs/key/key.rs b/port/assimp_rs/src/structs/key/key.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/key/mod.rs b/port/assimp_rs/src/structs/key/mod.rs
new file mode 100644
index 000000000..b23779d35
--- /dev/null
+++ b/port/assimp_rs/src/structs/key/mod.rs
@@ -0,0 +1,2 @@
+mod key;
+
diff --git a/port/assimp_rs/src/structs/light/light.rs b/port/assimp_rs/src/structs/light/light.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/light/mod.rs b/port/assimp_rs/src/structs/light/mod.rs
new file mode 100644
index 000000000..a68b51970
--- /dev/null
+++ b/port/assimp_rs/src/structs/light/mod.rs
@@ -0,0 +1,2 @@
+mod light;
+
diff --git a/port/assimp_rs/src/structs/material/material.rs b/port/assimp_rs/src/structs/material/material.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/material/mod.rs b/port/assimp_rs/src/structs/material/mod.rs
new file mode 100644
index 000000000..54de8b399
--- /dev/null
+++ b/port/assimp_rs/src/structs/material/mod.rs
@@ -0,0 +1,2 @@
+mod material;
+
diff --git a/port/assimp_rs/src/structs/matrix/matrix.rs b/port/assimp_rs/src/structs/matrix/matrix.rs
new file mode 100644
index 000000000..4673b2d69
--- /dev/null
+++ b/port/assimp_rs/src/structs/matrix/matrix.rs
@@ -0,0 +1,64 @@
+#[derive(Clone, Debug, Copy)]
+struct Matrix3x3 {
+    a1: f32,
+    a2: f32,
+    a3: f32,
+    b1: f32,
+    b2: f32,
+    b3: f32,
+    c1: f32,
+    c2: f32,
+    c3: f32
+}
+
+#[derive(Clone, Debug, Copy)]
+struct Matrix4x4 {
+    a1: f32,
+    a2: f32,
+    a3: f32,
+    a4: f32,
+    b1: f32,
+    b2: f32,
+    b3: f32,
+    b4: f32,
+    c1: f32,
+    c2: f32,
+    c3: f32,
+    c4: f32,
+    d1: f32,
+    d2: f32,
+    d3: f32,
+    d4: f32
+}
+
+impl Matrix3x3 {
+    pub fn new(
+        a1_f32: f32, a2_f32: f32, a3_f32: f32,
+        b1_f32: f32, b2_f32: f32, b3_f32: f32,
+        c1_f32: f32, c2_f32: f32, c3_f32: f32
+    ) -> Matrix3x3 {
+        Matrix3x3 {
+            a1: a1_f32, a2: a2_f32, a3: a3_f32,
+            b1: b1_f32, b2: b2_f32, b3: b3_f32,
+            c1: c1_f32, c2: c2_f32, c3: c3_f32
+        }
+    }
+}
+
+impl Matrix4x4 {
+    pub fn new(
+        a1_f32: f32, a2_f32: f32, a3_f32: f32, a4_f32: f32,
+        b1_f32: f32, b2_f32: f32, b3_f32: f32, b4_f32: f32,
+        c1_f32: f32, c2_f32: f32, c3_f32: f32, c4_f32: f32,
+        d1_f32: f32, d2_f32: f32, d3_f32: f32, d4_f32: f32
+    ) -> Matrix4x4 {
+        Matrix4x4 {
+            a1: a1_f32, a2: a2_f32, a3: a3_f32, a4: a4_f32,
+            b1: b1_f32, b2: b2_f32, b3: b3_f32, b4: b4_f32,
+            c1: c1_f32, c2: c2_f32, c3: c3_f32, c4: c4_f32,
+            d1: d1_f32, d2: d2_f32, d3: d3_f32, d4: d4_f32 
+        }
+    }
+}
+
+
diff --git a/port/assimp_rs/src/structs/matrix/mod.rs b/port/assimp_rs/src/structs/matrix/mod.rs
new file mode 100644
index 000000000..b0fb1e1f9
--- /dev/null
+++ b/port/assimp_rs/src/structs/matrix/mod.rs
@@ -0,0 +1,4 @@
+mod matrix;
+pub use self::matrix::{
+    Matrix3x3,
+    Matrix4x4};
diff --git a/port/assimp_rs/src/structs/memory/memory.rs b/port/assimp_rs/src/structs/memory/memory.rs
new file mode 100644
index 000000000..c076f172a
--- /dev/null
+++ b/port/assimp_rs/src/structs/memory/memory.rs
@@ -0,0 +1,35 @@
+#[derive(Clone, Debug, Copy)]
+struct MemoryInfo {
+    textures: u32,
+    materials: u32,
+    meshes: u32,
+    nodes: u32,
+    animations: u32,
+    cameras: u32,
+    lights: u32,
+    total: u32
+}
+
+impl MemoryInfo {
+    pub fn new(
+            textures_uint: u32,
+            materials_uint: u32,
+            meshes_uint: u32,
+            nodes_uint: u32,
+            animations_uint: u32,
+            cameras_uint: u32,
+            lights_uint: u32,
+            total_uint: u32) -> MemoryInfo {
+        
+        MemoryInfo {
+            textures: textures_uint,
+            materials: materials_uint,
+            meshes: meshes_uint,
+            nodes: nodes_uint,
+            animations: animations_uint,
+            cameras: cameras_uint,
+            lights: lights_uint,
+            total: total_uint
+        }
+    }
+}
diff --git a/port/assimp_rs/src/structs/memory/mod.rs b/port/assimp_rs/src/structs/memory/mod.rs
new file mode 100644
index 000000000..8c8c31ce8
--- /dev/null
+++ b/port/assimp_rs/src/structs/memory/mod.rs
@@ -0,0 +1,2 @@
+mod memory;
+pub use self::memory::MemoryInfo;
diff --git a/port/assimp_rs/src/structs/mesh/mesh.rs b/port/assimp_rs/src/structs/mesh/mesh.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/mesh/mod.rs b/port/assimp_rs/src/structs/mesh/mod.rs
new file mode 100644
index 000000000..1c3ef651d
--- /dev/null
+++ b/port/assimp_rs/src/structs/mesh/mod.rs
@@ -0,0 +1,3 @@
+mod mesh;
+
+
diff --git a/port/assimp_rs/src/structs/meta/meta.rs b/port/assimp_rs/src/structs/meta/meta.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/meta/mod.rs b/port/assimp_rs/src/structs/meta/mod.rs
new file mode 100644
index 000000000..045294772
--- /dev/null
+++ b/port/assimp_rs/src/structs/meta/mod.rs
@@ -0,0 +1,2 @@
+mod meta;
+
diff --git a/port/assimp_rs/src/structs/mod.rs b/port/assimp_rs/src/structs/mod.rs
new file mode 100644
index 000000000..fd9087648
--- /dev/null
+++ b/port/assimp_rs/src/structs/mod.rs
@@ -0,0 +1,61 @@
+mod anim;
+/* Animation
+ * NodeAnim
+ * MeshAnim
+ * MeshMorphAnim
+ */
+mod blob;
+/* ExportDataBlob
+ */
+mod vec;
+/* Vector2d
+ * Vector3d
+ * */
+mod matrix;
+/* Matrix3by3
+ * Matrix4by4
+ */
+mod camera;
+/* Camera */
+mod color;
+/* Color3d
+ * Color4d
+ */
+mod key;
+/* MeshKey
+ * MeshMorphKey
+ * QuatKey
+ * VectorKey
+ */
+mod texel;
+mod plane;
+mod string;
+/* String
+ */
+mod material;
+/* Material
+ * MaterialPropery
+ * MaterialPropertyString
+ */
+mod mem;
+mod quaternion;
+mod face;
+mod vertex_weight;
+mod mesh;
+/* Mesh
+ */
+mod meta;
+/* Metadata
+ * MetadataEntry
+ */
+mod node;
+/* Node
+ * */
+mod light;
+mod texture;
+mod ray;
+mod transform;
+/* UVTransform */
+mod bone;
+mod scene;
+/* Scene */
diff --git a/port/assimp_rs/src/structs/node/mod.rs b/port/assimp_rs/src/structs/node/mod.rs
new file mode 100644
index 000000000..c1fc34cdb
--- /dev/null
+++ b/port/assimp_rs/src/structs/node/mod.rs
@@ -0,0 +1,2 @@
+mod node;
+
diff --git a/port/assimp_rs/src/structs/node/node.rs b/port/assimp_rs/src/structs/node/node.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/plane/mod.rs b/port/assimp_rs/src/structs/plane/mod.rs
new file mode 100644
index 000000000..c73a8ed45
--- /dev/null
+++ b/port/assimp_rs/src/structs/plane/mod.rs
@@ -0,0 +1,2 @@
+mod plane;
+
diff --git a/port/assimp_rs/src/structs/plane/plane.rs b/port/assimp_rs/src/structs/plane/plane.rs
new file mode 100644
index 000000000..2b0b74499
--- /dev/null
+++ b/port/assimp_rs/src/structs/plane/plane.rs
@@ -0,0 +1,23 @@
+#[derive(Clone, Debug, Copy)]
+struct Plane {
+    a: f32,
+    b: f32,
+    c: f32,
+    d: f32
+}
+
+impl Plane {
+    pub fn new(
+        a_f32: f32,
+        b_f32: f32,
+        c_f32: f32,
+        d_f32: f32
+    ) -> Plane {
+        Plane {
+            a: a_f32,
+            b: b_f32,
+            c: b_f32,
+            d: d_f32
+        }
+    }
+}
diff --git a/port/assimp_rs/src/structs/quaternion/mod.rs b/port/assimp_rs/src/structs/quaternion/mod.rs
new file mode 100644
index 000000000..bb2c0616c
--- /dev/null
+++ b/port/assimp_rs/src/structs/quaternion/mod.rs
@@ -0,0 +1,3 @@
+mod quaternion;
+
+pub use self::quaternion::Quaternion;
diff --git a/port/assimp_rs/src/structs/quaternion/quaternion.rs b/port/assimp_rs/src/structs/quaternion/quaternion.rs
new file mode 100644
index 000000000..970f5cce5
--- /dev/null
+++ b/port/assimp_rs/src/structs/quaternion/quaternion.rs
@@ -0,0 +1,7 @@
+use crate::vec;
+
+#[derive(Clone, Debug, Copy)]
+pub struct Quaternion {
+    _coordinates: vec::Vector4d
+
+}
diff --git a/port/assimp_rs/src/structs/ray/mod.rs b/port/assimp_rs/src/structs/ray/mod.rs
new file mode 100644
index 000000000..7f0be074e
--- /dev/null
+++ b/port/assimp_rs/src/structs/ray/mod.rs
@@ -0,0 +1,2 @@
+mod ray;
+
diff --git a/port/assimp_rs/src/structs/ray/ray.rs b/port/assimp_rs/src/structs/ray/ray.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/scene/mod.rs b/port/assimp_rs/src/structs/scene/mod.rs
new file mode 100644
index 000000000..5aea638ee
--- /dev/null
+++ b/port/assimp_rs/src/structs/scene/mod.rs
@@ -0,0 +1,2 @@
+mod scene;
+
diff --git a/port/assimp_rs/src/structs/scene/scene.rs b/port/assimp_rs/src/structs/scene/scene.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/string/mod.rs b/port/assimp_rs/src/structs/string/mod.rs
new file mode 100644
index 000000000..f599ba7cb
--- /dev/null
+++ b/port/assimp_rs/src/structs/string/mod.rs
@@ -0,0 +1,3 @@
+mod string;
+pub use self::string::MAXLEN;
+pub use self::string::Str;
diff --git a/port/assimp_rs/src/structs/string/string.rs b/port/assimp_rs/src/structs/string/string.rs
new file mode 100644
index 000000000..b88457df4
--- /dev/null
+++ b/port/assimp_rs/src/structs/string/string.rs
@@ -0,0 +1,41 @@
+pub const MAXLEN: usize = 1024;
+
+/// Want to consider replacing `Vec<char>`
+/// with a comparable definition at 
+/// https://doc.rust-lang.org/src/alloc/string.rs.html#415-417
+#[derive(Clone, Debug)]
+struct Str {
+    length: usize,
+    data: Vec<char>
+}
+
+impl Str {
+    pub fn new(len_u32: usize, data_string: String) -> Str {
+        Str {
+            length: len_u32,
+            data: data_string.chars().collect()
+        }
+    }
+}
+
+/// MaterialPropertyStr
+/// The size of length is truncated to 4 bytes on a 64-bit platform when used as a 
+/// material property (see MaterialSystem.cpp, as aiMaterial::AddProperty() ).
+#[derive(Clone, Debug)]
+struct MaterialPropertyStr {
+    length: usize,
+    data: Vec<char>
+}
+
+
+impl MaterialPropertyStr {
+    pub fn new(len_u32: usize, data_string: String) -> MaterialPropertyStr {
+        MaterialPropertyStr {
+            length: len_u32,
+            data: data_string.chars().collect()
+        }
+    }
+}
+
+   
+
diff --git a/port/assimp_rs/src/structs/texture/mod.rs b/port/assimp_rs/src/structs/texture/mod.rs
new file mode 100644
index 000000000..1b5c9308d
--- /dev/null
+++ b/port/assimp_rs/src/structs/texture/mod.rs
@@ -0,0 +1,3 @@
+mod texture;
+pub use self::texture::Texel;
+
diff --git a/port/assimp_rs/src/structs/texture/texture.rs b/port/assimp_rs/src/structs/texture/texture.rs
new file mode 100644
index 000000000..b2c72f30e
--- /dev/null
+++ b/port/assimp_rs/src/structs/texture/texture.rs
@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, Copy)]
+struct Texel {
+    b: u32,
+    g: u32,
+    r: u32,
+    a: u32
+}
+
+impl Texel {
+    pub fn new(b_u32: u32, g_u32: u32,
+               r_u32: u32, a_u32: u32) -> Texel {
+        Texel {
+            b: b_u32,
+            g: g_u32,
+            r: r_u32,
+            a: a_u32
+        }
+    }
+}
diff --git a/port/assimp_rs/src/structs/transform/mod.rs b/port/assimp_rs/src/structs/transform/mod.rs
new file mode 100644
index 000000000..b80c43dd0
--- /dev/null
+++ b/port/assimp_rs/src/structs/transform/mod.rs
@@ -0,0 +1,2 @@
+mod transform;
+
diff --git a/port/assimp_rs/src/structs/transform/transform.rs b/port/assimp_rs/src/structs/transform/transform.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/assimp_rs/src/structs/vec/mod.rs b/port/assimp_rs/src/structs/vec/mod.rs
new file mode 100644
index 000000000..3613d5d48
--- /dev/null
+++ b/port/assimp_rs/src/structs/vec/mod.rs
@@ -0,0 +1,2 @@
+mod vec;
+
diff --git a/port/assimp_rs/src/structs/vec/vec.rs b/port/assimp_rs/src/structs/vec/vec.rs
new file mode 100644
index 000000000..ee0d194de
--- /dev/null
+++ b/port/assimp_rs/src/structs/vec/vec.rs
@@ -0,0 +1,48 @@
+struct Vector2d {
+    x: f32,
+    y: f32
+}
+
+struct Vector3d {
+    x: f32,
+    y: f32,
+    z: f32
+}
+
+struct Vector4d {
+    x: f32,
+    y: f32,
+    z: f32,
+    w: f32
+}
+
+impl Vector2d {
+    pub fn new(x_f32: f32, y_f32: f32) -> Vector2d {
+        Vector2d {
+            x: x_f32,
+            y: y_f32
+        }
+    }
+}
+
+impl Vector3d {
+    pub fn new(x_f32: f32, y_f32: f32, z_f32: f32) -> Vector3d {
+        Vector3d {
+            x: x_f32,
+            y: y_f32,
+            z: z_f32
+        }
+    }
+}
+
+impl Vector4d {
+    pub fn new(x_f32: f32, y_f32: f32, z_f32: f32, w_f32: f32) -> Vector4d {
+        Vector4d {
+            x: x_f32,
+            y: y_f32,
+            z: z_f32,
+            w: w_f32
+        }
+    }
+}
+
diff --git a/port/assimp_rs/src/structs/vertex/mod.rs b/port/assimp_rs/src/structs/vertex/mod.rs
new file mode 100644
index 000000000..97ae3eced
--- /dev/null
+++ b/port/assimp_rs/src/structs/vertex/mod.rs
@@ -0,0 +1,2 @@
+mod vertex;
+// pub use self::vertex::
diff --git a/port/assimp_rs/src/structs/vertex/vertex.rs b/port/assimp_rs/src/structs/vertex/vertex.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/port/jassimp/jassimp/src/jassimp/AiAnimation.java b/port/jassimp/jassimp/src/jassimp/AiAnimation.java
index 239820aaf..856b918dd 100644
--- a/port/jassimp/jassimp/src/jassimp/AiAnimation.java
+++ b/port/jassimp/jassimp/src/jassimp/AiAnimation.java
@@ -172,4 +172,4 @@ public final class AiAnimation {
     public List<AiMeshAnim> getMeshChannels() {
         throw new UnsupportedOperationException("not implemented yet");
     }    
-}
\ No newline at end of file
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiBlendMode.java b/port/jassimp/jassimp/src/jassimp/AiBlendMode.java
index 78cc5a5ed..d3a0e0e96 100644
--- a/port/jassimp/jassimp/src/jassimp/AiBlendMode.java
+++ b/port/jassimp/jassimp/src/jassimp/AiBlendMode.java
@@ -114,4 +114,4 @@ public enum AiBlendMode {
     * The mapped c/c++ integer enum value.
     */
    private final int m_rawValue;
-}
\ No newline at end of file
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiCamera.java b/port/jassimp/jassimp/src/jassimp/AiCamera.java
index 4445c34fc..b0f692eda 100644
--- a/port/jassimp/jassimp/src/jassimp/AiCamera.java
+++ b/port/jassimp/jassimp/src/jassimp/AiCamera.java
@@ -300,4 +300,4 @@ public final class AiCamera {
      * Aspect ratio.
      */
     private final float m_aspect;
-}
\ No newline at end of file
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiProgressHandler.java b/port/jassimp/jassimp/src/jassimp/AiProgressHandler.java
index 7998d1bcc..2987e5976 100644
--- a/port/jassimp/jassimp/src/jassimp/AiProgressHandler.java
+++ b/port/jassimp/jassimp/src/jassimp/AiProgressHandler.java
@@ -43,4 +43,4 @@ package jassimp;
 public interface AiProgressHandler
 {
     boolean update(float percentage);
-}
\ No newline at end of file
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiQuaternion.java b/port/jassimp/jassimp/src/jassimp/AiQuaternion.java
index af10e6f91..a9ca7be79 100644
--- a/port/jassimp/jassimp/src/jassimp/AiQuaternion.java
+++ b/port/jassimp/jassimp/src/jassimp/AiQuaternion.java
@@ -162,4 +162,4 @@ public final class AiQuaternion {
         return "[" + getX() + ", " + getY() + ", " + getZ() + ", " + 
                 getW() + "]";
     }    
-}
\ No newline at end of file
+}
diff --git a/port/jassimp/jassimp/src/jassimp/AiTextureType.java b/port/jassimp/jassimp/src/jassimp/AiTextureType.java
index 85b559c30..6b3e642e0 100644
--- a/port/jassimp/jassimp/src/jassimp/AiTextureType.java
+++ b/port/jassimp/jassimp/src/jassimp/AiTextureType.java
@@ -209,4 +209,4 @@ public enum AiTextureType {
     * The mapped c/c++ integer enum value.
     */
    private final int m_rawValue;
-}
\ No newline at end of file
+}
diff --git a/port/swig/DONOTUSEYET b/port/swig/DONOTUSEYET
index be9103007..87c6e0699 100644
--- a/port/swig/DONOTUSEYET
+++ b/port/swig/DONOTUSEYET
@@ -1 +1 @@
-The interface files are by no means complete yet and only work with the not-yet-released D SWIG backend, although adding support for other languages should not be too much of problem via #ifdefs.
+The interface files are by no means complete yet and only work with the not-yet-released D SWIG backend, although adding support for other languages should not be too much of problem via #ifdefs.
diff --git a/samples/SimpleAssimpViewX/README b/samples/SimpleAssimpViewX/README
index 701a7cdce..dc513d7aa 100644
--- a/samples/SimpleAssimpViewX/README
+++ b/samples/SimpleAssimpViewX/README
@@ -19,4 +19,4 @@ Troubleshooting:
   - OSX workspaces are not updated too frequently, so same files may be missing.
 
 If you have any problems which you can't solve on your own, 
-please report them on the thread above.
\ No newline at end of file
+please report them on the thread above.
diff --git a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
index 90338105e..5cce7c376 100644
--- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
+++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
@@ -1,4 +1,4 @@
-// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // Simple Assimp Directx11 Sample
 // This is a very basic sample and only reads diffuse texture
 // but this can load both embedded textures in fbx and non-embedded textures
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index bf6694845..a5f8086e9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -124,8 +124,7 @@ SET( IMPORTERS
   unit/utBlendImportMaterials.cpp
   unit/utBlenderWork.cpp
   unit/utBVHImportExport.cpp
-  unit/utColladaExportCamera.cpp
-  unit/utColladaExportLight.cpp
+  unit/utColladaExport.cpp
   unit/utColladaImportExport.cpp
   unit/utCSMImportExport.cpp
   unit/utB3DImportExport.cpp
diff --git a/test/models-nonbsd/3DS/jeep1.3ds.readme.txt b/test/models-nonbsd/3DS/jeep1.3ds.readme.txt
index d17d5e0e9..f52ada0cc 100644
--- a/test/models-nonbsd/3DS/jeep1.3ds.readme.txt
+++ b/test/models-nonbsd/3DS/jeep1.3ds.readme.txt
@@ -12,4 +12,4 @@ http://xu1productions.com/3dstudio/index.html  -  3D Game Resources
 
 http://www.psionicdesign.com  -  My Main 2D/3D Digital Art site
 
-Psionic 2002
\ No newline at end of file
+Psionic 2002
diff --git a/test/models-nonbsd/3DS/pyramob.3ds.readme.txt b/test/models-nonbsd/3DS/pyramob.3ds.readme.txt
index bf1858410..2bf93aa64 100644
--- a/test/models-nonbsd/3DS/pyramob.3ds.readme.txt
+++ b/test/models-nonbsd/3DS/pyramob.3ds.readme.txt
@@ -9,4 +9,4 @@ http://www.elektrobar.com/lux/
 or mail to:
 lux@elektrobar.com
 
-have fun.....VIRLUX
\ No newline at end of file
+have fun.....VIRLUX
diff --git a/test/models-nonbsd/ASE/Rifle.source.txt b/test/models-nonbsd/ASE/Rifle.source.txt
index 04d40a85d..1b96f8564 100644
--- a/test/models-nonbsd/ASE/Rifle.source.txt
+++ b/test/models-nonbsd/ASE/Rifle.source.txt
@@ -22,4 +22,4 @@ tutorials.
 INFO
 ====
 
-CONVERTED FROM 3DS TO ASE WITH AC3D
\ No newline at end of file
+CONVERTED FROM 3DS TO ASE WITH AC3D
diff --git a/test/models-nonbsd/ASE/Rifle2.source.txt b/test/models-nonbsd/ASE/Rifle2.source.txt
index 2072ddf13..3fa628db4 100644
--- a/test/models-nonbsd/ASE/Rifle2.source.txt
+++ b/test/models-nonbsd/ASE/Rifle2.source.txt
@@ -21,4 +21,4 @@ tutorials.
 INFO
 ====
 
-CONVERTED FROM 3DS TO ASE WITH AC3D
\ No newline at end of file
+CONVERTED FROM 3DS TO ASE WITH AC3D
diff --git a/test/models-nonbsd/B3D/turtle.source.txt b/test/models-nonbsd/B3D/turtle.source.txt
index fab387bdc..cd93aa3d6 100644
--- a/test/models-nonbsd/B3D/turtle.source.txt
+++ b/test/models-nonbsd/B3D/turtle.source.txt
@@ -8,4 +8,4 @@ RESTRICTIONS:
 This model pack is available for use in freeware, shareware, commercial games/software with the following restrictions:-
 
 **You may not sell/re-sell this model pack or claim it as your own.
-***You may not redistribute this pack in  some other model pack through a website or on a compilation CD of any kind, without my written consent.
\ No newline at end of file
+***You may not redistribute this pack in  some other model pack through a website or on a compilation CD of any kind, without my written consent.
diff --git a/test/models-nonbsd/DXF/rifle.source.txt b/test/models-nonbsd/DXF/rifle.source.txt
index 3e88f009f..a2585afad 100644
--- a/test/models-nonbsd/DXF/rifle.source.txt
+++ b/test/models-nonbsd/DXF/rifle.source.txt
@@ -20,4 +20,4 @@ tutorials.
 INFO
 ====
 
-COnverted from 3ds to DXF with Ac3D
\ No newline at end of file
+COnverted from 3ds to DXF with Ac3D
diff --git a/test/models-nonbsd/FBX/2013_ASCII/jeep1.fbx.readme.txt b/test/models-nonbsd/FBX/2013_ASCII/jeep1.fbx.readme.txt
index d17d5e0e9..f52ada0cc 100644
--- a/test/models-nonbsd/FBX/2013_ASCII/jeep1.fbx.readme.txt
+++ b/test/models-nonbsd/FBX/2013_ASCII/jeep1.fbx.readme.txt
@@ -12,4 +12,4 @@ http://xu1productions.com/3dstudio/index.html  -  3D Game Resources
 
 http://www.psionicdesign.com  -  My Main 2D/3D Digital Art site
 
-Psionic 2002
\ No newline at end of file
+Psionic 2002
diff --git a/test/models-nonbsd/FBX/2013_ASCII/pyramob.fbx.readme.txt b/test/models-nonbsd/FBX/2013_ASCII/pyramob.fbx.readme.txt
index bf1858410..2bf93aa64 100644
--- a/test/models-nonbsd/FBX/2013_ASCII/pyramob.fbx.readme.txt
+++ b/test/models-nonbsd/FBX/2013_ASCII/pyramob.fbx.readme.txt
@@ -9,4 +9,4 @@ http://www.elektrobar.com/lux/
 or mail to:
 lux@elektrobar.com
 
-have fun.....VIRLUX
\ No newline at end of file
+have fun.....VIRLUX
diff --git a/test/models-nonbsd/FBX/2013_BINARY/jeep1.fbx.readme.txt b/test/models-nonbsd/FBX/2013_BINARY/jeep1.fbx.readme.txt
index d17d5e0e9..f52ada0cc 100644
--- a/test/models-nonbsd/FBX/2013_BINARY/jeep1.fbx.readme.txt
+++ b/test/models-nonbsd/FBX/2013_BINARY/jeep1.fbx.readme.txt
@@ -12,4 +12,4 @@ http://xu1productions.com/3dstudio/index.html  -  3D Game Resources
 
 http://www.psionicdesign.com  -  My Main 2D/3D Digital Art site
 
-Psionic 2002
\ No newline at end of file
+Psionic 2002
diff --git a/test/models-nonbsd/FBX/2013_BINARY/pyramob.fbx.readme.txt b/test/models-nonbsd/FBX/2013_BINARY/pyramob.fbx.readme.txt
index bf1858410..2bf93aa64 100644
--- a/test/models-nonbsd/FBX/2013_BINARY/pyramob.fbx.readme.txt
+++ b/test/models-nonbsd/FBX/2013_BINARY/pyramob.fbx.readme.txt
@@ -9,4 +9,4 @@ http://www.elektrobar.com/lux/
 or mail to:
 lux@elektrobar.com
 
-have fun.....VIRLUX
\ No newline at end of file
+have fun.....VIRLUX
diff --git a/test/models-nonbsd/IFC/linklist.txt b/test/models-nonbsd/IFC/linklist.txt
index 06ad3844b..6971b7a45 100644
--- a/test/models-nonbsd/IFC/linklist.txt
+++ b/test/models-nonbsd/IFC/linklist.txt
@@ -1,4 +1,4 @@
 Good IFC test cases
 ===================
 
-http://www.iai.fzk.de/www-extern/index.php?id=1135
\ No newline at end of file
+http://www.iai.fzk.de/www-extern/index.php?id=1135
diff --git a/test/models-nonbsd/LWO/LWO2/LWSReferences/QuickDraw.source.txt b/test/models-nonbsd/LWO/LWO2/LWSReferences/QuickDraw.source.txt
index bb07f8e24..aaa244217 100644
--- a/test/models-nonbsd/LWO/LWO2/LWSReferences/QuickDraw.source.txt
+++ b/test/models-nonbsd/LWO/LWO2/LWSReferences/QuickDraw.source.txt
@@ -28,4 +28,4 @@ INFO
 
 
 These files belong to the QuickDraw model in the LWS folder - they are referenced
-and loaded into the LWS scene.
\ No newline at end of file
+and loaded into the LWS scene.
diff --git a/test/models-nonbsd/LWO/LWO2/rifle.source.txt b/test/models-nonbsd/LWO/LWO2/rifle.source.txt
index 34576f0ca..5523bbc0c 100644
--- a/test/models-nonbsd/LWO/LWO2/rifle.source.txt
+++ b/test/models-nonbsd/LWO/LWO2/rifle.source.txt
@@ -21,4 +21,4 @@ tutorials.
 INFO
 ====
 
-CONVERTED FROM 3DS TO LWO2 WITH AC3D
\ No newline at end of file
+CONVERTED FROM 3DS TO LWO2 WITH AC3D
diff --git a/test/models-nonbsd/LWS/QuickDraw v2.2.source.txt b/test/models-nonbsd/LWS/QuickDraw v2.2.source.txt
index e0c7d0f7c..92ac5d882 100644
--- a/test/models-nonbsd/LWS/QuickDraw v2.2.source.txt	
+++ b/test/models-nonbsd/LWS/QuickDraw v2.2.source.txt	
@@ -12,4 +12,4 @@ In the future more 3d formats will be added and some other sections such as wall
 
 
 CHANGES:
-Paths have been modified
\ No newline at end of file
+Paths have been modified
diff --git a/test/models-nonbsd/MD3/q3root/models/mapobjects/kt_kubalwagon/readme_kubalwagon.txt b/test/models-nonbsd/MD3/q3root/models/mapobjects/kt_kubalwagon/readme_kubalwagon.txt
index e0a978ee0..54fbcbd7f 100644
--- a/test/models-nonbsd/MD3/q3root/models/mapobjects/kt_kubalwagon/readme_kubalwagon.txt
+++ b/test/models-nonbsd/MD3/q3root/models/mapobjects/kt_kubalwagon/readme_kubalwagon.txt
@@ -23,4 +23,4 @@ ID software, eskimo roll, EMSIPE, QkenneyQ
 DISTRIBUTION
 as long as this readme is included...!
 
---------------------------------------------------------------------------
\ No newline at end of file
+--------------------------------------------------------------------------
diff --git a/test/models-nonbsd/MD3/readme_water.txt b/test/models-nonbsd/MD3/readme_water.txt
index cdc318ff8..c5346261d 100644
--- a/test/models-nonbsd/MD3/readme_water.txt
+++ b/test/models-nonbsd/MD3/readme_water.txt
@@ -23,4 +23,4 @@ ID software, eskimo roll, EMSIPE, QkenneyQ
 DISTRIBUTION
 as long as this readme is included...!
 
---------------------------------------------------------------------------
\ No newline at end of file
+--------------------------------------------------------------------------
diff --git a/test/models-nonbsd/MMD/readme.txt b/test/models-nonbsd/MMD/readme.txt
index d8c882420..909beee00 100644
--- a/test/models-nonbsd/MMD/readme.txt
+++ b/test/models-nonbsd/MMD/readme.txt
@@ -46,4 +46,4 @@ version 4
 ◯ クレジット
 企画: 株式会社ドワンゴ
 キャラクターデザイン: 黒星紅白
-モデリング: 雨刻
\ No newline at end of file
+モデリング: 雨刻
diff --git a/test/models-nonbsd/NFF/NFFSense8/credits.txt b/test/models-nonbsd/NFF/NFFSense8/credits.txt
index ff169151d..f3cef4d09 100644
--- a/test/models-nonbsd/NFF/NFFSense8/credits.txt
+++ b/test/models-nonbsd/NFF/NFFSense8/credits.txt
@@ -1,4 +1,4 @@
 teapot.nff, home4.nff - http://www.martinreddy.net/ukvrsig/wtk.html
 
 cokecan.nff -www.vrupl.evl.uic.edu/Eng591_Pages/cokecan.nff 
-TODO: License status to be confirmed
\ No newline at end of file
+TODO: License status to be confirmed
diff --git a/test/models-nonbsd/OBJ/rifle.source.txt b/test/models-nonbsd/OBJ/rifle.source.txt
index b09dcda8c..1d2cec5cf 100644
--- a/test/models-nonbsd/OBJ/rifle.source.txt
+++ b/test/models-nonbsd/OBJ/rifle.source.txt
@@ -24,4 +24,4 @@ tutorials.
 INFO
 ====
 
-Converted from 3DS to OBJ with AC3D
\ No newline at end of file
+Converted from 3DS to OBJ with AC3D
diff --git a/test/models-nonbsd/OBJ/segment.source.txt b/test/models-nonbsd/OBJ/segment.source.txt
index 978d72d26..204bc140e 100644
--- a/test/models-nonbsd/OBJ/segment.source.txt
+++ b/test/models-nonbsd/OBJ/segment.source.txt
@@ -1,4 +1,4 @@
 Obj exported from Blender
 
 http://toychest.in.tum.de/wiki/projects:kuka_lwr
-License: Creative-Commons-by-Attribution-3.0
\ No newline at end of file
+License: Creative-Commons-by-Attribution-3.0
diff --git a/test/models-nonbsd/Ogre/OgreSDK/LICENSE b/test/models-nonbsd/Ogre/OgreSDK/LICENSE
index e7e8f4280..ccdfb00fa 100644
--- a/test/models-nonbsd/Ogre/OgreSDK/LICENSE
+++ b/test/models-nonbsd/Ogre/OgreSDK/LICENSE
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
\ No newline at end of file
+THE SOFTWARE.
diff --git a/test/models-nonbsd/Ogre/OgreSDK/README.md b/test/models-nonbsd/Ogre/OgreSDK/README.md
index e7a838cb0..864536558 100644
--- a/test/models-nonbsd/Ogre/OgreSDK/README.md
+++ b/test/models-nonbsd/Ogre/OgreSDK/README.md
@@ -7,4 +7,4 @@ This asset set is used to test the full functionality of both binary and XML Ass
 * Material file was created by copying the relevant material parts from the sample sources. See the file for further information.
 * Some textures were converted from .png to .jpg to reduce the file size.
 
-See the LICENSE file in this folder for further copyright information about these assets.
\ No newline at end of file
+See the LICENSE file in this folder for further copyright information about these assets.
diff --git a/test/models-nonbsd/README.txt b/test/models-nonbsd/README.txt
index 8b244d2aa..aac170708 100644
--- a/test/models-nonbsd/README.txt
+++ b/test/models-nonbsd/README.txt
@@ -1,3 +1,3 @@
 These models are not generally redistributable under the terms of Assimp's BSD license. Usually, an additional requirement on the use of the data is imposed (i.e. no commercial use, need credits, some creative commons variants, ...).
 
-So, if you re-package Assimp for use in a 'clean' OSS package, consider removing this directory.
\ No newline at end of file
+So, if you re-package Assimp for use in a 'clean' OSS package, consider removing this directory.
diff --git a/test/models/3DS/UVTransformTest/note.txt b/test/models/3DS/UVTransformTest/note.txt
index dc4bd0789..4c8bfedd2 100644
--- a/test/models/3DS/UVTransformTest/note.txt
+++ b/test/models/3DS/UVTransformTest/note.txt
@@ -8,4 +8,4 @@ In other words: TO DO, but only if someone REALLY needs it.
 
 To see how it should look like - test/ReferenceImages
 Note that the viewer has no 'decal' texture mapping mode, so
-the usual clamping is used.
\ No newline at end of file
+the usual clamping is used.
diff --git a/test/models/3DS/textures.txt b/test/models/3DS/textures.txt
index 18bbd8f90..136322bea 100644
--- a/test/models/3DS/textures.txt
+++ b/test/models/3DS/textures.txt
@@ -1 +1 @@
-All textures are from cgtextures.com and are free for commercial use
\ No newline at end of file
+All textures are from cgtextures.com and are free for commercial use
diff --git a/test/models/ASE/MotionCaptureROM.source.txt b/test/models/ASE/MotionCaptureROM.source.txt
index 222a3afbb..2b961906a 100644
--- a/test/models/ASE/MotionCaptureROM.source.txt
+++ b/test/models/ASE/MotionCaptureROM.source.txt
@@ -1,3 +1,3 @@
 "MotionCaptureROM.ase" - Free for any purpose. 
 
-NOTE: The errors in the middle of the animation are caused by problems during recording, it's not an importer issue.
\ No newline at end of file
+NOTE: The errors in the middle of the animation are caused by problems during recording, it's not an importer issue.
diff --git a/test/models/BLEND/HUMAN.source.txt b/test/models/BLEND/HUMAN.source.txt
index 9409b46d3..a19c52468 100644
--- a/test/models/BLEND/HUMAN.source.txt
+++ b/test/models/BLEND/HUMAN.source.txt
@@ -1,3 +1,3 @@
 HUMAN.blend (c) 2010, Tobias Rittig
 
-Redistribution and reuse allowed for any purpose, credits appreciated.
\ No newline at end of file
+Redistribution and reuse allowed for any purpose, credits appreciated.
diff --git a/test/models/BVH/01_nn.bvh.source.txt b/test/models/BVH/01_nn.bvh.source.txt
index e538020a2..fc450d15d 100644
--- a/test/models/BVH/01_nn.bvh.source.txt
+++ b/test/models/BVH/01_nn.bvh.source.txt
@@ -47,4 +47,4 @@ Here's the relevant paragraph from mocap.cs.cmu.edu:
   obtained from mocap.cs.cmu.edu.  The database was created with funding
   from NSF EIA-0196217."
 
-[...]
\ No newline at end of file
+[...]
diff --git a/test/models/CSM/ThomasFechten.source.txt b/test/models/CSM/ThomasFechten.source.txt
index 529560ced..cf60674d8 100644
--- a/test/models/CSM/ThomasFechten.source.txt
+++ b/test/models/CSM/ThomasFechten.source.txt
@@ -1 +1 @@
-Recorded with vicon IQ, july 2008. Free for any purpose.
\ No newline at end of file
+Recorded with vicon IQ, july 2008. Free for any purpose.
diff --git a/test/models/IRRMesh/credits.txt b/test/models/IRRMesh/credits.txt
index a12163233..504746814 100644
--- a/test/models/IRRMesh/credits.txt
+++ b/test/models/IRRMesh/credits.txt
@@ -1,2 +1,2 @@
 cellar.irrmesh - From irrlight/irrEdit. Irrlicht/irredit license (which?)
-Textures resized to 400*400, improved JPEG compression to make them smaller
\ No newline at end of file
+Textures resized to 400*400, improved JPEG compression to make them smaller
diff --git a/test/models/LWO/LWO2/MappingModes/earthCylindric.txt b/test/models/LWO/LWO2/MappingModes/earthCylindric.txt
index 46660a486..18ea94ea2 100644
--- a/test/models/LWO/LWO2/MappingModes/earthCylindric.txt
+++ b/test/models/LWO/LWO2/MappingModes/earthCylindric.txt
@@ -2,4 +2,4 @@ Wikipedia Commons,
 downloaded November 25th 08
 
 
-http://upload.wikimedia.org/wikipedia/commons/0/01/Lambert-cylindrical-equal-area-projection.jpg
\ No newline at end of file
+http://upload.wikimedia.org/wikipedia/commons/0/01/Lambert-cylindrical-equal-area-projection.jpg
diff --git a/test/models/LWO/LWO2/MappingModes/earthSpherical.source.txt b/test/models/LWO/LWO2/MappingModes/earthSpherical.source.txt
index 218b339e1..db055ea0f 100644
--- a/test/models/LWO/LWO2/MappingModes/earthSpherical.source.txt
+++ b/test/models/LWO/LWO2/MappingModes/earthSpherical.source.txt
@@ -6,4 +6,4 @@ http://earthobservatory.nasa.gov/Features/BlueMarble/BlueMarble_monthlies.php
 
 
 Downloaded November 24, 08.
-Rescaled to 2048 * 1024 with GIMP
\ No newline at end of file
+Rescaled to 2048 * 1024 with GIMP
diff --git a/test/models/LWO/LWO2/concrete.source.txt b/test/models/LWO/LWO2/concrete.source.txt
index 2904ae998..90fc73e2d 100644
--- a/test/models/LWO/LWO2/concrete.source.txt
+++ b/test/models/LWO/LWO2/concrete.source.txt
@@ -1,2 +1,2 @@
 cgtextures.com - free, even for commercial use. See the licensing conditions and the FAQ the site for more details.
-Great source for free textures, btw!
\ No newline at end of file
+Great source for free textures, btw!
diff --git a/test/models/LWO/LWO2/uvtest-source.txt b/test/models/LWO/LWO2/uvtest-source.txt
index 75e4878a7..654d62180 100644
--- a/test/models/LWO/LWO2/uvtest-source.txt
+++ b/test/models/LWO/LWO2/uvtest-source.txt
@@ -1,2 +1,2 @@
 Regression file.
-by Tom Speed, see http://groups.google.com/group/bmx3d/browse_thread/thread/36db3b191f81be36
\ No newline at end of file
+by Tom Speed, see http://groups.google.com/group/bmx3d/browse_thread/thread/36db3b191f81be36
diff --git a/test/models/MD2/faerie-source.txt b/test/models/MD2/faerie-source.txt
index ef0e4f196..4906ff4d1 100644
--- a/test/models/MD2/faerie-source.txt
+++ b/test/models/MD2/faerie-source.txt
@@ -21,4 +21,4 @@ The Irrlicht Engine License
      appreciated but is not required.
   2. Altered source versions must be clearly marked as such, and must not be
      misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
\ No newline at end of file
+  3. This notice may not be removed or altered from any source distribution.
diff --git a/test/models/MD2/sidney-source.txt b/test/models/MD2/sidney-source.txt
index ef0e4f196..4906ff4d1 100644
--- a/test/models/MD2/sidney-source.txt
+++ b/test/models/MD2/sidney-source.txt
@@ -21,4 +21,4 @@ The Irrlicht Engine License
      appreciated but is not required.
   2. Altered source versions must be clearly marked as such, and must not be
      misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
\ No newline at end of file
+  3. This notice may not be removed or altered from any source distribution.
diff --git a/test/models/MD5/SimpleCube.source.txt b/test/models/MD5/SimpleCube.source.txt
index 6f51bc1cf..77d151ed7 100644
--- a/test/models/MD5/SimpleCube.source.txt
+++ b/test/models/MD5/SimpleCube.source.txt
@@ -1 +1 @@
-From http://www.doom3world.org/phpbb2/viewtopic.php?f=3&t=16842 (thanks, Rayne, whoever you are)
\ No newline at end of file
+From http://www.doom3world.org/phpbb2/viewtopic.php?f=3&t=16842 (thanks, Rayne, whoever you are)
diff --git a/test/models/MDL/MDL3 (3DGS A4)/minigun_readme.txt b/test/models/MDL/MDL3 (3DGS A4)/minigun_readme.txt
index c2ca7c696..4d36f8cbb 100644
--- a/test/models/MDL/MDL3 (3DGS A4)/minigun_readme.txt	
+++ b/test/models/MDL/MDL3 (3DGS A4)/minigun_readme.txt	
@@ -3,4 +3,4 @@ Hi everybody!!!
 This is my first published model so it isn't very good,but i'm still learning!..
 This model is free for everybody,but credit will be nice!
 You may reach me at rojkov91@mail.ru
-P.S: Excuse my bad english
\ No newline at end of file
+P.S: Excuse my bad english
diff --git a/test/models/MDL/MDL5 (3DGS A5)/minigun_mdl5_readme.txt b/test/models/MDL/MDL5 (3DGS A5)/minigun_mdl5_readme.txt
index c2ca7c696..4d36f8cbb 100644
--- a/test/models/MDL/MDL5 (3DGS A5)/minigun_mdl5_readme.txt	
+++ b/test/models/MDL/MDL5 (3DGS A5)/minigun_mdl5_readme.txt	
@@ -3,4 +3,4 @@ Hi everybody!!!
 This is my first published model so it isn't very good,but i'm still learning!..
 This model is free for everybody,but credit will be nice!
 You may reach me at rojkov91@mail.ru
-P.S: Excuse my bad english
\ No newline at end of file
+P.S: Excuse my bad english
diff --git a/test/models/MS3D/jeep1.readme.txt b/test/models/MS3D/jeep1.readme.txt
index d17d5e0e9..f52ada0cc 100644
--- a/test/models/MS3D/jeep1.readme.txt
+++ b/test/models/MS3D/jeep1.readme.txt
@@ -12,4 +12,4 @@ http://xu1productions.com/3dstudio/index.html  -  3D Game Resources
 
 http://www.psionicdesign.com  -  My Main 2D/3D Digital Art site
 
-Psionic 2002
\ No newline at end of file
+Psionic 2002
diff --git a/test/models/Q3D/E-AT-AT.source.txt b/test/models/Q3D/E-AT-AT.source.txt
index 56a96f7d5..2df8826f1 100644
--- a/test/models/Q3D/E-AT-AT.source.txt
+++ b/test/models/Q3D/E-AT-AT.source.txt
@@ -5,4 +5,4 @@ Downloaded 4th November 08 (Obama ftw!)
 Copyright notice found on the page:
 
 Where do the models in the archive come from?
-All 3D files available from the3darchive.com are from the public domain. 
\ No newline at end of file
+All 3D files available from the3darchive.com are from the public domain. 
diff --git a/test/models/Q3D/earth.source.txt b/test/models/Q3D/earth.source.txt
index 56a96f7d5..2df8826f1 100644
--- a/test/models/Q3D/earth.source.txt
+++ b/test/models/Q3D/earth.source.txt
@@ -5,4 +5,4 @@ Downloaded 4th November 08 (Obama ftw!)
 Copyright notice found on the page:
 
 Where do the models in the archive come from?
-All 3D files available from the3darchive.com are from the public domain. 
\ No newline at end of file
+All 3D files available from the3darchive.com are from the public domain. 
diff --git a/test/models/X/BCN_Epileptic.txt b/test/models/X/BCN_Epileptic.txt
index 1538e59fb..398d21b86 100644
--- a/test/models/X/BCN_Epileptic.txt
+++ b/test/models/X/BCN_Epileptic.txt
@@ -1 +1 @@
-A human body separated into three meshes: lower body, upper body, head. A common bone hierarchy for all three meshes, plus an test animation that makes the body sort of jump. No material information exported.
\ No newline at end of file
+A human body separated into three meshes: lower body, upper body, head. A common bone hierarchy for all three meshes, plus an test animation that makes the body sort of jump. No material information exported.
diff --git a/test/models/X/anim_test.txt b/test/models/X/anim_test.txt
index 637ea0581..3d270dc7d 100644
--- a/test/models/X/anim_test.txt
+++ b/test/models/X/anim_test.txt
@@ -6,4 +6,4 @@ Frame 18 - 24: Zylinder-Spitze bewegt sich zu Position in Richtung x+
 
 Remarks: The exporter failed here for some reasons... although the mesh referres to four bones, only two of them are stored in the corresponding node hierarchy. So you have a mesh with 4 bones, a hirarchy with 2 nodes and a animation that affects only those two nodes. 
 
-There is no timing given for the animation. You have to scale the animation manually. For this file, the timing seems to be 24 ticks per second.
\ No newline at end of file
+There is no timing given for the animation. You have to scale the animation manually. For this file, the timing seems to be 24 ticks per second.
diff --git a/test/models/X/test.txt b/test/models/X/test.txt
index 7a5e8e74b..eaf9d9c3c 100644
--- a/test/models/X/test.txt
+++ b/test/models/X/test.txt
@@ -1,3 +1,3 @@
 Simple textured test cube exported from Maya. Has a texture that does label each cube side uniquely, but the sides do not match DirectX coordinate space.
 
-Is not readable using D3DXLoadFrameHierarchy, needs custom text parsing. 
\ No newline at end of file
+Is not readable using D3DXLoadFrameHierarchy, needs custom text parsing. 
diff --git a/test/regression/result_checker.py b/test/regression/result_checker.py
index 19772f8af..1b01c52e6 100644
--- a/test/regression/result_checker.py
+++ b/test/regression/result_checker.py
@@ -110,4 +110,4 @@ def run():
 if __name__ == "__main__":
     sys.exit(run())
 
-# vim: ai ts=4 sts=4 et sw=4
\ No newline at end of file
+# vim: ai ts=4 sts=4 et sw=4
diff --git a/test/unit/utColladaExportLight.cpp b/test/unit/utColladaExport.cpp
similarity index 78%
rename from test/unit/utColladaExportLight.cpp
rename to test/unit/utColladaExport.cpp
index 0327b296e..efb2d7f17 100644
--- a/test/unit/utColladaExportLight.cpp
+++ b/test/unit/utColladaExport.cpp
@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
-class ColladaExportLight : public ::testing::Test {
+class utColladaExport : public ::testing::Test {
 public:
     void SetUp() override {
         ex = new Assimp::Exporter();
@@ -58,7 +58,9 @@ public:
 
     void TearDown() override {
         delete ex;
+        ex = nullptr;
         delete im;
+        im = nullptr;
     }
 
 protected:
@@ -66,8 +68,53 @@ protected:
     Assimp::Importer *im;
 };
 
+TEST_F(utColladaExport, testExportCamera) {
+    const char *file = "cameraExp.dae";
+
+    const aiScene *pTest = im->ReadFile(ASSIMP_TEST_MODELS_DIR "/Collada/cameras.dae", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, pTest);
+    ASSERT_TRUE(pTest->HasCameras());
+
+    EXPECT_EQ(AI_SUCCESS, ex->Export(pTest, "collada", file));
+    const unsigned int origNumCams(pTest->mNumCameras);
+    std::unique_ptr<float[]> origFOV(new float[origNumCams]);
+    std::unique_ptr<float[]> orifClipPlaneNear(new float[origNumCams]);
+    std::unique_ptr<float[]> orifClipPlaneFar(new float[origNumCams]);
+    std::unique_ptr<aiString[]> names(new aiString[origNumCams]);
+    std::unique_ptr<aiVector3D[]> pos(new aiVector3D[origNumCams]);
+    for (size_t i = 0; i < origNumCams; i++) {
+        const aiCamera *orig = pTest->mCameras[i];
+        ASSERT_NE(nullptr, orig);
+
+        origFOV[i] = orig->mHorizontalFOV;
+        orifClipPlaneNear[i] = orig->mClipPlaneNear;
+        orifClipPlaneFar[i] = orig->mClipPlaneFar;
+        names[i] = orig->mName;
+        pos[i] = orig->mPosition;
+    }
+    const aiScene *imported = im->ReadFile(file, aiProcess_ValidateDataStructure);
+
+    ASSERT_NE(nullptr, imported);
+
+    EXPECT_TRUE(imported->HasCameras());
+    EXPECT_EQ(origNumCams, imported->mNumCameras);
+
+    for (size_t i = 0; i < imported->mNumCameras; i++) {
+        const aiCamera *read = imported->mCameras[i];
+
+        EXPECT_TRUE(names[i] == read->mName);
+        EXPECT_NEAR(origFOV[i], read->mHorizontalFOV, 0.0001f);
+        EXPECT_FLOAT_EQ(orifClipPlaneNear[i], read->mClipPlaneNear);
+        EXPECT_FLOAT_EQ(orifClipPlaneFar[i], read->mClipPlaneFar);
+
+        EXPECT_FLOAT_EQ(pos[i].x, read->mPosition.x);
+        EXPECT_FLOAT_EQ(pos[i].y, read->mPosition.y);
+        EXPECT_FLOAT_EQ(pos[i].z, read->mPosition.z);
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
-TEST_F(ColladaExportLight, testExportLight) {
+TEST_F(utColladaExport, testExportLight) {
     const char *file = "lightsExp.dae";
 
     const aiScene *pTest = im->ReadFile(ASSIMP_TEST_MODELS_DIR "/Collada/lights.dae", aiProcess_ValidateDataStructure);
diff --git a/test/unit/utColladaExportCamera.cpp b/test/unit/utColladaExportCamera.cpp
deleted file mode 100644
index c2c704056..000000000
--- a/test/unit/utColladaExportCamera.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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.
----------------------------------------------------------------------------
-*/
-#include "UnitTestPCH.h"
-
-#include <assimp/cexport.h>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <assimp/Exporter.hpp>
-#include <assimp/Importer.hpp>
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-
-class ColladaExportCamera : public ::testing::Test {
-public:
-    void SetUp() override {
-        ex = new Assimp::Exporter();
-        im = new Assimp::Importer();
-    }
-
-    void TearDown() override {
-        delete ex;
-        ex = nullptr;
-        delete im;
-        im = nullptr;
-    }
-
-protected:
-    Assimp::Exporter *ex;
-    Assimp::Importer *im;
-};
-
-TEST_F(ColladaExportCamera, testExportCamera) {
-    const char *file = "cameraExp.dae";
-
-    const aiScene *pTest = im->ReadFile(ASSIMP_TEST_MODELS_DIR "/Collada/cameras.dae", aiProcess_ValidateDataStructure);
-    ASSERT_NE(nullptr, pTest);
-    ASSERT_TRUE(pTest->HasCameras());
-
-    EXPECT_EQ(AI_SUCCESS, ex->Export(pTest, "collada", file));
-    const unsigned int origNumCams(pTest->mNumCameras);
-    std::unique_ptr<float[]> origFOV(new float[origNumCams]);
-    std::unique_ptr<float[]> orifClipPlaneNear(new float[origNumCams]);
-    std::unique_ptr<float[]> orifClipPlaneFar(new float[origNumCams]);
-    std::unique_ptr<aiString[]> names(new aiString[origNumCams]);
-    std::unique_ptr<aiVector3D[]> pos(new aiVector3D[origNumCams]);
-    for (size_t i = 0; i < origNumCams; i++) {
-        const aiCamera *orig = pTest->mCameras[i];
-        ASSERT_NE(nullptr, orig);
-
-        origFOV[i] = orig->mHorizontalFOV;
-        orifClipPlaneNear[i] = orig->mClipPlaneNear;
-        orifClipPlaneFar[i] = orig->mClipPlaneFar;
-        names[i] = orig->mName;
-        pos[i] = orig->mPosition;
-    }
-    const aiScene *imported = im->ReadFile(file, aiProcess_ValidateDataStructure);
-
-    ASSERT_NE(nullptr, imported);
-
-    EXPECT_TRUE(imported->HasCameras());
-    EXPECT_EQ(origNumCams, imported->mNumCameras);
-
-    for (size_t i = 0; i < imported->mNumCameras; i++) {
-        const aiCamera *read = imported->mCameras[i];
-
-        EXPECT_TRUE(names[i] == read->mName);
-        EXPECT_NEAR(origFOV[i], read->mHorizontalFOV, 0.0001f);
-        EXPECT_FLOAT_EQ(orifClipPlaneNear[i], read->mClipPlaneNear);
-        EXPECT_FLOAT_EQ(orifClipPlaneFar[i], read->mClipPlaneFar);
-
-        EXPECT_FLOAT_EQ(pos[i].x, read->mPosition.x);
-        EXPECT_FLOAT_EQ(pos[i].y, read->mPosition.y);
-        EXPECT_FLOAT_EQ(pos[i].z, read->mPosition.z);
-    }
-}
-
-#endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/test/unit/utTriangulate.cpp b/test/unit/utTriangulate.cpp
index 7c5ba738c..a95331250 100644
--- a/test/unit/utTriangulate.cpp
+++ b/test/unit/utTriangulate.cpp
@@ -65,8 +65,7 @@ void TriangulateProcessTest::SetUp() {
     pcMesh->mFaces = new aiFace[1000];
     pcMesh->mVertices = new aiVector3D[10000];
 
-    pcMesh->mPrimitiveTypes = aiPrimitiveType_POINT | aiPrimitiveType_LINE |
-                              aiPrimitiveType_LINE | aiPrimitiveType_POLYGON;
+    pcMesh->mPrimitiveTypes = aiPrimitiveType_POINT | aiPrimitiveType_LINE | aiPrimitiveType_POLYGON;
 
     for (unsigned int m = 0, t = 0, q = 4; m < 1000; ++m) {
         ++t;
diff --git a/tools/assimp_view/AnimEvaluator.cpp b/tools/assimp_view/AnimEvaluator.cpp
index 710950fe2..e97bdf290 100644
--- a/tools/assimp_view/AnimEvaluator.cpp
+++ b/tools/assimp_view/AnimEvaluator.cpp
@@ -47,10 +47,11 @@ using namespace AssimpView;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor on a given animation.
-AnimEvaluator::AnimEvaluator( const aiAnimation *pAnim )
-: mAnim(pAnim)
-, mLastTime(0.0) {
-    mLastPositions.resize( pAnim->mNumChannels, std::make_tuple( 0, 0, 0));
+AnimEvaluator::AnimEvaluator(const aiAnimation *pAnim) :
+        mAnim(pAnim),
+        mLastTime(0.0) {
+    ai_assert(nullptr != pAnim);
+    mLastPositions.resize(pAnim->mNumChannels, std::make_tuple(0, 0, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -61,7 +62,7 @@ AnimEvaluator::~AnimEvaluator() {
 
 // ------------------------------------------------------------------------------------------------
 // Evaluates the animation tracks for a given time stamp.
-void AnimEvaluator::Evaluate( double pTime ) {
+void AnimEvaluator::Evaluate(double pTime) {
     // extract ticks per second. Assume default value if not given
     double ticksPerSecond = mAnim->mTicksPerSecond != 0.0 ? mAnim->mTicksPerSecond : 25.0;
     // every following time calculation happens in ticks
@@ -78,16 +79,16 @@ void AnimEvaluator::Evaluate( double pTime ) {
     }
 
     // calculate the transformations for each animation channel
-    for( unsigned int a = 0; a < mAnim->mNumChannels; ++a ) {
-        const aiNodeAnim* channel = mAnim->mChannels[a];
+    for (unsigned int a = 0; a < mAnim->mNumChannels; ++a) {
+        const aiNodeAnim *channel = mAnim->mChannels[a];
 
         // ******** Position *****
-        aiVector3D presentPosition( 0, 0, 0);
-        if( channel->mNumPositionKeys > 0) {
+        aiVector3D presentPosition(0, 0, 0);
+        if (channel->mNumPositionKeys > 0) {
             // Look for present frame number. Search from last position if time is after the last time, else from beginning
             // Should be much quicker than always looking from start for the average use case.
             unsigned int frame = (time >= mLastTime) ? std::get<0>(mLastPositions[a]) : 0;
-            while( frame < channel->mNumPositionKeys - 1) {
+            while (frame < channel->mNumPositionKeys - 1) {
                 if (time < channel->mPositionKeys[frame + 1].mTime) {
                     break;
                 }
@@ -96,14 +97,14 @@ void AnimEvaluator::Evaluate( double pTime ) {
 
             // interpolate between this frame's value and next frame's value
             unsigned int nextFrame = (frame + 1) % channel->mNumPositionKeys;
-            const aiVectorKey& key = channel->mPositionKeys[frame];
-            const aiVectorKey& nextKey = channel->mPositionKeys[nextFrame];
+            const aiVectorKey &key = channel->mPositionKeys[frame];
+            const aiVectorKey &nextKey = channel->mPositionKeys[nextFrame];
             double diffTime = nextKey.mTime - key.mTime;
             if (diffTime < 0.0) {
                 diffTime += mAnim->mDuration;
             }
-            if( diffTime > 0) {
-                float factor = float( (time - key.mTime) / diffTime);
+            if (diffTime > 0) {
+                float factor = float((time - key.mTime) / diffTime);
                 presentPosition = key.mValue + (nextKey.mValue - key.mValue) * factor;
             } else {
                 presentPosition = key.mValue;
@@ -113,10 +114,10 @@ void AnimEvaluator::Evaluate( double pTime ) {
         }
 
         // ******** Rotation *********
-        aiQuaternion presentRotation( 1, 0, 0, 0);
-        if( channel->mNumRotationKeys > 0) {
+        aiQuaternion presentRotation(1, 0, 0, 0);
+        if (channel->mNumRotationKeys > 0) {
             unsigned int frame = (time >= mLastTime) ? std::get<1>(mLastPositions[a]) : 0;
-            while( frame < channel->mNumRotationKeys - 1) {
+            while (frame < channel->mNumRotationKeys - 1) {
                 if (time < channel->mRotationKeys[frame + 1].mTime) {
                     break;
                 }
@@ -125,15 +126,15 @@ void AnimEvaluator::Evaluate( double pTime ) {
 
             // interpolate between this frame's value and next frame's value
             unsigned int nextFrame = (frame + 1) % channel->mNumRotationKeys;
-            const aiQuatKey& key = channel->mRotationKeys[frame];
-            const aiQuatKey& nextKey = channel->mRotationKeys[nextFrame];
+            const aiQuatKey &key = channel->mRotationKeys[frame];
+            const aiQuatKey &nextKey = channel->mRotationKeys[nextFrame];
             double diffTime = nextKey.mTime - key.mTime;
             if (diffTime < 0.0) {
                 diffTime += mAnim->mDuration;
             }
-            if( diffTime > 0) {
-                float factor = float( (time - key.mTime) / diffTime);
-                aiQuaternion::Interpolate( presentRotation, key.mValue, nextKey.mValue, factor);
+            if (diffTime > 0) {
+                float factor = float((time - key.mTime) / diffTime);
+                aiQuaternion::Interpolate(presentRotation, key.mValue, nextKey.mValue, factor);
             } else {
                 presentRotation = key.mValue;
             }
@@ -142,10 +143,10 @@ void AnimEvaluator::Evaluate( double pTime ) {
         }
 
         // ******** Scaling **********
-        aiVector3D presentScaling( 1, 1, 1);
-        if( channel->mNumScalingKeys > 0) {
+        aiVector3D presentScaling(1, 1, 1);
+        if (channel->mNumScalingKeys > 0) {
             unsigned int frame = (time >= mLastTime) ? std::get<2>(mLastPositions[a]) : 0;
-            while( frame < channel->mNumScalingKeys - 1) {
+            while (frame < channel->mNumScalingKeys - 1) {
                 if (time < channel->mScalingKeys[frame + 1].mTime) {
                     break;
                 }
@@ -158,12 +159,20 @@ void AnimEvaluator::Evaluate( double pTime ) {
         }
 
         // build a transformation matrix from it
-        aiMatrix4x4& mat = mTransforms[a];
-        mat = aiMatrix4x4( presentRotation.GetMatrix());
-        mat.a1 *= presentScaling.x; mat.b1 *= presentScaling.x; mat.c1 *= presentScaling.x;
-        mat.a2 *= presentScaling.y; mat.b2 *= presentScaling.y; mat.c2 *= presentScaling.y;
-        mat.a3 *= presentScaling.z; mat.b3 *= presentScaling.z; mat.c3 *= presentScaling.z;
-        mat.a4 = presentPosition.x; mat.b4 = presentPosition.y; mat.c4 = presentPosition.z;
+        aiMatrix4x4 &mat = mTransforms[a];
+        mat = aiMatrix4x4(presentRotation.GetMatrix());
+        mat.a1 *= presentScaling.x;
+        mat.b1 *= presentScaling.x;
+        mat.c1 *= presentScaling.x;
+        mat.a2 *= presentScaling.y;
+        mat.b2 *= presentScaling.y;
+        mat.c2 *= presentScaling.y;
+        mat.a3 *= presentScaling.z;
+        mat.b3 *= presentScaling.z;
+        mat.c3 *= presentScaling.z;
+        mat.a4 = presentPosition.x;
+        mat.b4 = presentPosition.y;
+        mat.c4 = presentPosition.z;
     }
 
     mLastTime = time;
diff --git a/tools/assimp_view/AnimEvaluator.h b/tools/assimp_view/AnimEvaluator.h
index 9267853e1..12bb91c30 100644
--- a/tools/assimp_view/AnimEvaluator.h
+++ b/tools/assimp_view/AnimEvaluator.h
@@ -58,7 +58,7 @@ public:
     /// the object.
     /// @param pAnim    The animation to calculate poses for. Ownership of the animation object stays
     ///                 at the caller, the evaluator just keeps a reference to it as long as it persists.
-    AnimEvaluator( const aiAnimation* pAnim);
+    AnimEvaluator(const aiAnimation *pAnim);
 
     /// @brief  The class destructor.
     ~AnimEvaluator();
@@ -68,16 +68,16 @@ public:
      * @param pTime The time for which you want to evaluate the animation, in seconds. Will be mapped into the animation cycle, so
      *   it can be an arbitrary value. Best use with ever-increasing time stamps.
      */
-    void Evaluate( double pTime);
+    void Evaluate(double pTime);
 
     /** Returns the transform matrices calculated at the last Evaluate() call. The array matches the mChannels array of
      * the aiAnimation. */
-    const std::vector<aiMatrix4x4>& GetTransformations() const { return mTransforms; }
+    const std::vector<aiMatrix4x4> &GetTransformations() const { return mTransforms; }
 
 protected:
-    const aiAnimation* mAnim;
+    const aiAnimation *mAnim;
     double mLastTime;
-    std::vector<std::tuple<unsigned int, unsigned int, unsigned int> > mLastPositions;
+    std::vector<std::tuple<unsigned int, unsigned int, unsigned int>> mLastPositions;
     std::vector<aiMatrix4x4> mTransforms;
 };
 
diff --git a/tools/assimp_view/AssetHelper.h b/tools/assimp_view/AssetHelper.h
index 7731e44e5..fe3761cfd 100644
--- a/tools/assimp_view/AssetHelper.h
+++ b/tools/assimp_view/AssetHelper.h
@@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-
 #if (!defined AV_ASSET_HELPER_H_INCLUDED)
 #define AV_ASSET_HELPER_H_INCLUDED
 
@@ -51,200 +50,187 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace AssimpView {
 
-    class SceneAnimator;
+class SceneAnimator;
 
-    //-------------------------------------------------------------------------------
-    /** \brief Class to wrap ASSIMP's asset output structures
+//-------------------------------------------------------------------------------
+/** \brief Class to wrap ASSIMP's asset output structures
     */
-    //-------------------------------------------------------------------------------
-    class AssetHelper
-    {
-    public:
-        enum
-        {
-            // the original normal set will be used
-            ORIGINAL = 0x0u,
+//-------------------------------------------------------------------------------
+class AssetHelper {
+public:
+    enum {
+        // the original normal set will be used
+        ORIGINAL = 0x0u,
 
-            // a smoothed normal set will be used
-            SMOOTH = 0x1u,
+        // a smoothed normal set will be used
+        SMOOTH = 0x1u,
 
-            // a hard normal set will be used
-            HARD = 0x2u,
-        };
+        // a hard normal set will be used
+        HARD = 0x2u,
+    };
 
-        // default constructor
-        AssetHelper()
-            : iNormalSet( ORIGINAL )
-        {
-            mAnimator = NULL;
-            apcMeshes = NULL;
-            pcScene = NULL;
+    // default constructor
+    AssetHelper() :
+            iNormalSet(ORIGINAL) {
+        mAnimator = NULL;
+        apcMeshes = NULL;
+        pcScene = NULL;
+    }
+
+    //---------------------------------------------------------------
+    // default vertex data structure
+    // (even if tangents, bitangents or normals aren't
+    // required by the shader they will be committed to the GPU)
+    //---------------------------------------------------------------
+    struct Vertex {
+        aiVector3D vPosition;
+        aiVector3D vNormal;
+
+        D3DCOLOR dColorDiffuse;
+        aiVector3D vTangent;
+        aiVector3D vBitangent;
+        aiVector2D vTextureUV;
+        aiVector2D vTextureUV2;
+        unsigned char mBoneIndices[4];
+        unsigned char mBoneWeights[4]; // last Weight not used, calculated inside the vertex shader
+
+        /** Returns the vertex declaration elements to create a declaration from. */
+        static D3DVERTEXELEMENT9 *GetDeclarationElements() {
+            static D3DVERTEXELEMENT9 decl[] = {
+                { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
+                { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
+                { 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
+                { 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
+                { 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
+                { 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
+                { 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
+                { 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },
+                { 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 },
+                D3DDECL_END()
+            };
+
+            return decl;
         }
+    };
 
-        //---------------------------------------------------------------
-        // default vertex data structure
-        // (even if tangents, bitangents or normals aren't
-        // required by the shader they will be committed to the GPU)
-        //---------------------------------------------------------------
-        struct Vertex
-        {
-            aiVector3D vPosition;
-            aiVector3D vNormal;
+    //---------------------------------------------------------------
+    // FVF vertex structure used for normals
+    //---------------------------------------------------------------
+    struct LineVertex {
+        aiVector3D vPosition;
+        DWORD dColorDiffuse;
 
-            D3DCOLOR dColorDiffuse;
-            aiVector3D vTangent;
-            aiVector3D vBitangent;
-            aiVector2D vTextureUV;
-            aiVector2D vTextureUV2;
-            unsigned char mBoneIndices[ 4 ];
-            unsigned char mBoneWeights[ 4 ]; // last Weight not used, calculated inside the vertex shader
+        // retrieves the FVF code of the vertex type
+        static DWORD GetFVF() {
+            return D3DFVF_DIFFUSE | D3DFVF_XYZ;
+        }
+    };
 
-            /** Returns the vertex declaration elements to create a declaration from. */
-            static D3DVERTEXELEMENT9* GetDeclarationElements()
-            {
-                static D3DVERTEXELEMENT9 decl[] =
-                {
-                    { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
-                    { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
-                    { 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
-                    { 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
-                    { 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
-                    { 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
-                    { 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
-                    { 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },
-                    { 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 },
-                    D3DDECL_END()
-                };
-
-                return decl;
-            }
-        };
-
-        //---------------------------------------------------------------
-        // FVF vertex structure used for normals
-        //---------------------------------------------------------------
-        struct LineVertex
-        {
-            aiVector3D vPosition;
-            DWORD dColorDiffuse;
-
-            // retrieves the FVF code of the vertex type
-            static DWORD GetFVF()
-            {
-                return D3DFVF_DIFFUSE | D3DFVF_XYZ;
-            }
-        };
-
-        //---------------------------------------------------------------
-        // Helper class to store GPU related resources created for
-        // a given aiMesh
-        //---------------------------------------------------------------
-        class MeshHelper
-        {
-        public:
-
-            MeshHelper()
-                :
+    //---------------------------------------------------------------
+    // Helper class to store GPU related resources created for
+    // a given aiMesh
+    //---------------------------------------------------------------
+    class MeshHelper {
+    public:
+        MeshHelper() :
                 eShadingMode(),
-                piVB( NULL ),
-                piIB( NULL ),
-                piVBNormals( NULL ),
-                piEffect( NULL ),
-                bSharedFX( false ),
-                piDiffuseTexture( NULL ),
-                piSpecularTexture( NULL ),
-                piAmbientTexture( NULL ),
-                piEmissiveTexture( NULL ),
-                piNormalTexture( NULL ),
-                piOpacityTexture( NULL ),
-                piShininessTexture( NULL ),
-                piLightmapTexture( NULL ),
+                piVB(NULL),
+                piIB(NULL),
+                piVBNormals(NULL),
+                piEffect(NULL),
+                bSharedFX(false),
+                piDiffuseTexture(NULL),
+                piSpecularTexture(NULL),
+                piAmbientTexture(NULL),
+                piEmissiveTexture(NULL),
+                piNormalTexture(NULL),
+                piOpacityTexture(NULL),
+                piShininessTexture(NULL),
+                piLightmapTexture(NULL),
                 fOpacity(),
                 fShininess(),
                 fSpecularStrength(),
-                twosided( false ),
-                pvOriginalNormals( NULL )
-            {}
+                twosided(false),
+                pvOriginalNormals(NULL) {}
 
-            ~MeshHelper()
-            {
-                // NOTE: This is done in DeleteAssetData()
-                // TODO: Make this a proper d'tor
-            }
+        ~MeshHelper() {
+            // NOTE: This is done in DeleteAssetData()
+            // TODO: Make this a proper d'tor
+        }
 
-            // shading mode to use. Either Lambert or otherwise phong
-            // will be used in every case
-            aiShadingMode eShadingMode;
+        // shading mode to use. Either Lambert or otherwise phong
+        // will be used in every case
+        aiShadingMode eShadingMode;
 
-            // vertex buffer
-            IDirect3DVertexBuffer9* piVB;
+        // vertex buffer
+        IDirect3DVertexBuffer9 *piVB;
 
-            // index buffer. For partially transparent meshes
-            // created with dynamic usage to be able to update
-            // the buffer contents quickly
-            IDirect3DIndexBuffer9* piIB;
+        // index buffer. For partially transparent meshes
+        // created with dynamic usage to be able to update
+        // the buffer contents quickly
+        IDirect3DIndexBuffer9 *piIB;
 
-            // vertex buffer to be used to draw vertex normals
-            // (vertex normals are generated in every case)
-            IDirect3DVertexBuffer9* piVBNormals;
+        // vertex buffer to be used to draw vertex normals
+        // (vertex normals are generated in every case)
+        IDirect3DVertexBuffer9 *piVBNormals;
 
-            // shader to be used
-            ID3DXEffect* piEffect;
-            bool bSharedFX;
+        // shader to be used
+        ID3DXEffect *piEffect;
+        bool bSharedFX;
 
-            // material textures
-            IDirect3DTexture9* piDiffuseTexture;
-            IDirect3DTexture9* piSpecularTexture;
-            IDirect3DTexture9* piAmbientTexture;
-            IDirect3DTexture9* piEmissiveTexture;
-            IDirect3DTexture9* piNormalTexture;
-            IDirect3DTexture9* piOpacityTexture;
-            IDirect3DTexture9* piShininessTexture;
-            IDirect3DTexture9* piLightmapTexture;
+        // material textures
+        IDirect3DTexture9 *piDiffuseTexture;
+        IDirect3DTexture9 *piSpecularTexture;
+        IDirect3DTexture9 *piAmbientTexture;
+        IDirect3DTexture9 *piEmissiveTexture;
+        IDirect3DTexture9 *piNormalTexture;
+        IDirect3DTexture9 *piOpacityTexture;
+        IDirect3DTexture9 *piShininessTexture;
+        IDirect3DTexture9 *piLightmapTexture;
 
-            // material colors
-            D3DXVECTOR4 vDiffuseColor;
-            D3DXVECTOR4 vSpecularColor;
-            D3DXVECTOR4 vAmbientColor;
-            D3DXVECTOR4 vEmissiveColor;
+        // material colors
+        D3DXVECTOR4 vDiffuseColor;
+        D3DXVECTOR4 vSpecularColor;
+        D3DXVECTOR4 vAmbientColor;
+        D3DXVECTOR4 vEmissiveColor;
 
-            // opacity for the material
-            float fOpacity;
+        // opacity for the material
+        float fOpacity;
 
-            // shininess for the material
-            float fShininess;
+        // shininess for the material
+        float fShininess;
 
-            // strength of the specular highlight
-            float fSpecularStrength;
+        // strength of the specular highlight
+        float fSpecularStrength;
 
-            // two-sided?
-            bool twosided;
+        // two-sided?
+        bool twosided;
 
-            // Stores a pointer to the original normal set of the asset
-            aiVector3D* pvOriginalNormals;
-        };
-
-        // One instance per aiMesh in the globally loaded asset
-        MeshHelper** apcMeshes;
-
-        // Scene wrapper instance
-        aiScene* pcScene;
-
-        // Animation player to animate the scene if necessary
-        SceneAnimator* mAnimator;
-
-        // Specifies the normal set to be used
-        unsigned int iNormalSet;
-
-        // ------------------------------------------------------------------
-        // set the normal set to be used
-        void SetNormalSet( unsigned int iSet );
-
-        // ------------------------------------------------------------------
-        // flip all normal vectors
-        void FlipNormals();
-        void FlipNormalsInt();
+        // Stores a pointer to the original normal set of the asset
+        aiVector3D *pvOriginalNormals;
     };
-}
+
+    // One instance per aiMesh in the globally loaded asset
+    MeshHelper **apcMeshes;
+
+    // Scene wrapper instance
+    aiScene *pcScene;
+
+    // Animation player to animate the scene if necessary
+    SceneAnimator *mAnimator;
+
+    // Specifies the normal set to be used
+    unsigned int iNormalSet;
+
+    // ------------------------------------------------------------------
+    // set the normal set to be used
+    void SetNormalSet(unsigned int iSet);
+
+    // ------------------------------------------------------------------
+    // flip all normal vectors
+    void FlipNormals();
+    void FlipNormalsInt();
+};
+} // namespace AssimpView
 
 #endif // !! IG
diff --git a/tools/assimp_view/Background.cpp b/tools/assimp_view/Background.cpp
index 3cf0a81e3..fe6e68c09 100644
--- a/tools/assimp_view/Background.cpp
+++ b/tools/assimp_view/Background.cpp
@@ -118,8 +118,9 @@ CBackgroundPainter CBackgroundPainter::s_cInstance;
 
 //-------------------------------------------------------------------------------
 void CBackgroundPainter::SetColor(D3DCOLOR p_clrNew) {
-    if (TEXTURE_CUBE == eMode)
+    if (TEXTURE_CUBE == eMode) {
         RemoveSBDeps();
+    }
 
     clrColor = p_clrNew;
     eMode = SIMPLE_COLOR;
diff --git a/tools/assimp_view/Camera.h b/tools/assimp_view/Camera.h
index dd82af029..9c3103827 100644
--- a/tools/assimp_view/Camera.h
+++ b/tools/assimp_view/Camera.h
@@ -82,4 +82,4 @@ class Camera
 
     } ;
 
-#endif // !!IG
\ No newline at end of file
+#endif // !!IG
diff --git a/tools/assimp_view/Display.h b/tools/assimp_view/Display.h
index f52e65e42..1ca29f498 100644
--- a/tools/assimp_view/Display.h
+++ b/tools/assimp_view/Display.h
@@ -539,4 +539,4 @@ namespace AssimpView
     };
 
 }
-#endif // AV_DISPLAY_H_INCLUDE
\ No newline at end of file
+#endif // AV_DISPLAY_H_INCLUDE
diff --git a/tools/assimp_view/Input.cpp b/tools/assimp_view/Input.cpp
index 505433404..f9f463412 100644
--- a/tools/assimp_view/Input.cpp
+++ b/tools/assimp_view/Input.cpp
@@ -369,4 +369,4 @@ void HandleKeyboardInputTextureView( void )
     if( keys[VK_RIGHT] & 0x80 )
         CDisplay::Instance().SetTextureViewOffsetX ( -g_fElpasedTime * 150.0f );
     }
-};
\ No newline at end of file
+};
diff --git a/tools/assimp_view/LogWindow.h b/tools/assimp_view/LogWindow.h
index 671d8be8f..5b2a3d2d3 100644
--- a/tools/assimp_view/LogWindow.h
+++ b/tools/assimp_view/LogWindow.h
@@ -130,4 +130,4 @@ namespace AssimpView
 
 }
 
-#endif // AV_LOG_DISPLA
\ No newline at end of file
+#endif // AV_LOG_DISPLA
diff --git a/tools/assimp_view/MaterialManager.h b/tools/assimp_view/MaterialManager.h
index fb3fcb38f..107c4d9f0 100644
--- a/tools/assimp_view/MaterialManager.h
+++ b/tools/assimp_view/MaterialManager.h
@@ -45,164 +45,154 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "AssetHelper.h"
 
-namespace AssimpView
-{
+namespace AssimpView {
 
-    //-------------------------------------------------------------------------------
-    /* Helper class to create, access and destroy materials
+//-------------------------------------------------------------------------------
+/* Helper class to create, access and destroy materials
     */
-    //-------------------------------------------------------------------------------
-    class CMaterialManager
-    {
-    private:
+//-------------------------------------------------------------------------------
+class CMaterialManager {
+private:
+    friend class CDisplay;
 
-        friend class CDisplay;
+    // default constructor
+    CMaterialManager() :
+            m_iShaderCount(0), sDefaultTexture() {}
 
-        // default constructor
-        CMaterialManager()
-            : m_iShaderCount( 0 ), sDefaultTexture() {}
-
-        ~CMaterialManager() {
-            if( sDefaultTexture ) {
-                sDefaultTexture->Release();
-            }
-            Reset();
+    ~CMaterialManager() {
+        if (sDefaultTexture) {
+            sDefaultTexture->Release();
         }
+        Reset();
+    }
 
-    public:
+public:
+    //------------------------------------------------------------------
+    // Singleton accessors
+    static CMaterialManager s_cInstance;
+    inline static CMaterialManager &Instance() {
+        return s_cInstance;
+    }
 
-        //------------------------------------------------------------------
-        // Singleton accessors
-        static CMaterialManager s_cInstance;
-        inline static CMaterialManager& Instance()
-        {
-            return s_cInstance;
+    //------------------------------------------------------------------
+    // Delete all resources of a given material
+    //
+    // Must be called before CreateMaterial() to prevent memory leaking
+    void DeleteMaterial(AssetHelper::MeshHelper *pcIn);
+
+    //------------------------------------------------------------------
+    // Create the material for a mesh.
+    //
+    // The function checks whether an identical shader is already in use.
+    // A shader is considered to be identical if it has the same input
+    // signature and takes the same number of texture channels.
+    int CreateMaterial(AssetHelper::MeshHelper *pcMesh,
+            const aiMesh *pcSource);
+
+    //------------------------------------------------------------------
+    // Setup the material for a given mesh
+    // pcMesh Mesh to be rendered
+    // pcProj Projection matrix
+    // aiMe Current world matrix
+    // pcCam Camera matrix
+    // vPos Position of the camera
+    // TODO: Extract camera position from matrix ...
+    //
+    int SetupMaterial(AssetHelper::MeshHelper *pcMesh,
+            const aiMatrix4x4 &pcProj,
+            const aiMatrix4x4 &aiMe,
+            const aiMatrix4x4 &pcCam,
+            const aiVector3D &vPos);
+
+    //------------------------------------------------------------------
+    // End the material for a given mesh
+    // Called after mesh rendering is complete
+    // pcMesh Mesh object
+    int EndMaterial(AssetHelper::MeshHelper *pcMesh);
+
+    //------------------------------------------------------------------
+    // Recreate all specular materials depending on the current
+    // specularity settings
+    //
+    // Diffuse-only materials are ignored.
+    // Must be called after specular highlights have been toggled
+    int UpdateSpecularMaterials();
+
+    //------------------------------------------------------------------
+    // find a valid path to a texture file
+    //
+    // Handle 8.3 syntax correctly, search the environment of the
+    // executable and the asset for a texture with a name very similar
+    // to a given one
+    int FindValidPath(aiString *p_szString);
+
+    //------------------------------------------------------------------
+    // Load a texture into memory and create a native D3D texture resource
+    //
+    // The function tries to find a valid path for a texture
+    int LoadTexture(IDirect3DTexture9 **p_ppiOut, aiString *szPath);
+
+    //------------------------------------------------------------------
+    // Getter for m_iShaderCount
+    //
+    inline unsigned int GetShaderCount() {
+        return this->m_iShaderCount;
+    }
+
+    //------------------------------------------------------------------
+    // Reset the state of the class
+    // Called whenever a new asset is loaded
+    inline void Reset() {
+        this->m_iShaderCount = 0;
+        for (TextureCache::iterator it = sCachedTextures.begin(); it != sCachedTextures.end(); ++it) {
+            (*it).second->Release();
         }
+        sCachedTextures.clear();
+    }
 
-        //------------------------------------------------------------------
-        // Delete all resources of a given material
-        //
-        // Must be called before CreateMaterial() to prevent memory leaking
-        void DeleteMaterial( AssetHelper::MeshHelper* pcIn );
+private:
+    //------------------------------------------------------------------
+    // find a valid path to a texture file
+    //
+    // Handle 8.3 syntax correctly, search the environment of the
+    // executable and the asset for a texture with a name very similar
+    // to a given one
+    bool TryLongerPath(char *szTemp, aiString *p_szString);
 
-        //------------------------------------------------------------------
-        // Create the material for a mesh.
-        //
-        // The function checks whether an identical shader is already in use.
-        // A shader is considered to be identical if it has the same input
-        // signature and takes the same number of texture channels.
-        int CreateMaterial( AssetHelper::MeshHelper* pcMesh,
-            const aiMesh* pcSource );
+    //------------------------------------------------------------------
+    // Setup the default texture for a texture channel
+    //
+    // Generates a default checker pattern for a texture
+    int SetDefaultTexture(IDirect3DTexture9 **p_ppiOut);
 
-        //------------------------------------------------------------------
-        // Setup the material for a given mesh
-        // pcMesh Mesh to be rendered
-        // pcProj Projection matrix
-        // aiMe Current world matrix
-        // pcCam Camera matrix
-        // vPos Position of the camera
-        // TODO: Extract camera position from matrix ...
-        //
-        int SetupMaterial( AssetHelper::MeshHelper* pcMesh,
-            const aiMatrix4x4& pcProj,
-            const aiMatrix4x4& aiMe,
-            const aiMatrix4x4& pcCam,
-            const aiVector3D& vPos );
+    //------------------------------------------------------------------
+    // Convert a height map to a normal map if necessary
+    //
+    // The function tries to detect the type of a texture automatically.
+    // However, this won't work in every case.
+    void HMtoNMIfNecessary(IDirect3DTexture9 *piTexture,
+            IDirect3DTexture9 **piTextureOut,
+            bool bWasOriginallyHM = true);
 
-        //------------------------------------------------------------------
-        // End the material for a given mesh
-        // Called after mesh rendering is complete
-        // pcMesh Mesh object
-        int EndMaterial( AssetHelper::MeshHelper* pcMesh );
+    //------------------------------------------------------------------
+    // Search for non-opaque pixels in a texture
+    //
+    // A pixel is considered to be non-opaque if its alpha value is
+    // less than 255
+    //------------------------------------------------------------------
+    bool HasAlphaPixels(IDirect3DTexture9 *piTexture);
 
-        //------------------------------------------------------------------
-        // Recreate all specular materials depending on the current
-        // specularity settings
-        //
-        // Diffuse-only materials are ignored.
-        // Must be called after specular highlights have been toggled
-        int UpdateSpecularMaterials();
+private:
+    //
+    // Specifies the number of different shaders generated for
+    // the current asset. This number is incremented by CreateMaterial()
+    // each time a shader isn't found in cache and needs to be created
+    //
+    unsigned int m_iShaderCount;
+    IDirect3DTexture9 *sDefaultTexture;
 
-        //------------------------------------------------------------------
-        // find a valid path to a texture file
-        //
-        // Handle 8.3 syntax correctly, search the environment of the
-        // executable and the asset for a texture with a name very similar
-        // to a given one
-        int FindValidPath( aiString* p_szString );
+    typedef std::map<std::string, IDirect3DTexture9 *> TextureCache;
+    TextureCache sCachedTextures;
+};
 
-        //------------------------------------------------------------------
-        // Load a texture into memory and create a native D3D texture resource
-        //
-        // The function tries to find a valid path for a texture
-        int LoadTexture( IDirect3DTexture9** p_ppiOut, aiString* szPath );
-
-
-        //------------------------------------------------------------------
-        // Getter for m_iShaderCount
-        //
-        inline unsigned int GetShaderCount()
-        {
-            return this->m_iShaderCount;
-        }
-
-        //------------------------------------------------------------------
-        // Reset the state of the class
-        // Called whenever a new asset is loaded
-        inline void Reset()
-        {
-            this->m_iShaderCount = 0;
-            for( TextureCache::iterator it = sCachedTextures.begin(); it != sCachedTextures.end(); ++it ) {
-                ( *it ).second->Release();
-            }
-            sCachedTextures.clear();
-        }
-
-    private:
-
-        //------------------------------------------------------------------
-        // find a valid path to a texture file
-        //
-        // Handle 8.3 syntax correctly, search the environment of the
-        // executable and the asset for a texture with a name very similar
-        // to a given one
-        bool TryLongerPath( char* szTemp, aiString* p_szString );
-
-        //------------------------------------------------------------------
-        // Setup the default texture for a texture channel
-        //
-        // Generates a default checker pattern for a texture
-        int SetDefaultTexture( IDirect3DTexture9** p_ppiOut );
-
-        //------------------------------------------------------------------
-        // Convert a height map to a normal map if necessary
-        //
-        // The function tries to detect the type of a texture automatically.
-        // However, this won't work in every case.
-        void HMtoNMIfNecessary( IDirect3DTexture9* piTexture,
-            IDirect3DTexture9** piTextureOut,
-            bool bWasOriginallyHM = true );
-
-        //------------------------------------------------------------------
-        // Search for non-opaque pixels in a texture
-        //
-        // A pixel is considered to be non-opaque if its alpha value is
-        // less than 255
-        //------------------------------------------------------------------
-        bool HasAlphaPixels( IDirect3DTexture9* piTexture );
-
-    private:
-
-        //
-        // Specifies the number of different shaders generated for
-        // the current asset. This number is incremented by CreateMaterial()
-        // each time a shader isn't found in cache and needs to be created
-        //
-        unsigned int m_iShaderCount;
-        IDirect3DTexture9* sDefaultTexture;
-
-        typedef std::map<std::string, IDirect3DTexture9*> TextureCache;
-        TextureCache sCachedTextures;
-    };
-
-}
+} // namespace AssimpView
diff --git a/tools/assimp_view/MeshRenderer.cpp b/tools/assimp_view/MeshRenderer.cpp
index 27bc6704f..d93bb4aea 100644
--- a/tools/assimp_view/MeshRenderer.cpp
+++ b/tools/assimp_view/MeshRenderer.cpp
@@ -161,4 +161,4 @@ int CMeshRenderer::DrawSorted(unsigned int iIndex,const aiMatrix4x4& mWorld) {
 
     return 1;
 }
-};
\ No newline at end of file
+};
diff --git a/tools/assimp_view/MeshRenderer.h b/tools/assimp_view/MeshRenderer.h
index 38cfa6326..d756a9984 100644
--- a/tools/assimp_view/MeshRenderer.h
+++ b/tools/assimp_view/MeshRenderer.h
@@ -96,4 +96,4 @@ namespace AssimpView {
     };
 
 }
-#endif //!! include guard
\ No newline at end of file
+#endif //!! include guard
diff --git a/tools/assimp_view/NOTE@help.rtf.txt b/tools/assimp_view/NOTE@help.rtf.txt
index f00962db6..dd20078e9 100644
--- a/tools/assimp_view/NOTE@help.rtf.txt
+++ b/tools/assimp_view/NOTE@help.rtf.txt
@@ -1,2 +1,2 @@
 text1.bin is the corresponding bin file to be included with the executable file.
-When updating the rich formatted text inside Visual Studio, a terminating 0 character must be appended
\ No newline at end of file
+When updating the rich formatted text inside Visual Studio, a terminating 0 character must be appended
diff --git a/tools/assimp_view/RenderOptions.h b/tools/assimp_view/RenderOptions.h
index bd9e8a871..69297419e 100644
--- a/tools/assimp_view/RenderOptions.h
+++ b/tools/assimp_view/RenderOptions.h
@@ -110,4 +110,4 @@ class RenderOptions
         bool bCulling,bSkeleton;
     };
 
-#endif // !! IG
\ No newline at end of file
+#endif // !! IG
diff --git a/tools/assimp_view/SceneAnimator.h b/tools/assimp_view/SceneAnimator.h
index 956edb3e3..33b8568a4 100644
--- a/tools/assimp_view/SceneAnimator.h
+++ b/tools/assimp_view/SceneAnimator.h
@@ -58,8 +58,8 @@ namespace AssimpView {
  */
 struct SceneAnimNode {
     std::string mName;
-    SceneAnimNode* mParent;
-    std::vector<SceneAnimNode*> mChildren;
+    SceneAnimNode *mParent;
+    std::vector<SceneAnimNode *> mChildren;
 
     //! most recently calculated local transform
     aiMatrix4x4 mLocalTransform;
@@ -71,30 +71,20 @@ struct SceneAnimNode {
     int mChannelIndex;
 
     //! Default construction
-    SceneAnimNode()
-    : mName()
-    , mParent(nullptr)
-    , mChildren()
-    , mLocalTransform()
-    , mGlobalTransform()
-    , mChannelIndex(-1) {
+    SceneAnimNode() :
+            mName(), mParent(nullptr), mChildren(), mLocalTransform(), mGlobalTransform(), mChannelIndex(-1) {
         // empty
     }
 
     //! Construction from a given name
-    SceneAnimNode( const std::string& pName)
-    : mName( pName)
-    , mParent(nullptr)
-    , mChildren()
-    , mLocalTransform()
-    , mGlobalTransform()
-    , mChannelIndex(-1) {
+    SceneAnimNode(const std::string &pName) :
+            mName(pName), mParent(nullptr), mChildren(), mLocalTransform(), mGlobalTransform(), mChannelIndex(-1) {
         // empty
     }
 
     //! Destruct all children recursively
     ~SceneAnimNode() {
-        for (std::vector<SceneAnimNode*>::iterator it = mChildren.begin(); it != mChildren.end(); ++it) {
+        for (std::vector<SceneAnimNode *>::iterator it = mChildren.begin(); it != mChildren.end(); ++it) {
             delete *it;
         }
     }
@@ -112,7 +102,6 @@ struct SceneAnimNode {
  */
 class SceneAnimator {
 public:
-
     // ----------------------------------------------------------------------------
     /** Constructor for a given scene.
      *
@@ -122,7 +111,7 @@ public:
      * @param pAnimIndex [optional] Index of the animation to play. Assumed to
      *  be 0 if not given.
      */
-    SceneAnimator( const aiScene* pScene, size_t pAnimIndex = 0);
+    SceneAnimator(const aiScene *pScene, size_t pAnimIndex = 0);
 
     /** Destructor */
     ~SceneAnimator();
@@ -132,14 +121,14 @@ public:
      * mapping structures, which might take a few cycles.
      * @param pAnimIndex Index of the animation in the scene's animation array
      */
-    void SetAnimIndex( size_t pAnimIndex);
+    void SetAnimIndex(size_t pAnimIndex);
 
     // ----------------------------------------------------------------------------
     /** Calculates the node transformations for the scene. Call this to get
      * uptodate results before calling one of the getters.
      * @param pTime Current time. Can be an arbitrary range.
      */
-    void Calculate( double pTime);
+    void Calculate(double pTime);
 
     // ----------------------------------------------------------------------------
     /** Retrieves the most recent local transformation matrix for the given node.
@@ -154,7 +143,7 @@ public:
      * @return A reference to the node's most recently calculated local
      *   transformation matrix.
      */
-    const aiMatrix4x4& GetLocalTransform( const aiNode* node) const;
+    const aiMatrix4x4 &GetLocalTransform(const aiNode *node) const;
 
     // ----------------------------------------------------------------------------
     /** Retrieves the most recent global transformation matrix for the given node.
@@ -169,7 +158,7 @@ public:
      * @return A reference to the node's most recently calculated global
      *   transformation matrix.
      */
-    const aiMatrix4x4& GetGlobalTransform( const aiNode* node) const;
+    const aiMatrix4x4 &GetGlobalTransform(const aiNode *node) const;
 
     // ----------------------------------------------------------------------------
     /** Calculates the bone matrices for the given mesh.
@@ -187,8 +176,8 @@ public:
      * @return A reference to a vector of bone matrices. Stays stable till the
      *   next call to GetBoneMatrices();
      */
-    const std::vector<aiMatrix4x4>& GetBoneMatrices( const aiNode* pNode,
-        size_t pMeshIndex = 0);
+    const std::vector<aiMatrix4x4> &GetBoneMatrices(const aiNode *pNode,
+            size_t pMeshIndex = 0);
 
     // ----------------------------------------------------------------------------
     /** @brief Get the current animation index
@@ -200,44 +189,43 @@ public:
     // ----------------------------------------------------------------------------
     /** @brief Get the current animation or NULL
      */
-    aiAnimation* CurrentAnim() const {
-        return  static_cast<unsigned int>( mCurrentAnimIndex ) < mScene->mNumAnimations ? mScene->mAnimations[ mCurrentAnimIndex ] : NULL;
+    aiAnimation *CurrentAnim() const {
+        return static_cast<unsigned int>(mCurrentAnimIndex) < mScene->mNumAnimations ? mScene->mAnimations[mCurrentAnimIndex] : NULL;
     }
 
 protected:
-
     /** Recursively creates an internal node structure matching the
      *  current scene and animation.
      */
-    SceneAnimNode* CreateNodeTree( aiNode* pNode, SceneAnimNode* pParent);
+    SceneAnimNode *CreateNodeTree(aiNode *pNode, SceneAnimNode *pParent);
 
     /** Recursively updates the internal node transformations from the
      *  given matrix array
      */
-    void UpdateTransforms( SceneAnimNode* pNode, const std::vector<aiMatrix4x4>& pTransforms);
+    void UpdateTransforms(SceneAnimNode *pNode, const std::vector<aiMatrix4x4> &pTransforms);
 
     /** Calculates the global transformation matrix for the given internal node */
-    void CalculateGlobalTransform( SceneAnimNode* pInternalNode);
+    void CalculateGlobalTransform(SceneAnimNode *pInternalNode);
 
 protected:
     /** The scene we're operating on */
-    const aiScene* mScene;
+    const aiScene *mScene;
 
     /** Current animation index */
     int mCurrentAnimIndex;
 
     /** The AnimEvaluator we use to calculate the current pose for the current animation */
-    AnimEvaluator* mAnimEvaluator;
+    AnimEvaluator *mAnimEvaluator;
 
     /** Root node of the internal scene structure */
-    SceneAnimNode* mRootNode;
+    SceneAnimNode *mRootNode;
 
     /** Name to node map to quickly find nodes by their name */
-    typedef std::map<const aiNode*, SceneAnimNode*> NodeMap;
+    typedef std::map<const aiNode *, SceneAnimNode *> NodeMap;
     NodeMap mNodesByName;
 
     /** Name to node map to quickly find nodes for given bones by their name */
-    typedef std::map<const char*, const aiNode*> BoneMap;
+    typedef std::map<const char *, const aiNode *> BoneMap;
     BoneMap mBoneNodesByName;
 
     /** Array to return transformations results inside. */
@@ -246,4 +234,4 @@ protected:
 
 } // end of namespace AssimpView
 
-#endif // AV_SCENEANIMATOR_H_INCLUDED
\ No newline at end of file
+#endif // AV_SCENEANIMATOR_H_INCLUDED
diff --git a/tools/assimp_view/Shaders.cpp b/tools/assimp_view/Shaders.cpp
index 8adb873a2..17c51bbda 100644
--- a/tools/assimp_view/Shaders.cpp
+++ b/tools/assimp_view/Shaders.cpp
@@ -1394,4 +1394,4 @@ std::string g_szCheckerBackgroundShader = std::string(
         "VertexShader = compile vs_3_0 DefaultVShader();\n"
         "}\n"
         "};\n");
-}; // namespace AssimpView
+} // namespace AssimpView
diff --git a/tools/assimp_view/assimp_view.cpp b/tools/assimp_view/assimp_view.cpp
index 79a902b2a..5342f14d0 100644
--- a/tools/assimp_view/assimp_view.cpp
+++ b/tools/assimp_view/assimp_view.cpp
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
@@ -41,15 +39,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-
 #include "assimp_view.h"
 #include <assimp/StringUtils.h>
 #include <map>
 
 #ifdef __MINGW32__
-#   include <mmsystem.h>
+#include <mmsystem.h>
 #else
-#   include <timeapi.h>
+#include <timeapi.h>
 #endif
 
 using namespace std;
@@ -61,122 +58,118 @@ extern std::string g_szDefaultShader;
 extern std::string g_szPassThroughShader;
 
 //-------------------------------------------------------------------------------
-HINSTANCE g_hInstance				= nullptr;
-HWND g_hDlg							= nullptr;
-IDirect3D9* g_piD3D					= nullptr;
-IDirect3DDevice9* g_piDevice		= nullptr;
-IDirect3DVertexDeclaration9* gDefaultVertexDecl = nullptr;
-double g_fFPS						= 0.0f;
+HINSTANCE g_hInstance = nullptr;
+HWND g_hDlg = nullptr;
+IDirect3D9 *g_piD3D = nullptr;
+IDirect3DDevice9 *g_piDevice = nullptr;
+IDirect3DVertexDeclaration9 *gDefaultVertexDecl = nullptr;
+double g_fFPS = 0.0f;
 char g_szFileName[MAX_PATH];
-ID3DXEffect* g_piDefaultEffect		= nullptr;
-ID3DXEffect* g_piNormalsEffect		= nullptr;
-ID3DXEffect* g_piPassThroughEffect	= nullptr;
-ID3DXEffect* g_piPatternEffect		= nullptr;
-bool g_bMousePressed				= false;
-bool g_bMousePressedR				= false;
-bool g_bMousePressedM				= false;
-bool g_bMousePressedBoth			= false;
-float g_fElpasedTime				= 0.0f;
+ID3DXEffect *g_piDefaultEffect = nullptr;
+ID3DXEffect *g_piNormalsEffect = nullptr;
+ID3DXEffect *g_piPassThroughEffect = nullptr;
+ID3DXEffect *g_piPatternEffect = nullptr;
+bool g_bMousePressed = false;
+bool g_bMousePressedR = false;
+bool g_bMousePressedM = false;
+bool g_bMousePressedBoth = false;
+float g_fElpasedTime = 0.0f;
 D3DCAPS9 g_sCaps;
-bool g_bLoadingFinished				= false;
-HANDLE g_hThreadHandle				= nullptr;
-float g_fWheelPos					= -10.0f;
-bool g_bLoadingCanceled				= false;
-IDirect3DTexture9* g_pcTexture		= nullptr;
-bool g_bPlay						= false;
+bool g_bLoadingFinished = false;
+HANDLE g_hThreadHandle = nullptr;
+float g_fWheelPos = -10.0f;
+bool g_bLoadingCanceled = false;
+IDirect3DTexture9 *g_pcTexture = nullptr;
+bool g_bPlay = false;
 double g_dCurrent = 0.;
 
 // default pp steps
 unsigned int ppsteps = aiProcess_CalcTangentSpace | // calculate tangents and bitangents if possible
-        aiProcess_JoinIdenticalVertices    | // join identical vertices/ optimize indexing
-        aiProcess_ValidateDataStructure    | // perform a full validation of the loader's output
-        aiProcess_ImproveCacheLocality     | // improve the cache locality of the output vertices
-        aiProcess_RemoveRedundantMaterials | // remove redundant materials
-        aiProcess_FindDegenerates          | // remove degenerated polygons from the import
-        aiProcess_FindInvalidData          | // detect invalid model data, such as invalid normal vectors
-        aiProcess_GenUVCoords              | // convert spherical, cylindrical, box and planar mapping to proper UVs
-        aiProcess_TransformUVCoords        | // preprocess UV transformations (scaling, translation ...)
-        aiProcess_FindInstances            | // search for instanced meshes and remove them by references to one master
-        aiProcess_LimitBoneWeights         | // limit bone weights to 4 per vertex
-        aiProcess_OptimizeMeshes		   | // join small meshes, if possible;
-        aiProcess_SplitByBoneCount         | // split meshes with too many bones. Necessary for our (limited) hardware skinning shader
-        0;
+                       aiProcess_JoinIdenticalVertices | // join identical vertices/ optimize indexing
+                       aiProcess_ValidateDataStructure | // perform a full validation of the loader's output
+                       aiProcess_ImproveCacheLocality | // improve the cache locality of the output vertices
+                       aiProcess_RemoveRedundantMaterials | // remove redundant materials
+                       aiProcess_FindDegenerates | // remove degenerated polygons from the import
+                       aiProcess_FindInvalidData | // detect invalid model data, such as invalid normal vectors
+                       aiProcess_GenUVCoords | // convert spherical, cylindrical, box and planar mapping to proper UVs
+                       aiProcess_TransformUVCoords | // preprocess UV transformations (scaling, translation ...)
+                       aiProcess_FindInstances | // search for instanced meshes and remove them by references to one master
+                       aiProcess_LimitBoneWeights | // limit bone weights to 4 per vertex
+                       aiProcess_OptimizeMeshes | // join small meshes, if possible;
+                       aiProcess_SplitByBoneCount | // split meshes with too many bones. Necessary for our (limited) hardware skinning shader
+                       0;
 
 unsigned int ppstepsdefault = ppsteps;
 
 bool nopointslines = false;
 
-extern bool g_bWasFlipped			/*= false*/;
+extern bool g_bWasFlipped /*= false*/;
 
 aiMatrix4x4 g_mWorld;
 aiMatrix4x4 g_mWorldRotate;
-aiVector3D g_vRotateSpeed			= aiVector3D(0.5f,0.5f,0.5f);
+aiVector3D g_vRotateSpeed = aiVector3D(0.5f, 0.5f, 0.5f);
 
 // NOTE: The second light direction is now computed from the first
-aiVector3D g_avLightDirs[1] = 
-{	aiVector3D(-0.5f,0.6f,0.2f)  };
+aiVector3D g_avLightDirs[1] = { aiVector3D(-0.5f, 0.6f, 0.2f) };
 
-D3DCOLOR g_avLightColors[3] = 
-{
-    D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0xFF),
-    D3DCOLOR_ARGB(0xFF,0xFF,0x00,0x00),
-    D3DCOLOR_ARGB(0xFF,0x05,0x05,0x05),
+ D3DCOLOR g_avLightColors[3] = {
+    D3DCOLOR_ARGB(0xFF, 0xFF, 0xFF, 0xFF),
+    D3DCOLOR_ARGB(0xFF, 0xFF, 0x00, 0x00),
+    D3DCOLOR_ARGB(0xFF, 0x05, 0x05, 0x05),
 };
 
 POINT g_mousePos;
 POINT g_LastmousePos;
-bool g_bFPSView						= false;
-bool g_bInvert						= false;
-EClickPos g_eClick					= EClickPos_Circle;
-unsigned int g_iCurrentColor		= 0;
+bool g_bFPSView = false;
+bool g_bInvert = false;
+EClickPos g_eClick = EClickPos_Circle;
+unsigned int g_iCurrentColor = 0;
 
-float g_fLightIntensity				= 1.0f;
-float g_fLightColor					= 1.0f;
+float g_fLightIntensity = 1.0f;
+float g_fLightColor = 1.0f;
 
 RenderOptions g_sOptions;
 Camera g_sCamera;
-AssetHelper *g_pcAsset				= nullptr;
+AssetHelper *g_pcAsset = nullptr;
 
 //
-// Contains the mask image for the HUD 
+// Contains the mask image for the HUD
 // (used to determine the position of a click)
 //
-unsigned char* g_szImageMask		= nullptr;
+unsigned char *g_szImageMask = nullptr;
 
 float g_fLoadTime = 0.0f;
 
-
 //-------------------------------------------------------------------------------
 // Entry point for the loader thread
 // The loader thread loads the asset while the progress dialog displays the
 // smart progress bar
 //-------------------------------------------------------------------------------
-DWORD WINAPI LoadThreadProc(LPVOID lpParameter)
-{
+DWORD WINAPI LoadThreadProc(LPVOID lpParameter) {
     UNREFERENCED_PARAMETER(lpParameter);
 
     // get current time
     double fCur = (double)timeGetTime();
 
-    aiPropertyStore* props = aiCreatePropertyStore();
-    aiSetImportPropertyInteger(props,AI_CONFIG_IMPORT_TER_MAKE_UVS,1);
-    aiSetImportPropertyFloat(props,AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,g_smoothAngle);
-    aiSetImportPropertyInteger(props,AI_CONFIG_PP_SBP_REMOVE,nopointslines ? aiPrimitiveType_LINE | aiPrimitiveType_POINT : 0 );
+    aiPropertyStore *props = aiCreatePropertyStore();
+    aiSetImportPropertyInteger(props, AI_CONFIG_IMPORT_TER_MAKE_UVS, 1);
+    aiSetImportPropertyFloat(props, AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, g_smoothAngle);
+    aiSetImportPropertyInteger(props, AI_CONFIG_PP_SBP_REMOVE, nopointslines ? aiPrimitiveType_LINE | aiPrimitiveType_POINT : 0);
 
-    aiSetImportPropertyInteger(props,AI_CONFIG_GLOB_MEASURE_TIME,1);
+    aiSetImportPropertyInteger(props, AI_CONFIG_GLOB_MEASURE_TIME, 1);
     //aiSetImportPropertyInteger(props,AI_CONFIG_PP_PTV_KEEP_HIERARCHY,1);
 
     // Call ASSIMPs C-API to load the file
-    g_pcAsset->pcScene = (aiScene*)aiImportFileExWithProperties(g_szFileName,
-        ppsteps | /* configurable pp steps */
-        aiProcess_GenSmoothNormals		   | // generate smooth normal vectors if not existing
-        aiProcess_SplitLargeMeshes         | // split large, unrenderable meshes into submeshes
-        aiProcess_Triangulate			   | // triangulate polygons with more than 3 edges
-        aiProcess_ConvertToLeftHanded	   | // convert everything to D3D left handed space
-        aiProcess_SortByPType              | // make 'clean' meshes which consist of a single typ of primitives
-        0,
-        nullptr,
-        props);
+    g_pcAsset->pcScene = (aiScene *)aiImportFileExWithProperties(g_szFileName,
+            ppsteps | /* configurable pp steps */
+                    aiProcess_GenSmoothNormals | // generate smooth normal vectors if not existing
+                    aiProcess_SplitLargeMeshes | // split large, unrenderable meshes into submeshes
+                    aiProcess_Triangulate | // triangulate polygons with more than 3 edges
+                    aiProcess_ConvertToLeftHanded | // convert everything to D3D left handed space
+                    aiProcess_SortByPType | // make 'clean' meshes which consist of a single typ of primitives
+                    0,
+            nullptr,
+            props);
 
     aiReleasePropertyStore(props);
 
@@ -186,14 +179,13 @@ DWORD WINAPI LoadThreadProc(LPVOID lpParameter)
     g_bLoadingFinished = true;
 
     // check whether the loading process has failed ...
-    if (nullptr == g_pcAsset->pcScene)
-    {
+    if (nullptr == g_pcAsset->pcScene) {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load this asset:",
-            D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
 
         // print ASSIMPs error string to the log display
         CLogDisplay::Instance().AddEntry(aiGetErrorString(),
-            D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
         return 1;
     }
 
@@ -204,38 +196,36 @@ DWORD WINAPI LoadThreadProc(LPVOID lpParameter)
 // load the current asset
 // THe path to the asset is specified in the global path variable
 //-------------------------------------------------------------------------------
-int LoadAsset()
-{
+int LoadAsset() {
     // set the world and world rotation matrices to the identity
     g_mWorldRotate = aiMatrix4x4();
     g_mWorld = aiMatrix4x4();
 
-//	char szTemp[MAX_PATH+64];
-//	sprintf(szTemp,"Starting to load %s",g_szFileName);
+    //	char szTemp[MAX_PATH+64];
+    //	sprintf(szTemp,"Starting to load %s",g_szFileName);
     CLogWindow::Instance().WriteLine(
-        "----------------------------------------------------------------------------");
-//	CLogWindow::Instance().WriteLine(szTemp);
-//	CLogWindow::Instance().WriteLine(
-//		"----------------------------------------------------------------------------");
+            "----------------------------------------------------------------------------");
+    //	CLogWindow::Instance().WriteLine(szTemp);
+    //	CLogWindow::Instance().WriteLine(
+    //		"----------------------------------------------------------------------------");
     CLogWindow::Instance().SetAutoUpdate(false);
 
     // create a helper thread to load the asset
     DWORD dwID;
     g_bLoadingCanceled = false;
     g_pcAsset = new AssetHelper();
-    g_hThreadHandle = CreateThread(nullptr,0,&LoadThreadProc,nullptr,0,&dwID);
+    g_hThreadHandle = CreateThread(nullptr, 0, &LoadThreadProc, nullptr, 0, &dwID);
 
-    if (!g_hThreadHandle)
-    {
+    if (!g_hThreadHandle) {
         CLogDisplay::Instance().AddEntry(
-            "[ERROR] Unable to create helper thread for loading",
-            D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                "[ERROR] Unable to create helper thread for loading",
+                D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
         return 0;
     }
 
     // show the progress bar dialog
-    DialogBox(g_hInstance,MAKEINTRESOURCE(IDD_LOADDIALOG),
-        g_hDlg,&ProgressMessageProc);
+    DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_LOADDIALOG),
+            g_hDlg, &ProgressMessageProc);
 
     // update the log window
     CLogWindow::Instance().SetAutoUpdate(true);
@@ -243,10 +233,8 @@ int LoadAsset()
 
     // now we should have loaded the asset. Check this ...
     g_bLoadingFinished = false;
-    if (!g_pcAsset || !g_pcAsset->pcScene)
-    {
-        if (g_pcAsset)
-        {
+    if (!g_pcAsset || !g_pcAsset->pcScene) {
+        if (g_pcAsset) {
             delete g_pcAsset;
             g_pcAsset = nullptr;
         }
@@ -255,40 +243,38 @@ int LoadAsset()
 
     // allocate a new MeshHelper array and build a new instance
     // for each mesh in the original asset
-    g_pcAsset->apcMeshes = new AssetHelper::MeshHelper*[g_pcAsset->pcScene->mNumMeshes]();
-    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
+    g_pcAsset->apcMeshes = new AssetHelper::MeshHelper *[g_pcAsset->pcScene->mNumMeshes]();
+    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i)
         g_pcAsset->apcMeshes[i] = new AssetHelper::MeshHelper();
 
-
     // create animator
-    g_pcAsset->mAnimator = new SceneAnimator( g_pcAsset->pcScene);
+    g_pcAsset->mAnimator = new SceneAnimator(g_pcAsset->pcScene);
 
     // build a new caption string for the viewer
-	static const size_t Size = MAX_PATH + 10;
-	char szOut[Size];
-    ai_snprintf(szOut, Size,AI_VIEW_CAPTION_BASE " [%s]",g_szFileName);
-    SetWindowText(g_hDlg,szOut);
+    static const size_t Size = MAX_PATH + 10;
+    char szOut[Size];
+    ai_snprintf(szOut, Size, AI_VIEW_CAPTION_BASE " [%s]", g_szFileName);
+    SetWindowText(g_hDlg, szOut);
 
     // scale the asset vertices to fit into the viewer window
     ScaleAsset();
 
     // reset the camera view to the default position
-    g_sCamera.vPos = aiVector3D(0.0f,0.0f,-10.0f);
-    g_sCamera.vLookAt = aiVector3D(0.0f,0.0f,1.0f);
-    g_sCamera.vUp = aiVector3D(0.0f,1.0f,0.0f);
-    g_sCamera.vRight = aiVector3D(0.0f,1.0f,0.0f);
+    g_sCamera.vPos = aiVector3D(0.0f, 0.0f, -10.0f);
+    g_sCamera.vLookAt = aiVector3D(0.0f, 0.0f, 1.0f);
+    g_sCamera.vUp = aiVector3D(0.0f, 1.0f, 0.0f);
+    g_sCamera.vRight = aiVector3D(0.0f, 1.0f, 0.0f);
 
     // build native D3D vertex/index buffers, textures, materials
-    if( 1 != CreateAssetData())
+    if (1 != CreateAssetData())
         return 0;
 
     if (!g_pcAsset->pcScene->HasAnimations()) {
-        EnableWindow(GetDlgItem(g_hDlg,IDC_PLAY),FALSE);
-        EnableWindow(GetDlgItem(g_hDlg,IDC_SLIDERANIM),FALSE);
-    }
-    else {
-        EnableWindow(GetDlgItem(g_hDlg,IDC_PLAY),TRUE);
-        EnableWindow(GetDlgItem(g_hDlg,IDC_SLIDERANIM),TRUE);
+        EnableWindow(GetDlgItem(g_hDlg, IDC_PLAY), FALSE);
+        EnableWindow(GetDlgItem(g_hDlg, IDC_SLIDERANIM), FALSE);
+    } else {
+        EnableWindow(GetDlgItem(g_hDlg, IDC_PLAY), TRUE);
+        EnableWindow(GetDlgItem(g_hDlg, IDC_SLIDERANIM), TRUE);
     }
 
     CLogDisplay::Instance().AddEntry("[OK] The asset has been loaded successfully");
@@ -296,7 +282,7 @@ int LoadAsset()
     CDisplay::Instance().FillAnimList();
 
     CDisplay::Instance().FillDefaultStatistics();
-    
+
     // render the scene once
     CDisplay::Instance().OnRender();
 
@@ -305,7 +291,6 @@ int LoadAsset()
     return 1;
 }
 
-
 //-------------------------------------------------------------------------------
 // Delete the loaded asset
 // The function does nothing is no asset is loaded
@@ -320,8 +305,7 @@ int DeleteAsset(void) {
 
     // delete everything
     DeleteAssetData();
-    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-    {
+    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i) {
         delete g_pcAsset->apcMeshes[i];
     }
     aiReleaseImport(g_pcAsset->pcScene);
@@ -331,7 +315,7 @@ int DeleteAsset(void) {
     g_pcAsset = nullptr;
 
     // reset the caption of the viewer window
-    SetWindowText(g_hDlg,AI_VIEW_CAPTION_BASE);
+    SetWindowText(g_hDlg, AI_VIEW_CAPTION_BASE);
 
     // clear UI
     CDisplay::Instance().ClearAnimList();
@@ -342,7 +326,6 @@ int DeleteAsset(void) {
     return 1;
 }
 
-
 //-------------------------------------------------------------------------------
 // Calculate the boundaries of a given node and all of its children
 // The boundaries are in Worldspace (AABB)
@@ -350,7 +333,7 @@ int DeleteAsset(void) {
 // p_avOut Receives the min/max boundaries. Must point to 2 vec3s
 // piMatrix Transformation matrix of the graph at this position
 //-------------------------------------------------------------------------------
-int CalculateBounds(aiNode* piNode, aiVector3D* p_avOut, const aiMatrix4x4& piMatrix) {
+int CalculateBounds(aiNode *piNode, aiVector3D *p_avOut, const aiMatrix4x4 &piMatrix) {
     ai_assert(nullptr != piNode);
     ai_assert(nullptr != p_avOut);
 
@@ -358,28 +341,24 @@ int CalculateBounds(aiNode* piNode, aiVector3D* p_avOut, const aiMatrix4x4& piMa
     mTemp.Transpose();
     aiMatrix4x4 aiMe = mTemp * piMatrix;
 
-    for (unsigned int i = 0; i < piNode->mNumMeshes;++i)
-    {
-        for( unsigned int a = 0; a < g_pcAsset->pcScene->mMeshes[
-            piNode->mMeshes[i]]->mNumVertices;++a)
-        {
-            aiVector3D pc =g_pcAsset->pcScene->mMeshes[piNode->mMeshes[i]]->mVertices[a];
+    for (unsigned int i = 0; i < piNode->mNumMeshes; ++i) {
+        for (unsigned int a = 0; a < g_pcAsset->pcScene->mMeshes[piNode->mMeshes[i]]->mNumVertices; ++a) {
+            aiVector3D pc = g_pcAsset->pcScene->mMeshes[piNode->mMeshes[i]]->mVertices[a];
 
             aiVector3D pc1;
-            D3DXVec3TransformCoord((D3DXVECTOR3*)&pc1,(D3DXVECTOR3*)&pc,
-                (D3DXMATRIX*)&aiMe);
+            D3DXVec3TransformCoord((D3DXVECTOR3 *)&pc1, (D3DXVECTOR3 *)&pc,
+                    (D3DXMATRIX *)&aiMe);
 
-            p_avOut[0].x = min( p_avOut[0].x, pc1.x);
-            p_avOut[0].y = min( p_avOut[0].y, pc1.y);
-            p_avOut[0].z = min( p_avOut[0].z, pc1.z);
-            p_avOut[1].x = max( p_avOut[1].x, pc1.x);
-            p_avOut[1].y = max( p_avOut[1].y, pc1.y);
-            p_avOut[1].z = max( p_avOut[1].z, pc1.z);
+            p_avOut[0].x = min(p_avOut[0].x, pc1.x);
+            p_avOut[0].y = min(p_avOut[0].y, pc1.y);
+            p_avOut[0].z = min(p_avOut[0].z, pc1.z);
+            p_avOut[1].x = max(p_avOut[1].x, pc1.x);
+            p_avOut[1].y = max(p_avOut[1].y, pc1.y);
+            p_avOut[1].z = max(p_avOut[1].z, pc1.z);
         }
     }
-    for (unsigned int i = 0; i < piNode->mNumChildren;++i)
-    {
-        CalculateBounds( piNode->mChildren[i], p_avOut, aiMe );
+    for (unsigned int i = 0; i < piNode->mNumChildren; ++i) {
+        CalculateBounds(piNode->mChildren[i], p_avOut, aiMe);
     }
     return 1;
 }
@@ -388,31 +367,29 @@ int CalculateBounds(aiNode* piNode, aiVector3D* p_avOut, const aiMatrix4x4& piMa
 // The function calculates the boundaries of the mesh and modifies the
 // global world transformation matrix according to the aset AABB
 //-------------------------------------------------------------------------------
-int ScaleAsset(void)
-{
-    aiVector3D aiVecs[2] = {aiVector3D( 1e10f, 1e10f, 1e10f),
-        aiVector3D( -1e10f, -1e10f, -1e10f) };
+int ScaleAsset(void) {
+    aiVector3D aiVecs[2] = { aiVector3D(1e10f, 1e10f, 1e10f),
+        aiVector3D(-1e10f, -1e10f, -1e10f) };
 
-    if (g_pcAsset->pcScene->mRootNode)
-    {
+    if (g_pcAsset->pcScene->mRootNode) {
         aiMatrix4x4 m;
-        CalculateBounds(g_pcAsset->pcScene->mRootNode,aiVecs,m);
+        CalculateBounds(g_pcAsset->pcScene->mRootNode, aiVecs, m);
     }
 
-    aiVector3D vDelta = aiVecs[1]-aiVecs[0];
-    aiVector3D vHalf =  aiVecs[0] + (vDelta / 2.0f);
+    aiVector3D vDelta = aiVecs[1] - aiVecs[0];
+    aiVector3D vHalf = aiVecs[0] + (vDelta / 2.0f);
     float fScale = 10.0f / vDelta.Length();
 
-    g_mWorld =  aiMatrix4x4(
-        1.0f,0.0f,0.0f,0.0f,
-        0.0f,1.0f,0.0f,0.0f,
-        0.0f,0.0f,1.0f,0.0f,
-        -vHalf.x,-vHalf.y,-vHalf.z,1.0f) *
-        aiMatrix4x4(
-        fScale,0.0f,0.0f,0.0f,
-        0.0f,fScale,0.0f,0.0f,
-        0.0f,0.0f,fScale,0.0f,
-        0.0f,0.0f,0.0f,1.0f);
+    g_mWorld = aiMatrix4x4(
+                       1.0f, 0.0f, 0.0f, 0.0f,
+                       0.0f, 1.0f, 0.0f, 0.0f,
+                       0.0f, 0.0f, 1.0f, 0.0f,
+                       -vHalf.x, -vHalf.y, -vHalf.z, 1.0f) *
+               aiMatrix4x4(
+                       fScale, 0.0f, 0.0f, 0.0f,
+                       0.0f, fScale, 0.0f, 0.0f,
+                       0.0f, 0.0f, fScale, 0.0f,
+                       0.0f, 0.0f, 0.0f, 1.0f);
     return 1;
 }
 
@@ -422,30 +399,27 @@ int ScaleAsset(void)
 // pcMesh Input mesh
 // pcSource Source mesh from ASSIMP
 //-------------------------------------------------------------------------------
-int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource)
-{
+int GenerateNormalsAsLineList(AssetHelper::MeshHelper *pcMesh, const aiMesh *pcSource) {
     ai_assert(nullptr != pcMesh);
     ai_assert(nullptr != pcSource);
 
-    if (!pcSource->mNormals)return 0;
+    if (!pcSource->mNormals) return 0;
 
     // create vertex buffer
-    if(FAILED( g_piDevice->CreateVertexBuffer(sizeof(AssetHelper::LineVertex) *
-        pcSource->mNumVertices * 2,
-        D3DUSAGE_WRITEONLY,
-        AssetHelper::LineVertex::GetFVF(),
-        D3DPOOL_DEFAULT, &pcMesh->piVBNormals,nullptr)))
-    {
+    if (FAILED(g_piDevice->CreateVertexBuffer(sizeof(AssetHelper::LineVertex) *
+                                                      pcSource->mNumVertices * 2,
+                D3DUSAGE_WRITEONLY,
+                AssetHelper::LineVertex::GetFVF(),
+                D3DPOOL_DEFAULT, &pcMesh->piVBNormals, nullptr))) {
         CLogDisplay::Instance().AddEntry("Failed to create vertex buffer for the normal list",
-            D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
         return 2;
     }
 
     // now fill the vertex buffer with data
-    AssetHelper::LineVertex* pbData2;
-    pcMesh->piVBNormals->Lock(0,0,(void**)&pbData2,0);
-    for (unsigned int x = 0; x < pcSource->mNumVertices;++x)
-    {
+    AssetHelper::LineVertex *pbData2;
+    pcMesh->piVBNormals->Lock(0, 0, (void **)&pbData2, 0);
+    for (unsigned int x = 0; x < pcSource->mNumVertices; ++x) {
         pbData2->vPosition = pcSource->mVertices[x];
 
         ++pbData2;
@@ -456,9 +430,9 @@ int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSo
         // scalo with the inverse of the world scaling to make sure
         // the normals have equal length in each case
         // TODO: Check whether this works in every case, I don't think so
-        vNormal.x /= g_mWorld.a1*4;
-        vNormal.y /= g_mWorld.b2*4;
-        vNormal.z /= g_mWorld.c3*4;
+        vNormal.x /= g_mWorld.a1 * 4;
+        vNormal.y /= g_mWorld.b2 * 4;
+        vNormal.z /= g_mWorld.c3 * 4;
 
         pbData2->vPosition = pcSource->mVertices[x] + vNormal;
 
@@ -472,32 +446,30 @@ int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSo
 // Create the native D3D representation of the asset: vertex buffers,
 // index buffers, materials ...
 //-------------------------------------------------------------------------------
-int CreateAssetData()
-{
-    if (!g_pcAsset)return 0;
+int CreateAssetData() {
+    if (!g_pcAsset) return 0;
 
     // reset all subsystems
     CMaterialManager::Instance().Reset();
     CDisplay::Instance().Reset();
 
-    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-    {
-        const aiMesh* mesh = g_pcAsset->pcScene->mMeshes[i];
+    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i) {
+        const aiMesh *mesh = g_pcAsset->pcScene->mMeshes[i];
 
         // create the material for the mesh
-        if (!g_pcAsset->apcMeshes[i]->piEffect)	{
+        if (!g_pcAsset->apcMeshes[i]->piEffect) {
             CMaterialManager::Instance().CreateMaterial(
-                g_pcAsset->apcMeshes[i],mesh);
+                    g_pcAsset->apcMeshes[i], mesh);
         }
 
         // create vertex buffer
-        if(FAILED( g_piDevice->CreateVertexBuffer(sizeof(AssetHelper::Vertex) *
-            mesh->mNumVertices,
-            D3DUSAGE_WRITEONLY,
-            0,
-            D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piVB,nullptr)))	{
-            MessageBox(g_hDlg,"Failed to create vertex buffer",
-                "ASSIMP Viewer Utility",MB_OK);
+        if (FAILED(g_piDevice->CreateVertexBuffer(sizeof(AssetHelper::Vertex) *
+                                                          mesh->mNumVertices,
+                    D3DUSAGE_WRITEONLY,
+                    0,
+                    D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piVB, nullptr))) {
+            MessageBox(g_hDlg, "Failed to create vertex buffer",
+                    "ASSIMP Viewer Utility", MB_OK);
             return 2;
         }
 
@@ -507,18 +479,18 @@ int CreateAssetData()
 
         unsigned int nidx = 0;
         switch (mesh->mPrimitiveTypes) {
-            case aiPrimitiveType_POINT:
-                nidx = 1;
-                break;
-            case aiPrimitiveType_LINE:
-                nidx = 2;
-                break;
-            case aiPrimitiveType_TRIANGLE:
-                nidx = 3;
-                break;
-            default: 
-                ai_assert(false);
-                break;
+        case aiPrimitiveType_POINT:
+            nidx = 1;
+            break;
+        case aiPrimitiveType_LINE:
+            nidx = 2;
+            break;
+        case aiPrimitiveType_TRIANGLE:
+            nidx = 3;
+            break;
+        default:
+            ai_assert(false);
+            break;
         };
 
         unsigned int numIndices = mesh->mNumFaces * 3;
@@ -526,54 +498,47 @@ int CreateAssetData()
             numIndices = mesh->mNumVertices;
         }
         // check whether we can use 16 bit indices
-        if (numIndices >= 65536)	{
+        if (numIndices >= 65536) {
             // create 32 bit index buffer
-            if(FAILED( g_piDevice->CreateIndexBuffer( 4 *
-                numIndices,
-                D3DUSAGE_WRITEONLY | dwUsage,
-                D3DFMT_INDEX32,
-                D3DPOOL_DEFAULT, 
-                &g_pcAsset->apcMeshes[i]->piIB,
-                nullptr)))
-            {
-                MessageBox(g_hDlg,"Failed to create 32 Bit index buffer",
-                    "ASSIMP Viewer Utility",MB_OK);
+            if (FAILED(g_piDevice->CreateIndexBuffer(4 *
+                                                             numIndices,
+                        D3DUSAGE_WRITEONLY | dwUsage,
+                        D3DFMT_INDEX32,
+                        D3DPOOL_DEFAULT,
+                        &g_pcAsset->apcMeshes[i]->piIB,
+                        nullptr))) {
+                MessageBox(g_hDlg, "Failed to create 32 Bit index buffer",
+                        "ASSIMP Viewer Utility", MB_OK);
                 return 2;
             }
 
             // now fill the index buffer
-            unsigned int* pbData;
-            g_pcAsset->apcMeshes[i]->piIB->Lock(0,0,(void**)&pbData,0);
-            for (unsigned int x = 0; x < mesh->mNumFaces;++x)
-            {
-                for (unsigned int a = 0; a < nidx;++a)
-                {
+            unsigned int *pbData;
+            g_pcAsset->apcMeshes[i]->piIB->Lock(0, 0, (void **)&pbData, 0);
+            for (unsigned int x = 0; x < mesh->mNumFaces; ++x) {
+                for (unsigned int a = 0; a < nidx; ++a) {
                     *pbData++ = mesh->mFaces[x].mIndices[a];
                 }
             }
-        }
-        else	{
+        } else {
             // create 16 bit index buffer
-            if(FAILED( g_piDevice->CreateIndexBuffer( 2 *
-                numIndices,
-                D3DUSAGE_WRITEONLY | dwUsage,
-                D3DFMT_INDEX16,
-                D3DPOOL_DEFAULT,
-                &g_pcAsset->apcMeshes[i]->piIB,
-                nullptr)))
-            {
-                MessageBox(g_hDlg,"Failed to create 16 Bit index buffer",
-                    "ASSIMP Viewer Utility",MB_OK);
+            if (FAILED(g_piDevice->CreateIndexBuffer(2 *
+                                                             numIndices,
+                        D3DUSAGE_WRITEONLY | dwUsage,
+                        D3DFMT_INDEX16,
+                        D3DPOOL_DEFAULT,
+                        &g_pcAsset->apcMeshes[i]->piIB,
+                        nullptr))) {
+                MessageBox(g_hDlg, "Failed to create 16 Bit index buffer",
+                        "ASSIMP Viewer Utility", MB_OK);
                 return 2;
             }
 
             // now fill the index buffer
-            uint16_t* pbData;
-            g_pcAsset->apcMeshes[i]->piIB->Lock(0,0,(void**)&pbData,0);
-            for (unsigned int x = 0; x < mesh->mNumFaces;++x)
-            {
-                for (unsigned int a = 0; a < nidx;++a)
-                {
+            uint16_t *pbData;
+            g_pcAsset->apcMeshes[i]->piIB->Lock(0, 0, (void **)&pbData, 0);
+            for (unsigned int x = 0; x < mesh->mNumFaces; ++x) {
+                for (unsigned int a = 0; a < nidx; ++a) {
                     *pbData++ = (uint16_t)mesh->mFaces[x].mIndices[a];
                 }
             }
@@ -581,74 +546,71 @@ int CreateAssetData()
         g_pcAsset->apcMeshes[i]->piIB->Unlock();
 
         // collect weights on all vertices. Quick and careless
-        std::vector<std::vector<aiVertexWeight> > weightsPerVertex( mesh->mNumVertices);
-        for( unsigned int a = 0; a < mesh->mNumBones; a++)	{
-            const aiBone* bone = mesh->mBones[a];
-            for( unsigned int b = 0; b < bone->mNumWeights; b++)
-                weightsPerVertex[bone->mWeights[b].mVertexId].push_back( aiVertexWeight( a, bone->mWeights[b].mWeight));
+        std::vector<std::vector<aiVertexWeight>> weightsPerVertex(mesh->mNumVertices);
+        for (unsigned int a = 0; a < mesh->mNumBones; a++) {
+            const aiBone *bone = mesh->mBones[a];
+            for (unsigned int b = 0; b < bone->mNumWeights; b++)
+                weightsPerVertex[bone->mWeights[b].mVertexId].push_back(aiVertexWeight(a, bone->mWeights[b].mWeight));
         }
 
         // now fill the vertex buffer
-        AssetHelper::Vertex* pbData2;
-        g_pcAsset->apcMeshes[i]->piVB->Lock(0,0,(void**)&pbData2,0);
-        for (unsigned int x = 0; x < mesh->mNumVertices;++x)
-        {
+        AssetHelper::Vertex *pbData2;
+        g_pcAsset->apcMeshes[i]->piVB->Lock(0, 0, (void **)&pbData2, 0);
+        for (unsigned int x = 0; x < mesh->mNumVertices; ++x) {
             pbData2->vPosition = mesh->mVertices[x];
 
             if (nullptr == mesh->mNormals)
-                pbData2->vNormal = aiVector3D(0.0f,0.0f,0.0f);
-            else pbData2->vNormal = mesh->mNormals[x];
+                pbData2->vNormal = aiVector3D(0.0f, 0.0f, 0.0f);
+            else
+                pbData2->vNormal = mesh->mNormals[x];
 
-            if (nullptr == mesh->mTangents)	{
-                pbData2->vTangent = aiVector3D(0.0f,0.0f,0.0f);
-                pbData2->vBitangent = aiVector3D(0.0f,0.0f,0.0f);
-            }
-            else	{
+            if (nullptr == mesh->mTangents) {
+                pbData2->vTangent = aiVector3D(0.0f, 0.0f, 0.0f);
+                pbData2->vBitangent = aiVector3D(0.0f, 0.0f, 0.0f);
+            } else {
                 pbData2->vTangent = mesh->mTangents[x];
                 pbData2->vBitangent = mesh->mBitangents[x];
             }
 
-            if (mesh->HasVertexColors( 0))	{
+            if (mesh->HasVertexColors(0)) {
                 pbData2->dColorDiffuse = D3DCOLOR_ARGB(
-                    ((unsigned char)max( min( mesh->mColors[0][x].a * 255.0f, 255.0f),0.0f)),
-                    ((unsigned char)max( min( mesh->mColors[0][x].r * 255.0f, 255.0f),0.0f)),
-                    ((unsigned char)max( min( mesh->mColors[0][x].g * 255.0f, 255.0f),0.0f)),
-                    ((unsigned char)max( min( mesh->mColors[0][x].b * 255.0f, 255.0f),0.0f)));
-            }
-            else pbData2->dColorDiffuse = D3DCOLOR_ARGB(0xFF,0xff,0xff,0xff);
+                        ((unsigned char)max(min(mesh->mColors[0][x].a * 255.0f, 255.0f), 0.0f)),
+                        ((unsigned char)max(min(mesh->mColors[0][x].r * 255.0f, 255.0f), 0.0f)),
+                        ((unsigned char)max(min(mesh->mColors[0][x].g * 255.0f, 255.0f), 0.0f)),
+                        ((unsigned char)max(min(mesh->mColors[0][x].b * 255.0f, 255.0f), 0.0f)));
+            } else
+                pbData2->dColorDiffuse = D3DCOLOR_ARGB(0xFF, 0xff, 0xff, 0xff);
 
             // ignore a third texture coordinate component
-            if (mesh->HasTextureCoords( 0))	{
+            if (mesh->HasTextureCoords(0)) {
                 pbData2->vTextureUV = aiVector2D(
-                    mesh->mTextureCoords[0][x].x,
-                    mesh->mTextureCoords[0][x].y);
-            }
-            else pbData2->vTextureUV = aiVector2D(0.5f,0.5f);
+                        mesh->mTextureCoords[0][x].x,
+                        mesh->mTextureCoords[0][x].y);
+            } else
+                pbData2->vTextureUV = aiVector2D(0.5f, 0.5f);
 
-            if (mesh->HasTextureCoords( 1))	{
+            if (mesh->HasTextureCoords(1)) {
                 pbData2->vTextureUV2 = aiVector2D(
-                    mesh->mTextureCoords[1][x].x,
-                    mesh->mTextureCoords[1][x].y);
-            }
-            else pbData2->vTextureUV2 = aiVector2D(0.5f,0.5f);
+                        mesh->mTextureCoords[1][x].x,
+                        mesh->mTextureCoords[1][x].y);
+            } else
+                pbData2->vTextureUV2 = aiVector2D(0.5f, 0.5f);
 
             // Bone indices and weights
-            if( mesh->HasBones())	{
+            if (mesh->HasBones()) {
                 unsigned char boneIndices[4] = { 0, 0, 0, 0 };
                 unsigned char boneWeights[4] = { 0, 0, 0, 0 };
-                ai_assert( weightsPerVertex[x].size() <= 4);
-                for( unsigned int a = 0; a < weightsPerVertex[x].size(); a++)
-                {
+                ai_assert(weightsPerVertex[x].size() <= 4);
+                for (unsigned int a = 0; a < weightsPerVertex[x].size(); a++) {
                     boneIndices[a] = static_cast<unsigned char>(weightsPerVertex[x][a].mVertexId);
-                    boneWeights[a] = (unsigned char) (weightsPerVertex[x][a].mWeight * 255.0f);
+                    boneWeights[a] = (unsigned char)(weightsPerVertex[x][a].mWeight * 255.0f);
                 }
 
-                memcpy( pbData2->mBoneIndices, boneIndices, sizeof( boneIndices));
-                memcpy( pbData2->mBoneWeights, boneWeights, sizeof( boneWeights));
-            } else
-            {
-                memset( pbData2->mBoneIndices, 0, sizeof( pbData2->mBoneIndices));
-                memset( pbData2->mBoneWeights, 0, sizeof( pbData2->mBoneWeights));
+                memcpy(pbData2->mBoneIndices, boneIndices, sizeof(boneIndices));
+                memcpy(pbData2->mBoneWeights, boneWeights, sizeof(boneWeights));
+            } else {
+                memset(pbData2->mBoneIndices, 0, sizeof(pbData2->mBoneIndices));
+                memset(pbData2->mBoneWeights, 0, sizeof(pbData2->mBoneWeights));
             }
 
             ++pbData2;
@@ -656,8 +618,8 @@ int CreateAssetData()
         g_pcAsset->apcMeshes[i]->piVB->Unlock();
 
         // now generate the second vertex buffer, holding all normals
-        if (!g_pcAsset->apcMeshes[i]->piVBNormals)	{
-            GenerateNormalsAsLineList(g_pcAsset->apcMeshes[i],mesh);
+        if (!g_pcAsset->apcMeshes[i]->piVBNormals) {
+            GenerateNormalsAsLineList(g_pcAsset->apcMeshes[i], mesh);
         }
     }
     return 1;
@@ -667,25 +629,20 @@ int CreateAssetData()
 // Delete all effects, textures, vertex buffers ... associated with
 // an asset
 //-------------------------------------------------------------------------------
-int DeleteAssetData(bool bNoMaterials)
-{
-    if (!g_pcAsset)return 0;
+int DeleteAssetData(bool bNoMaterials) {
+    if (!g_pcAsset) return 0;
 
     // TODO: Move this to a proper destructor
-    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-    {
-        if(g_pcAsset->apcMeshes[i]->piVB)
-        {
+    for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i) {
+        if (g_pcAsset->apcMeshes[i]->piVB) {
             g_pcAsset->apcMeshes[i]->piVB->Release();
             g_pcAsset->apcMeshes[i]->piVB = nullptr;
         }
-        if(g_pcAsset->apcMeshes[i]->piVBNormals)
-        {
+        if (g_pcAsset->apcMeshes[i]->piVBNormals) {
             g_pcAsset->apcMeshes[i]->piVBNormals->Release();
             g_pcAsset->apcMeshes[i]->piVBNormals = nullptr;
         }
-        if(g_pcAsset->apcMeshes[i]->piIB)
-        {
+        if (g_pcAsset->apcMeshes[i]->piIB) {
             g_pcAsset->apcMeshes[i]->piIB->Release();
             g_pcAsset->apcMeshes[i]->piIB = nullptr;
         }
@@ -698,45 +655,36 @@ int DeleteAssetData(bool bNoMaterials)
         //	delete[] g_pcAsset->apcMeshes[i]->pvOriginalNormals;
         //}
 
-        if (!bNoMaterials)
-        {
-            if(g_pcAsset->apcMeshes[i]->piEffect)
-            {
+        if (!bNoMaterials) {
+            if (g_pcAsset->apcMeshes[i]->piEffect) {
                 g_pcAsset->apcMeshes[i]->piEffect->Release();
                 g_pcAsset->apcMeshes[i]->piEffect = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piDiffuseTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piDiffuseTexture) {
                 g_pcAsset->apcMeshes[i]->piDiffuseTexture->Release();
                 g_pcAsset->apcMeshes[i]->piDiffuseTexture = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piNormalTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piNormalTexture) {
                 g_pcAsset->apcMeshes[i]->piNormalTexture->Release();
                 g_pcAsset->apcMeshes[i]->piNormalTexture = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piSpecularTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piSpecularTexture) {
                 g_pcAsset->apcMeshes[i]->piSpecularTexture->Release();
                 g_pcAsset->apcMeshes[i]->piSpecularTexture = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piAmbientTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piAmbientTexture) {
                 g_pcAsset->apcMeshes[i]->piAmbientTexture->Release();
                 g_pcAsset->apcMeshes[i]->piAmbientTexture = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piEmissiveTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piEmissiveTexture) {
                 g_pcAsset->apcMeshes[i]->piEmissiveTexture->Release();
                 g_pcAsset->apcMeshes[i]->piEmissiveTexture = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piOpacityTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piOpacityTexture) {
                 g_pcAsset->apcMeshes[i]->piOpacityTexture->Release();
                 g_pcAsset->apcMeshes[i]->piOpacityTexture = nullptr;
             }
-            if(g_pcAsset->apcMeshes[i]->piShininessTexture)
-            {
+            if (g_pcAsset->apcMeshes[i]->piShininessTexture) {
                 g_pcAsset->apcMeshes[i]->piShininessTexture->Release();
                 g_pcAsset->apcMeshes[i]->piShininessTexture = nullptr;
             }
@@ -745,27 +693,22 @@ int DeleteAssetData(bool bNoMaterials)
     return 1;
 }
 
-
 //-------------------------------------------------------------------------------
 // Switch between zoom/rotate view and the standard FPS view
 // g_bFPSView specifies the view mode to setup
 //-------------------------------------------------------------------------------
-int SetupFPSView()
-{
-    if (!g_bFPSView)
-    {
-        g_sCamera.vPos = aiVector3D(0.0f,0.0f,g_fWheelPos);
-        g_sCamera.vLookAt = aiVector3D(0.0f,0.0f,1.0f);
-        g_sCamera.vUp = aiVector3D(0.0f,1.0f,0.0f);
-        g_sCamera.vRight = aiVector3D(0.0f,1.0f,0.0f);
-    }
-    else
-    {
+int SetupFPSView() {
+    if (!g_bFPSView) {
+        g_sCamera.vPos = aiVector3D(0.0f, 0.0f, g_fWheelPos);
+        g_sCamera.vLookAt = aiVector3D(0.0f, 0.0f, 1.0f);
+        g_sCamera.vUp = aiVector3D(0.0f, 1.0f, 0.0f);
+        g_sCamera.vRight = aiVector3D(0.0f, 1.0f, 0.0f);
+    } else {
         g_fWheelPos = g_sCamera.vPos.z;
-        g_sCamera.vPos = aiVector3D(0.0f,0.0f,-10.0f);
-        g_sCamera.vLookAt = aiVector3D(0.0f,0.0f,1.0f);
-        g_sCamera.vUp = aiVector3D(0.0f,1.0f,0.0f);
-        g_sCamera.vRight = aiVector3D(0.0f,1.0f,0.0f);
+        g_sCamera.vPos = aiVector3D(0.0f, 0.0f, -10.0f);
+        g_sCamera.vLookAt = aiVector3D(0.0f, 0.0f, 1.0f);
+        g_sCamera.vUp = aiVector3D(0.0f, 1.0f, 0.0f);
+        g_sCamera.vRight = aiVector3D(0.0f, 1.0f, 0.0f);
     }
     return 1;
 }
@@ -774,35 +717,29 @@ int SetupFPSView()
 // Initialize the IDIrect3D interface
 // Called by the WinMain
 //-------------------------------------------------------------------------------
-int InitD3D(void)
-{
-    if (nullptr == g_piD3D)
-    {
+int InitD3D(void) {
+    if (nullptr == g_piD3D) {
         g_piD3D = Direct3DCreate9(D3D_SDK_VERSION);
-        if (nullptr == g_piD3D)return 0;
+        if (nullptr == g_piD3D) return 0;
     }
     return 1;
 }
 
-
 //-------------------------------------------------------------------------------
 // Release the IDirect3D interface.
 // NOTE: Assumes that the device has already been deleted
 //-------------------------------------------------------------------------------
-int ShutdownD3D(void)
-{
+int ShutdownD3D(void) {
     ShutdownDevice();
-    if (nullptr != g_piD3D)
-    {
+    if (nullptr != g_piD3D) {
         g_piD3D->Release();
         g_piD3D = nullptr;
     }
     return 1;
 }
 
-template<class TComPtr>
-inline 
-void SafeRelease(TComPtr *&ptr) {
+template <class TComPtr>
+inline void SafeRelease(TComPtr *&ptr) {
     if (nullptr != ptr) {
         ptr->Release();
         ptr = nullptr;
@@ -813,8 +750,7 @@ void SafeRelease(TComPtr *&ptr) {
 // Shutdown the D3D device object and all resources associated with it
 // NOTE: Assumes that the asset has already been deleted
 //-------------------------------------------------------------------------------
-int ShutdownDevice(void)
-{
+int ShutdownDevice(void) {
     // release other subsystems
     CBackgroundPainter::Instance().ReleaseNativeResource();
     CLogDisplay::Instance().ReleaseNativeResource();
@@ -837,35 +773,32 @@ int ShutdownDevice(void)
     return 1;
 }
 
-
 //-------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------
-int CreateHUDTexture()
-{
+int CreateHUDTexture() {
     // lock the memory resource ourselves
-    HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUD),RT_RCDATA);
-    HGLOBAL hg = LoadResource(nullptr,res);
-    void* pData = LockResource(hg);
+    HRSRC res = FindResource(nullptr, MAKEINTRESOURCE(IDR_HUD), RT_RCDATA);
+    HGLOBAL hg = LoadResource(nullptr, res);
+    void *pData = LockResource(hg);
 
-    if(FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
-        pData,SizeofResource(nullptr,res),
-        D3DX_DEFAULT_NONPOW2,
-        D3DX_DEFAULT_NONPOW2,
-        1,
-        0,
-        D3DFMT_A8R8G8B8,
-        D3DPOOL_MANAGED,
-        D3DX_DEFAULT,
-        D3DX_DEFAULT,
-        0,
-        nullptr,
-        nullptr,
-        &g_pcTexture)))
-    {
+    if (FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
+                pData, SizeofResource(nullptr, res),
+                D3DX_DEFAULT_NONPOW2,
+                D3DX_DEFAULT_NONPOW2,
+                1,
+                0,
+                D3DFMT_A8R8G8B8,
+                D3DPOOL_MANAGED,
+                D3DX_DEFAULT,
+                D3DX_DEFAULT,
+                0,
+                nullptr,
+                nullptr,
+                &g_pcTexture))) {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD texture",
-            D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
 
-        g_pcTexture  = nullptr;
+        g_pcTexture = nullptr;
         g_szImageMask = nullptr;
 
         FreeResource(hg);
@@ -875,32 +808,30 @@ int CreateHUDTexture()
     FreeResource(hg);
 
     D3DSURFACE_DESC sDesc;
-    g_pcTexture->GetLevelDesc(0,&sDesc);
-
+    g_pcTexture->GetLevelDesc(0, &sDesc);
 
     // lock the memory resource ourselves
-    res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUDMASK),RT_RCDATA);
-    hg = LoadResource(nullptr,res);
+    res = FindResource(nullptr, MAKEINTRESOURCE(IDR_HUDMASK), RT_RCDATA);
+    hg = LoadResource(nullptr, res);
     pData = LockResource(hg);
 
-    IDirect3DTexture9* pcTex;
-    if(FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
-        pData,SizeofResource(nullptr,res),
-        sDesc.Width,
-        sDesc.Height,
-        1,
-        0,
-        D3DFMT_L8,
-        D3DPOOL_MANAGED, // unnecessary
-        D3DX_DEFAULT,
-        D3DX_DEFAULT,
-        0,
-        nullptr,
-        nullptr,
-        &pcTex)))
-    {
+    IDirect3DTexture9 *pcTex;
+    if (FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
+                pData, SizeofResource(nullptr, res),
+                sDesc.Width,
+                sDesc.Height,
+                1,
+                0,
+                D3DFMT_L8,
+                D3DPOOL_MANAGED, // unnecessary
+                D3DX_DEFAULT,
+                D3DX_DEFAULT,
+                0,
+                nullptr,
+                nullptr,
+                &pcTex))) {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD mask texture",
-            D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
         g_szImageMask = nullptr;
 
         FreeResource(hg);
@@ -911,15 +842,14 @@ int CreateHUDTexture()
 
     // lock the texture and copy it to get a pointer
     D3DLOCKED_RECT sRect;
-    pcTex->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY);
+    pcTex->LockRect(0, &sRect, nullptr, D3DLOCK_READONLY);
 
-    unsigned char* szOut = new unsigned char[sDesc.Width * sDesc.Height];
-    unsigned char* _szOut = szOut;
+    unsigned char *szOut = new unsigned char[sDesc.Width * sDesc.Height];
+    unsigned char *_szOut = szOut;
 
-    unsigned char* szCur = (unsigned char*) sRect.pBits;
-    for (unsigned int y = 0; y < sDesc.Height;++y)
-    {
-        memcpy(_szOut,szCur,sDesc.Width);
+    unsigned char *szCur = (unsigned char *)sRect.pBits;
+    for (unsigned int y = 0; y < sDesc.Height; ++y) {
+        memcpy(_szOut, szCur, sDesc.Width);
 
         szCur += sRect.Pitch;
         _szOut += sDesc.Width;
@@ -933,159 +863,141 @@ int CreateHUDTexture()
 
 //-------------------------------------------------------------------------------
 //-------------------------------------------------------------------------------
-int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
-{
+int CreateDevice(bool p_bMultiSample, bool p_bSuperSample, bool bHW /*= true*/) {
     D3DDEVTYPE eType = bHW ? D3DDEVTYPE_HAL : D3DDEVTYPE_REF;
 
     // get the client rectangle of the window.
     RECT sRect;
-    GetWindowRect(GetDlgItem(g_hDlg,IDC_RT),&sRect);
+    GetWindowRect(GetDlgItem(g_hDlg, IDC_RT), &sRect);
     sRect.right -= sRect.left;
     sRect.bottom -= sRect.top;
 
     D3DPRESENT_PARAMETERS sParams;
-    memset(&sParams,0,sizeof(D3DPRESENT_PARAMETERS));
+    memset(&sParams, 0, sizeof(D3DPRESENT_PARAMETERS));
 
     // get the current display mode
     D3DDISPLAYMODE sMode;
-    g_piD3D->GetAdapterDisplayMode(0,&sMode);
+    g_piD3D->GetAdapterDisplayMode(0, &sMode);
 
     // fill the presentation parameter structure
-    sParams.Windowed				= TRUE;
-    sParams.hDeviceWindow			= GetDlgItem( g_hDlg, IDC_RT );
-    sParams.EnableAutoDepthStencil	= TRUE;
-    sParams.PresentationInterval	= D3DPRESENT_INTERVAL_ONE;
-    sParams.BackBufferWidth			= (UINT)sRect.right;
-    sParams.BackBufferHeight		= (UINT)sRect.bottom;
-    sParams.SwapEffect				= D3DSWAPEFFECT_DISCARD;
-    sParams.BackBufferCount			= 1;
+    sParams.Windowed = TRUE;
+    sParams.hDeviceWindow = GetDlgItem(g_hDlg, IDC_RT);
+    sParams.EnableAutoDepthStencil = TRUE;
+    sParams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+    sParams.BackBufferWidth = (UINT)sRect.right;
+    sParams.BackBufferHeight = (UINT)sRect.bottom;
+    sParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
+    sParams.BackBufferCount = 1;
 
     // check whether we can use a D32 depth buffer format
-    if (SUCCEEDED ( g_piD3D->CheckDepthStencilMatch(0,eType,
-        D3DFMT_X8R8G8B8,D3DFMT_X8R8G8B8,D3DFMT_D32)))
-    {
+    if (SUCCEEDED(g_piD3D->CheckDepthStencilMatch(0, eType,
+                D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, D3DFMT_D32))) {
         sParams.AutoDepthStencilFormat = D3DFMT_D32;
-    }
-    else sParams.AutoDepthStencilFormat = D3DFMT_D24X8;
+    } else
+        sParams.AutoDepthStencilFormat = D3DFMT_D24X8;
 
     // find the highest multisample type available on this device
     D3DMULTISAMPLE_TYPE sMS = D3DMULTISAMPLE_2_SAMPLES;
     D3DMULTISAMPLE_TYPE sMSOut = D3DMULTISAMPLE_NONE;
     DWORD dwQuality = 0;
-    if (p_bMultiSample)
-    {
-        while ((D3DMULTISAMPLE_TYPE)(D3DMULTISAMPLE_16_SAMPLES + 1)  != 
-            (sMS = (D3DMULTISAMPLE_TYPE)(sMS + 1)))
-        {
-            if(SUCCEEDED( g_piD3D->CheckDeviceMultiSampleType(0,eType,
-                sMode.Format,TRUE,sMS,&dwQuality)))
-            {
+    if (p_bMultiSample) {
+        while ((D3DMULTISAMPLE_TYPE)(D3DMULTISAMPLE_16_SAMPLES + 1) !=
+                (sMS = (D3DMULTISAMPLE_TYPE)(sMS + 1))) {
+            if (SUCCEEDED(g_piD3D->CheckDeviceMultiSampleType(0, eType,
+                        sMode.Format, TRUE, sMS, &dwQuality))) {
                 sMSOut = sMS;
             }
         }
-        if (0 != dwQuality)dwQuality -= 1;
-
+        if (0 != dwQuality) dwQuality -= 1;
 
         sParams.MultiSampleQuality = dwQuality;
         sParams.MultiSampleType = sMSOut;
     }
 
     // get the device capabilities. If the hardware vertex shader is too old, we prefer software vertex processing
-    g_piD3D->GetDeviceCaps( 0, D3DDEVTYPE_HAL, &g_sCaps);
+    g_piD3D->GetDeviceCaps(0, D3DDEVTYPE_HAL, &g_sCaps);
     DWORD creationFlags = D3DCREATE_MULTITHREADED;
-    if( g_sCaps.VertexShaderVersion >= D3DVS_VERSION( 2, 0))
+    if (g_sCaps.VertexShaderVersion >= D3DVS_VERSION(2, 0))
         creationFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
     else
         creationFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
 
     // create the D3D9 device object. with software-vertexprocessing if VS2.0 isn`t supported in hardware
-    if(FAILED(g_piD3D->CreateDevice(0,eType, g_hDlg, creationFlags ,&sParams,&g_piDevice)))
-    {
+    if (FAILED(g_piD3D->CreateDevice(0, eType, g_hDlg, creationFlags, &sParams, &g_piDevice))) {
         // if hardware fails use software rendering instead
-        if (bHW)return CreateDevice(p_bMultiSample,p_bSuperSample,false);
+        if (bHW) return CreateDevice(p_bMultiSample, p_bSuperSample, false);
         return 0;
     }
 
     // create a vertex declaration to match the vertex
-    D3DVERTEXELEMENT9* vdecl = AssetHelper::Vertex::GetDeclarationElements();
-    if( FAILED( g_piDevice->CreateVertexDeclaration( vdecl, &gDefaultVertexDecl)))
-    {
-        MessageBox( g_hDlg, "Failed to create vertex declaration", "Init", MB_OK);
+    D3DVERTEXELEMENT9 *vdecl = AssetHelper::Vertex::GetDeclarationElements();
+    if (FAILED(g_piDevice->CreateVertexDeclaration(vdecl, &gDefaultVertexDecl))) {
+        MessageBox(g_hDlg, "Failed to create vertex declaration", "Init", MB_OK);
         return 0;
     }
-    g_piDevice->SetVertexDeclaration( gDefaultVertexDecl);
+    g_piDevice->SetVertexDeclaration(gDefaultVertexDecl);
 
     // get the capabilities of the device object
     g_piDevice->GetDeviceCaps(&g_sCaps);
-    if(g_sCaps.PixelShaderVersion < D3DPS_VERSION(3,0))
-    {
-        EnableWindow(GetDlgItem(g_hDlg,IDC_LOWQUALITY),FALSE);
+    if (g_sCaps.PixelShaderVersion < D3DPS_VERSION(3, 0)) {
+        EnableWindow(GetDlgItem(g_hDlg, IDC_LOWQUALITY), FALSE);
     }
 
     // compile the default material shader (gray gouraud/phong)
-    ID3DXBuffer* piBuffer = nullptr;
-    if(FAILED( D3DXCreateEffect(g_piDevice,
-        g_szDefaultShader.c_str(),
-        (UINT)g_szDefaultShader.length(),
-        nullptr,
-        nullptr,
-        AI_SHADER_COMPILE_FLAGS,
-        nullptr,
-        &g_piDefaultEffect,&piBuffer)))
-    {
-        if( piBuffer) 
-        {
-            MessageBox(g_hDlg,(LPCSTR)piBuffer->GetBufferPointer(),"HLSL",MB_OK);
+    ID3DXBuffer *piBuffer = nullptr;
+    if (FAILED(D3DXCreateEffect(g_piDevice,
+                g_szDefaultShader.c_str(),
+                (UINT)g_szDefaultShader.length(),
+                nullptr,
+                nullptr,
+                AI_SHADER_COMPILE_FLAGS,
+                nullptr,
+                &g_piDefaultEffect, &piBuffer))) {
+        if (piBuffer) {
+            MessageBox(g_hDlg, (LPCSTR)piBuffer->GetBufferPointer(), "HLSL", MB_OK);
             piBuffer->Release();
         }
         return 0;
     }
-    if( piBuffer) 
-    {
+    if (piBuffer) {
         piBuffer->Release();
         piBuffer = nullptr;
     }
 
     // use Fixed Function effect when working with shaderless cards
-    if( g_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0))
-        g_piDefaultEffect->SetTechnique( "DefaultFXSpecular_FF");
+    if (g_sCaps.PixelShaderVersion < D3DPS_VERSION(2, 0))
+        g_piDefaultEffect->SetTechnique("DefaultFXSpecular_FF");
 
     // create the shader used to draw the HUD
-    if(FAILED( D3DXCreateEffect(g_piDevice,
-        g_szPassThroughShader.c_str(),(UINT)g_szPassThroughShader.length(),
-        nullptr,nullptr,AI_SHADER_COMPILE_FLAGS,nullptr,&g_piPassThroughEffect,&piBuffer)))
-    {
-        if( piBuffer) 
-        {
-            MessageBox(g_hDlg,(LPCSTR)piBuffer->GetBufferPointer(),"HLSL",MB_OK);
+    if (FAILED(D3DXCreateEffect(g_piDevice,
+                g_szPassThroughShader.c_str(), (UINT)g_szPassThroughShader.length(),
+                nullptr, nullptr, AI_SHADER_COMPILE_FLAGS, nullptr, &g_piPassThroughEffect, &piBuffer))) {
+        if (piBuffer) {
+            MessageBox(g_hDlg, (LPCSTR)piBuffer->GetBufferPointer(), "HLSL", MB_OK);
             piBuffer->Release();
         }
         return 0;
     }
-    if( piBuffer) 
-    {
+    if (piBuffer) {
         piBuffer->Release();
         piBuffer = nullptr;
     }
 
     // use Fixed Function effect when working with shaderless cards
-    if( g_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0))
-        g_piPassThroughEffect->SetTechnique( "PassThrough_FF");
+    if (g_sCaps.PixelShaderVersion < D3DPS_VERSION(2, 0))
+        g_piPassThroughEffect->SetTechnique("PassThrough_FF");
 
     // create the shader used to visualize normal vectors
-    if(FAILED( D3DXCreateEffect(g_piDevice,
-        g_szNormalsShader.c_str(),(UINT)g_szNormalsShader.length(),
-        nullptr,nullptr,AI_SHADER_COMPILE_FLAGS,nullptr,&g_piNormalsEffect, &piBuffer)))
-    {
-        if( piBuffer) 
-        {
-            MessageBox(g_hDlg,(LPCSTR)piBuffer->GetBufferPointer(),"HLSL",MB_OK);
+    if (FAILED(D3DXCreateEffect(g_piDevice,
+                g_szNormalsShader.c_str(), (UINT)g_szNormalsShader.length(),
+                nullptr, nullptr, AI_SHADER_COMPILE_FLAGS, nullptr, &g_piNormalsEffect, &piBuffer))) {
+        if (piBuffer) {
+            MessageBox(g_hDlg, (LPCSTR)piBuffer->GetBufferPointer(), "HLSL", MB_OK);
             piBuffer->Release();
         }
         return 0;
     }
-    if( piBuffer) 
-    {
+    if (piBuffer) {
         piBuffer->Release();
         piBuffer = nullptr;
     }
@@ -1093,30 +1005,28 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/)
     //MessageBox( g_hDlg, "Failed to create vertex declaration", "Init", MB_OK);
 
     // use Fixed Function effect when working with shaderless cards
-    if( g_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0))
-        g_piNormalsEffect->SetTechnique( "RenderNormals_FF");
+    if (g_sCaps.PixelShaderVersion < D3DPS_VERSION(2, 0))
+        g_piNormalsEffect->SetTechnique("RenderNormals_FF");
 
-    g_piDevice->SetRenderState(D3DRS_DITHERENABLE,TRUE);
+    g_piDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
 
     // create the texture for the HUD
     CreateHUDTexture();
     CBackgroundPainter::Instance().RecreateNativeResource();
     CLogDisplay::Instance().RecreateNativeResource();
 
-    g_piPassThroughEffect->SetTexture("TEXTURE_2D",g_pcTexture);
+    g_piPassThroughEffect->SetTexture("TEXTURE_2D", g_pcTexture);
     return 1;
 }
 
 //-------------------------------------------------------------------------------
-int CreateDevice()
-{
+int CreateDevice() {
     return CreateDevice(g_sOptions.bMultiSample,
-        g_sOptions.bSuperSample);
+            g_sOptions.bSuperSample);
 }
 
 //-------------------------------------------------------------------------------
-int GetProjectionMatrix (aiMatrix4x4& p_mOut)
-{
+int GetProjectionMatrix(aiMatrix4x4 &p_mOut) {
     const float fFarPlane = 100.0f;
     const float fNearPlane = 0.1f;
     const float fFOV = (float)(45.0 * 0.0174532925);
@@ -1125,30 +1035,29 @@ int GetProjectionMatrix (aiMatrix4x4& p_mOut)
     const float Q = fFarPlane / (fFarPlane - fNearPlane);
 
     RECT sRect;
-    GetWindowRect(GetDlgItem(g_hDlg,IDC_RT),&sRect);
+    GetWindowRect(GetDlgItem(g_hDlg, IDC_RT), &sRect);
     sRect.right -= sRect.left;
     sRect.bottom -= sRect.top;
     const float fAspect = (float)sRect.right / (float)sRect.bottom;
 
     p_mOut = aiMatrix4x4(
-        s / fAspect, 0.0f, 0.0f, 0.0f,
-        0.0f, s, 0.0f, 0.0f,
-        0.0f, 0.0f, Q, 1.0f,
-        0.0f, 0.0f, -Q * fNearPlane, 0.0f);
+            s / fAspect, 0.0f, 0.0f, 0.0f,
+            0.0f, s, 0.0f, 0.0f,
+            0.0f, 0.0f, Q, 1.0f,
+            0.0f, 0.0f, -Q * fNearPlane, 0.0f);
     return 1;
 }
 
 //-------------------------------------------------------------------------------
-aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut)
-{
+aiVector3D GetCameraMatrix(aiMatrix4x4 &p_mOut) {
     D3DXMATRIX view;
-    D3DXMatrixIdentity( &view );
+    D3DXMatrixIdentity(&view);
 
-    D3DXVec3Normalize( (D3DXVECTOR3*)&g_sCamera.vLookAt, (D3DXVECTOR3*)&g_sCamera.vLookAt );
-    D3DXVec3Cross( (D3DXVECTOR3*)&g_sCamera.vRight, (D3DXVECTOR3*)&g_sCamera.vUp, (D3DXVECTOR3*)&g_sCamera.vLookAt );
-    D3DXVec3Normalize( (D3DXVECTOR3*)&g_sCamera.vRight, (D3DXVECTOR3*)&g_sCamera.vRight );
-    D3DXVec3Cross( (D3DXVECTOR3*)&g_sCamera.vUp, (D3DXVECTOR3*)&g_sCamera.vLookAt, (D3DXVECTOR3*)&g_sCamera.vRight );
-    D3DXVec3Normalize( (D3DXVECTOR3*)&g_sCamera.vUp, (D3DXVECTOR3*)&g_sCamera.vUp );
+    D3DXVec3Normalize((D3DXVECTOR3 *)&g_sCamera.vLookAt, (D3DXVECTOR3 *)&g_sCamera.vLookAt);
+    D3DXVec3Cross((D3DXVECTOR3 *)&g_sCamera.vRight, (D3DXVECTOR3 *)&g_sCamera.vUp, (D3DXVECTOR3 *)&g_sCamera.vLookAt);
+    D3DXVec3Normalize((D3DXVECTOR3 *)&g_sCamera.vRight, (D3DXVECTOR3 *)&g_sCamera.vRight);
+    D3DXVec3Cross((D3DXVECTOR3 *)&g_sCamera.vUp, (D3DXVECTOR3 *)&g_sCamera.vLookAt, (D3DXVECTOR3 *)&g_sCamera.vRight);
+    D3DXVec3Normalize((D3DXVECTOR3 *)&g_sCamera.vUp, (D3DXVECTOR3 *)&g_sCamera.vUp);
 
     view._11 = g_sCamera.vRight.x;
     view._12 = g_sCamera.vUp.x;
@@ -1165,14 +1074,14 @@ aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut)
     view._33 = g_sCamera.vLookAt.z;
     view._34 = 0.0f;
 
-    view._41 = -D3DXVec3Dot( (D3DXVECTOR3*)&g_sCamera.vPos, (D3DXVECTOR3*)&g_sCamera.vRight );
-    view._42 = -D3DXVec3Dot( (D3DXVECTOR3*)&g_sCamera.vPos, (D3DXVECTOR3*)&g_sCamera.vUp );
-    view._43 = -D3DXVec3Dot( (D3DXVECTOR3*)&g_sCamera.vPos, (D3DXVECTOR3*)&g_sCamera.vLookAt );
-    view._44 =  1.0f;
+    view._41 = -D3DXVec3Dot((D3DXVECTOR3 *)&g_sCamera.vPos, (D3DXVECTOR3 *)&g_sCamera.vRight);
+    view._42 = -D3DXVec3Dot((D3DXVECTOR3 *)&g_sCamera.vPos, (D3DXVECTOR3 *)&g_sCamera.vUp);
+    view._43 = -D3DXVec3Dot((D3DXVECTOR3 *)&g_sCamera.vPos, (D3DXVECTOR3 *)&g_sCamera.vLookAt);
+    view._44 = 1.0f;
 
-    memcpy(&p_mOut,&view,sizeof(aiMatrix4x4));
+    memcpy(&p_mOut, &view, sizeof(aiMatrix4x4));
 
     return g_sCamera.vPos;
 }
 
-}
+} // namespace AssimpView
diff --git a/tools/assimp_view/assimp_view.h b/tools/assimp_view/assimp_view.h
index 2adffacff..8e04f7117 100644
--- a/tools/assimp_view/assimp_view.h
+++ b/tools/assimp_view/assimp_view.h
@@ -51,27 +51,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "resource.h"
 
 #include <assert.h>
-#include <stdlib.h>
 #include <malloc.h>
 #include <memory.h>
-#include <tchar.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <tchar.h>
 #include <time.h>
 
 // Include ASSIMP headers (XXX: do we really need all of them?)
-#include <assimp/cimport.h>
-#include <assimp/Importer.hpp>
 #include <assimp/ai_assert.h>
 #include <assimp/cfileio.h>
+#include <assimp/cimport.h>
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/IOStream.hpp>
-#include <assimp/LogStream.hpp>
 #include <assimp/DefaultLogger.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
+#include <assimp/LogStream.hpp>
 
-#include "Material/MaterialSystem.h"   // aiMaterial class
-#include <assimp/StringComparison.h>   // ASSIMP_stricmp and ASSIMP_strincmp
+#include "Material/MaterialSystem.h" // aiMaterial class
+#include <assimp/StringComparison.h> // ASSIMP_stricmp and ASSIMP_strincmp
 
 #include <time.h>
 
@@ -79,33 +79,31 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define MOVE_SPEED 3.f
 
 #include "AssetHelper.h"
-#include "Camera.h"
-#include "RenderOptions.h"
-#include "Shaders.h"
 #include "Background.h"
+#include "Camera.h"
+#include "Display.h"
 #include "LogDisplay.h"
 #include "LogWindow.h"
-#include "Display.h"
-#include "MeshRenderer.h"
 #include "MaterialManager.h"
-
+#include "MeshRenderer.h"
+#include "RenderOptions.h"
+#include "Shaders.h"
 
 // outside of namespace, to help Intellisense and solve boost::metatype_stuff_miracle
 #include "AnimEvaluator.h"
 #include "SceneAnimator.h"
 
-namespace AssimpView
-{
+namespace AssimpView {
 
 //-------------------------------------------------------------------------------
 // Function prototypes
 //-------------------------------------------------------------------------------
 int InitD3D(void);
 int ShutdownD3D(void);
-int CreateDevice (bool p_bMultiSample,bool p_bSuperSample, bool bHW = true);
-int CreateDevice (void);
+int CreateDevice(bool p_bMultiSample, bool p_bSuperSample, bool bHW = true);
+int CreateDevice(void);
 int ShutdownDevice(void);
-int GetProjectionMatrix (aiMatrix4x4& p_mOut);
+int GetProjectionMatrix(aiMatrix4x4 &p_mOut);
 int LoadAsset(void);
 int CreateAssetData(void);
 int DeleteAssetData(bool bNoMaterials = false);
@@ -113,26 +111,25 @@ int ScaleAsset(void);
 int DeleteAsset(void);
 int SetupFPSView();
 
-aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut);
-int CreateMaterial(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource);
-
-void HandleMouseInputFPS( void );
-void HandleMouseInputLightRotate( void );
-void HandleMouseInputLocal( void );
-void HandleKeyboardInputFPS( void );
-void HandleMouseInputLightIntensityAndColor( void );
-void HandleMouseInputSkyBox( void );
-void HandleKeyboardInputTextureView( void );
-void HandleMouseInputTextureView( void );
+aiVector3D GetCameraMatrix(aiMatrix4x4 &p_mOut);
+int CreateMaterial(AssetHelper::MeshHelper *pcMesh, const aiMesh *pcSource);
 
+void HandleMouseInputFPS(void);
+void HandleMouseInputLightRotate(void);
+void HandleMouseInputLocal(void);
+void HandleKeyboardInputFPS(void);
+void HandleMouseInputLightIntensityAndColor(void);
+void HandleMouseInputSkyBox(void);
+void HandleKeyboardInputTextureView(void);
+void HandleMouseInputTextureView(void);
 
 //-------------------------------------------------------------------------------
 //
 // Dialog procedure for the progress bar window
 //
 //-------------------------------------------------------------------------------
-INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg,UINT uMsg,
-    WPARAM wParam,LPARAM lParam);
+INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg, UINT uMsg,
+        WPARAM wParam, LPARAM lParam);
 
 //-------------------------------------------------------------------------------
 // Main message procedure of the application
@@ -142,25 +139,24 @@ INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg,UINT uMsg,
 // NOTE: Due to the impossibility to process WM_CHAR messages in dialogs
 // properly the code for all hotkeys has been moved to the WndMain
 //-------------------------------------------------------------------------------
-INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg,
-    WPARAM wParam,LPARAM lParam);
+INT_PTR CALLBACK MessageProc(HWND hwndDlg, UINT uMsg,
+        WPARAM wParam, LPARAM lParam);
 
 //-------------------------------------------------------------------------------
 //
 // Dialog procedure for the about dialog
 //
 //-------------------------------------------------------------------------------
-INT_PTR CALLBACK AboutMessageProc(HWND hwndDlg,UINT uMsg,
-    WPARAM wParam,LPARAM lParam);
+INT_PTR CALLBACK AboutMessageProc(HWND hwndDlg, UINT uMsg,
+        WPARAM wParam, LPARAM lParam);
 
 //-------------------------------------------------------------------------------
 //
 // Dialog procedure for the help dialog
 //
 //-------------------------------------------------------------------------------
-INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
-    WPARAM wParam,LPARAM lParam);
-
+INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg, UINT uMsg,
+        WPARAM wParam, LPARAM lParam);
 
 //-------------------------------------------------------------------------------
 // Handle command line parameters
@@ -168,24 +164,20 @@ INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
 // The function loads an asset specified on the command line as first argument
 // Other command line parameters are not handled
 //-------------------------------------------------------------------------------
-void HandleCommandLine(char* p_szCommand);
-
+void HandleCommandLine(char *p_szCommand);
 
 //-------------------------------------------------------------------------------
 template <class type, class intype>
-type clamp(intype in)
-{
+type clamp(intype in) {
     // for unsigned types only ...
-    intype mask = (0x1u << (sizeof(type)*8))-1;
-    return (type)std::max((intype)0,std::min(in,mask));
+    intype mask = (0x1u << (sizeof(type) * 8)) - 1;
+    return (type)std::max((intype)0, std::min(in, mask));
 }
 
-
 //-------------------------------------------------------------------------------
 // Position of the cursor relative to the 3ds max' like control circle
 //-------------------------------------------------------------------------------
-enum EClickPos
-{
+enum EClickPos {
     // The click was inside the inner circle (x,y axis)
     EClickPos_Circle,
     // The click was inside one of the vertical snap-ins
@@ -197,84 +189,82 @@ enum EClickPos
 };
 
 #if (!defined AI_VIEW_CAPTION_BASE)
-#   define AI_VIEW_CAPTION_BASE "Open Asset Import Library : Viewer "
+#define AI_VIEW_CAPTION_BASE "Open Asset Import Library : Viewer "
 #endif // !! AI_VIEW_CAPTION_BASE
 
 //-------------------------------------------------------------------------------
 // Evil globals
 //-------------------------------------------------------------------------------
-    extern HINSTANCE g_hInstance                /*= NULL*/;
-    extern HWND g_hDlg                          /*= NULL*/;
-    extern IDirect3D9* g_piD3D                  /*= NULL*/;
-    extern IDirect3DDevice9* g_piDevice         /*= NULL*/;
-    extern IDirect3DVertexDeclaration9* gDefaultVertexDecl /*= NULL*/;
-    extern double g_fFPS                        /*= 0.0f*/;
-    extern char g_szFileName[MAX_PATH];
-    extern ID3DXEffect* g_piDefaultEffect       /*= NULL*/;
-    extern ID3DXEffect* g_piNormalsEffect       /*= NULL*/;
-    extern ID3DXEffect* g_piPassThroughEffect   /*= NULL*/;
-    extern ID3DXEffect* g_piPatternEffect       /*= NULL*/;
-    extern bool g_bMousePressed                 /*= false*/;
-    extern bool g_bMousePressedR                /*= false*/;
-    extern bool g_bMousePressedM                /*= false*/;
-    extern bool g_bMousePressedBoth             /*= false*/;
-    extern float g_fElpasedTime                 /*= 0.0f*/;
-    extern D3DCAPS9 g_sCaps;
-    extern bool g_bLoadingFinished              /*= false*/;
-    extern HANDLE g_hThreadHandle               /*= NULL*/;
-    extern float g_fWheelPos                    /*= -10.0f*/;
-    extern bool g_bLoadingCanceled              /*= false*/;
-    extern IDirect3DTexture9* g_pcTexture       /*= NULL*/;
+extern HINSTANCE g_hInstance /*= NULL*/;
+extern HWND g_hDlg /*= NULL*/;
+extern IDirect3D9 *g_piD3D /*= NULL*/;
+extern IDirect3DDevice9 *g_piDevice /*= NULL*/;
+extern IDirect3DVertexDeclaration9 *gDefaultVertexDecl /*= NULL*/;
+extern double g_fFPS /*= 0.0f*/;
+extern char g_szFileName[MAX_PATH];
+extern ID3DXEffect *g_piDefaultEffect /*= NULL*/;
+extern ID3DXEffect *g_piNormalsEffect /*= NULL*/;
+extern ID3DXEffect *g_piPassThroughEffect /*= NULL*/;
+extern ID3DXEffect *g_piPatternEffect /*= NULL*/;
+extern bool g_bMousePressed /*= false*/;
+extern bool g_bMousePressedR /*= false*/;
+extern bool g_bMousePressedM /*= false*/;
+extern bool g_bMousePressedBoth /*= false*/;
+extern float g_fElpasedTime /*= 0.0f*/;
+extern D3DCAPS9 g_sCaps;
+extern bool g_bLoadingFinished /*= false*/;
+extern HANDLE g_hThreadHandle /*= NULL*/;
+extern float g_fWheelPos /*= -10.0f*/;
+extern bool g_bLoadingCanceled /*= false*/;
+extern IDirect3DTexture9 *g_pcTexture /*= NULL*/;
 
-    extern aiMatrix4x4 g_mWorld;
-    extern aiMatrix4x4 g_mWorldRotate;
-    extern aiVector3D g_vRotateSpeed            /*= aiVector3D(0.5f,0.5f,0.5f)*/;
+extern aiMatrix4x4 g_mWorld;
+extern aiMatrix4x4 g_mWorldRotate;
+extern aiVector3D g_vRotateSpeed /*= aiVector3D(0.5f,0.5f,0.5f)*/;
 
-    extern aiVector3D g_avLightDirs[1] /* =
+extern aiVector3D g_avLightDirs[1] /* =
         {   aiVector3D(-0.5f,0.6f,0.2f) ,
-            aiVector3D(-0.5f,0.5f,0.5f)} */;
+            aiVector3D(-0.5f,0.5f,0.5f)} */
+        ;
 
+extern POINT g_mousePos /*= {0,0};*/;
+extern POINT g_LastmousePos /*= {0,0}*/;
+extern bool g_bFPSView /*= false*/;
+extern bool g_bInvert /*= false*/;
+extern EClickPos g_eClick;
+extern unsigned int g_iCurrentColor /*= 0*/;
 
-    extern POINT g_mousePos                     /*= {0,0};*/;
-    extern POINT g_LastmousePos                 /*= {0,0}*/;
-    extern bool g_bFPSView                      /*= false*/;
-    extern bool g_bInvert                       /*= false*/;
-    extern EClickPos g_eClick;
-    extern unsigned int g_iCurrentColor         /*= 0*/;
+// NOTE: The light intensity is separated from the color, it can
+// directly be manipulated using the middle mouse button.
+// When the user chooses a color from the palette the intensity
+// is reset to 1.0
+// index[2] is the ambient color
+extern float g_fLightIntensity /*=0.0f*/;
+extern D3DCOLOR g_avLightColors[3];
 
-    // NOTE: The light intensity is separated from the color, it can
-    // directly be manipulated using the middle mouse button.
-    // When the user chooses a color from the palette the intensity
-    // is reset to 1.0
-    // index[2] is the ambient color
-    extern float g_fLightIntensity              /*=0.0f*/;
-    extern D3DCOLOR g_avLightColors[3];
+extern RenderOptions g_sOptions;
+extern Camera g_sCamera;
+extern AssetHelper *g_pcAsset /*= NULL*/;
 
-    extern RenderOptions g_sOptions;
-    extern Camera g_sCamera;
-    extern AssetHelper *g_pcAsset               /*= NULL*/;
+//
+// Contains the mask image for the HUD
+// (used to determine the position of a click)
+//
+// The size of the image is identical to the size of the main
+// HUD texture
+//
+extern unsigned char *g_szImageMask /*= NULL*/;
 
+extern float g_fACMR /*= 3.0f*/;
+extern IDirect3DQuery9 *g_piQuery;
 
-    //
-    // Contains the mask image for the HUD
-    // (used to determine the position of a click)
-    //
-    // The size of the image is identical to the size of the main
-    // HUD texture
-    //
-    extern unsigned char* g_szImageMask         /*= NULL*/;
+extern bool g_bPlay /*= false*/;
 
+extern double g_dCurrent;
+extern float g_smoothAngle /*= 80.f*/;
 
-    extern float g_fACMR /*= 3.0f*/;
-    extern IDirect3DQuery9* g_piQuery;
+extern unsigned int ppsteps, ppstepsdefault;
+extern bool nopointslines;
+} // namespace AssimpView
 
-    extern bool g_bPlay                     /*= false*/;
-
-    extern double g_dCurrent;
-    extern float g_smoothAngle /*= 80.f*/;
-
-    extern unsigned int ppsteps,ppstepsdefault;
-    extern bool nopointslines;
-    }
-
-#endif // !! AV_MAIN_H_INCLUDED
\ No newline at end of file
+#endif // !! AV_MAIN_H_INCLUDED