diff --git a/code/Assimp.cpp b/code/Assimp.cpp
index b682d257b..87f436602 100644
--- a/code/Assimp.cpp
+++ b/code/Assimp.cpp
@@ -50,13 +50,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/Importer.hpp>
 #include <assimp/importerdesc.h>
 #include <assimp/scene.h>
-
 #include <assimp/GenericProperty.h>
+#include <assimp/Exceptional.h>
+#include <assimp/BaseImporter.h>
+
 #include "CInterfaceIOWrapper.h"
 #include "Importer.h"
-#include <assimp/Exceptional.h>
 #include "ScenePrivate.h"
-#include <assimp/BaseImporter.h>
+
 #include <list>
 
 // ------------------------------------------------------------------------------------------------
@@ -107,7 +108,6 @@ namespace Assimp {
 static std::mutex gLogStreamMutex;
 #endif
 
-
 // ------------------------------------------------------------------------------------------------
 // Custom LogStream implementation for the C-API
 class LogToCallbackRedirector : public LogStream {
diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt
index d163f73dc..780b28a71 100644
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -505,7 +505,6 @@ ADD_ASSIMP_IMPORTER( XGL
   XGLLoader.h
 )
 
-
 ADD_ASSIMP_IMPORTER( FBX
   FBXImporter.cpp
   FBXCompileConfig.h
@@ -722,9 +721,15 @@ ADD_ASSIMP_IMPORTER( MMD
 )
 
 SET( Step_SRCS
-  STEPFile.h
-  StepExporter.h
-  StepExporter.cpp
+    STEPFile.h
+    Importer/StepFile/StepFileImporter.h
+    Importer/StepFile/StepFileImporter.cpp
+    Importer/StepFile/StepFileGen1.cpp
+    Importer/StepFile/StepFileGen2.cpp
+    Importer/StepFile/StepFileGen3.cpp
+    Importer/StepFile/StepReaderGen.h
+    StepExporter.h
+    StepExporter.cpp
 )
 SOURCE_GROUP( Step FILES ${Step_SRCS})
 
diff --git a/code/Importer/IFC/IFCLoader.cpp b/code/Importer/IFC/IFCLoader.cpp
index a40eedc1d..f1c99a0f4 100644
--- a/code/Importer/IFC/IFCLoader.cpp
+++ b/code/Importer/IFC/IFCLoader.cpp
@@ -134,7 +134,7 @@ IFCImporter::~IFCImporter()
 bool IFCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
 {
     const std::string& extension = GetExtension(pFile);
-    if (extension == "ifc" || extension == "ifczip" || extension == "stp" ) {
+    if (extension == "ifc" || extension == "ifczip" ) {
         return true;
     } else if ((!extension.length() || checkSig) && pIOHandler)   {
         // note: this is the common identification for STEP-encoded files, so
diff --git a/code/Importer/IFC/STEPFileReader.cpp b/code/Importer/IFC/STEPFileReader.cpp
index b1390b9de..c7cad05ae 100644
--- a/code/Importer/IFC/STEPFileReader.cpp
+++ b/code/Importer/IFC/STEPFileReader.cpp
@@ -85,16 +85,16 @@ STEP::TypeError::TypeError (const std::string& s,uint64_t entity /* = ENTITY_NOT
 
 }
 
-
+static const char *ISO_Token         = "ISO-10303-21;";
+static const char *FILE_SCHEMA_Token = "FILE_SCHEMA";
 // ------------------------------------------------------------------------------------------------
-STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream)
-{
+STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream) {
     std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
     std::unique_ptr<STEP::DB> db = std::unique_ptr<STEP::DB>(new STEP::DB(reader));
 
-    LineSplitter& splitter = db->GetSplitter();
-    if (!splitter || *splitter != "ISO-10303-21;") {
-        throw STEP::SyntaxError("expected magic token: ISO-10303-21",1);
+    LineSplitter &splitter = db->GetSplitter();
+    if (!splitter || *splitter != ISO_Token ) {
+        throw STEP::SyntaxError("expected magic token: " + std::string( ISO_Token ), 1);
     }
 
     HeaderInfo& head = db->GetHeader();
@@ -109,7 +109,7 @@ STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream)
         // want one-based line numbers for human readers, so +1
         const uint64_t line = splitter.get_index()+1;
 
-        if (s.substr(0,11) == "FILE_SCHEMA") {
+        if (s.substr(0,11) == FILE_SCHEMA_Token) {
             const char* sz = s.c_str()+11;
             SkipSpaces(sz,&sz);
             std::shared_ptr< const EXPRESS::DataType > schema = EXPRESS::DataType::Parse(sz);
@@ -549,4 +549,3 @@ void STEP::LazyObject::LazyInit() const
     // store the original id in the object instance
     obj->SetID(id);
 }
-
diff --git a/code/Importer/IFC/STEPFileReader.h b/code/Importer/IFC/STEPFileReader.h
index b9dcf8948..667d28bfd 100644
--- a/code/Importer/IFC/STEPFileReader.h
+++ b/code/Importer/IFC/STEPFileReader.h
@@ -48,18 +48,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace STEP {
 
-    // ### Parsing a STEP file is a twofold procedure ###
-    // --------------------------------------------------------------------------
-    // 1) read file header and return to caller, who checks if the
-    //    file is of a supported schema ..
-    DB* ReadFileHeader(std::shared_ptr<IOStream> stream);
-    // --------------------------------------------------------------------------
-    // 2) read the actual file contents using a user-supplied set of
-    //    conversion functions to interpret the data.
-    void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const* types_to_track, size_t len, const char* const* inverse_indices_to_track, size_t len2);
-    template <size_t N, size_t N2> inline void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const (&arr)[N], const char* const (&arr2)[N2]) {
-        return ReadFile(db,scheme,arr,N,arr2,N2);
-    }
+// --------------------------------------------------------------------------
+/// @brief  Parsing a STEP file is a twofold procedure.
+/// 1) read file header and return to caller, who checks if the
+///    file is of a supported schema ..
+DB* ReadFileHeader(std::shared_ptr<IOStream> stream);
+
+/// 2) read the actual file contents using a user-supplied set of
+///    conversion functions to interpret the data.
+void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const* types_to_track, size_t len, const char* const* inverse_indices_to_track, size_t len2);
+
+/// @brief  Helper to read a file.
+template <size_t N, size_t N2>
+inline
+void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const (&arr)[N], const char* const (&arr2)[N2]) {
+    return ReadFile(db,scheme,arr,N,arr2,N2);
+}
+
 } // ! STEP
 } // ! Assimp
 
diff --git a/code/Importer/StepFile/StepFileGen1.cpp b/code/Importer/StepFile/StepFileGen1.cpp
new file mode 100644
index 000000000..32df66c17
--- /dev/null
+++ b/code/Importer/StepFile/StepFileGen1.cpp
@@ -0,0 +1,2195 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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_STEPFILE_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& db, const LIST& params, abstract_variable* in)
+{
+	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& db, const LIST& params, angle_direction_reference* in)
+{
+	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/Importer/StepFile/StepFileGen2.cpp b/code/Importer/StepFile/StepFileGen2.cpp
new file mode 100644
index 000000000..eca09e4e1
--- /dev/null
+++ b/code/Importer/StepFile/StepFileGen2.cpp
@@ -0,0 +1,3067 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2010, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#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/Importer/StepFile/StepFileGen3.cpp b/code/Importer/StepFile/StepFileGen3.cpp
new file mode 100644
index 000000000..d8d81141f
--- /dev/null
+++ b/code/Importer/StepFile/StepFileGen3.cpp
@@ -0,0 +1,5746 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2010, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#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& db, const LIST& params, logical_representation_item* in)
+{
+    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/Importer/StepFile/StepFileImporter.cpp b/code/Importer/StepFile/StepFileImporter.cpp
new file mode 100644
index 000000000..9a34a84f5
--- /dev/null
+++ b/code/Importer/StepFile/StepFileImporter.cpp
@@ -0,0 +1,114 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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_STEPFILE_IMPORTER
+
+#include "StepFileImporter.h"
+#include "../../Importer/IFC/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* pScene, 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_STEPFILE_IMPORTER
+
diff --git a/code/Importer/StepFile/StepFileImporter.h b/code/Importer/StepFile/StepFileImporter.h
new file mode 100644
index 000000000..7314a54f3
--- /dev/null
+++ b/code/Importer/StepFile/StepFileImporter.h
@@ -0,0 +1,69 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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.
+---------------------------------------------------------------------------
+*/
+
+#pragma once
+
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+
+#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_STEPFILE_IMPORTER
diff --git a/code/Importer/StepFile/StepReaderGen.h b/code/Importer/StepFile/StepReaderGen.h
new file mode 100644
index 000000000..21f2518df
--- /dev/null
+++ b/code/Importer/StepFile/StepReaderGen.h
@@ -0,0 +1,7288 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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/STEPFile.h"
+
+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/ImporterRegistry.cpp b/code/ImporterRegistry.cpp
index 4a8428d25..d3ae53c7d 100644
--- a/code/ImporterRegistry.cpp
+++ b/code/ImporterRegistry.cpp
@@ -197,6 +197,9 @@ corresponding preprocessor flag to selectively disable formats.
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
 #   include "MMDImporter.h"
 #endif
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+#   include "Importer/StepFile/StepFileImporter.h"
+#endif
 
 namespace Assimp {
 
@@ -352,6 +355,9 @@ void GetImporterInstanceList(std::vector< BaseImporter* >& out)
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
     out.push_back( new MMDImporter() );
 #endif
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+    out.push_back(new StepFile::StepFileImporter());
+#endif
 }
 
 /** will delete all registered importers. */
diff --git a/code/ObjFileImporter.cpp b/code/ObjFileImporter.cpp
index 0cb1b6544..6fd48cfa1 100644
--- a/code/ObjFileImporter.cpp
+++ b/code/ObjFileImporter.cpp
@@ -105,7 +105,7 @@ bool ObjFileImporter::CanRead( const std::string& pFile, IOSystem*  pIOHandler ,
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* ObjFileImporter::GetInfo () const {
+const aiImporterDesc* ObjFileImporter::GetInfo() const {
     return &desc;
 }
 
diff --git a/code/STEPFile.h b/code/STEPFile.h
index 492150658..6245290b6 100644
--- a/code/STEPFile.h
+++ b/code/STEPFile.h
@@ -139,10 +139,10 @@ namespace STEP {
      *  error (i.e. an entity expects a string but receives a bool) occurs.
      *  It is typically coupled with both an entity id and a line number.*/
     // -------------------------------------------------------------------------------
-    struct TypeError : DeadlyImportError
-    {
+    struct TypeError : DeadlyImportError {
         enum {
-            ENTITY_NOT_SPECIFIED = 0xffffffffffffffffLL
+            ENTITY_NOT_SPECIFIED = 0xffffffffffffffffLL,
+            ENTITY_NOT_SPECIFIED_32 = -1u
         };
 
         TypeError (const std::string& s,uint64_t entity = ENTITY_NOT_SPECIFIED, uint64_t line = SyntaxError::LINE_NOT_SPECIFIED);
@@ -164,7 +164,6 @@ namespace STEP {
         class DataType
         {
         public:
-
             typedef std::shared_ptr<const DataType> Out;
 
         public:
@@ -357,14 +356,25 @@ namespace STEP {
             MemberList members;
         };
 
+        class BINARY : public PrimitiveDataType<uint32_t> {
+        public:
+            BINARY(uint32_t val)
+            : PrimitiveDataType<uint32_t>(val) {
+                // empty
+            }
+
+            BINARY()
+            : PrimitiveDataType<uint32_t>(TypeError::ENTITY_NOT_SPECIFIED_32) {
+                // empty
+            }
+        };
 
         // -------------------------------------------------------------------------------
         /* Not exactly a full EXPRESS schema but rather a list of conversion functions
          * to extract valid C++ objects out of a STEP file. Those conversion functions
          * may, however, perform further schema validations. */
         // -------------------------------------------------------------------------------
-        class ConversionSchema
-        {
+        class ConversionSchema {
         public:
             struct SchemaEntry {
                 SchemaEntry( const char *name, ConvertObjectProc func )
@@ -379,30 +389,27 @@ namespace STEP {
 
             typedef std::map<std::string,ConvertObjectProc> ConverterMap;
 
-        public:
-
             template <size_t N>
             explicit ConversionSchema( const SchemaEntry (& schemas)[N]) {
                 *this = schemas;
             }
 
-            ConversionSchema() {}
+            ConversionSchema() {
 
-        public:
+            }
 
             ConvertObjectProc GetConverterProc(const std::string& name) const {
                 ConverterMap::const_iterator it = converters.find(name);
-                return it == converters.end() ? NULL : (*it).second;
+                return it == converters.end() ? nullptr : (*it).second;
             }
 
-
             bool IsKnownToken(const std::string& name) const {
                 return converters.find(name) != converters.end();
             }
 
             const char* GetStaticStringForToken(const std::string& token) const {
                 ConverterMap::const_iterator it = converters.find(token);
-                return it == converters.end() ? NULL : (*it).first.c_str();
+                return it == converters.end() ? nullptr : (*it).first.c_str();
             }
 
 
@@ -416,7 +423,6 @@ namespace STEP {
             }
 
         private:
-
             ConverterMap converters;
         };
     }
@@ -451,8 +457,6 @@ namespace STEP {
             // empty
         }
 
-    public:
-
         // utilities to simplify casting to concrete types
         template <typename T>
         const T& To() const {
@@ -474,7 +478,6 @@ namespace STEP {
             return dynamic_cast<T*>(this);
         }
 
-    public:
         uint64_t GetID() const {
             return id;
         }
@@ -501,9 +504,11 @@ namespace STEP {
     /** CRTP shared base class for use by concrete entity implementation classes */
     // ------------------------------------------------------------------------------
     template <typename TDerived, size_t arg_count>
-    struct ObjectHelper : virtual Object
-    {
-        ObjectHelper() : aux_is_derived(0) {}
+    struct ObjectHelper : virtual Object {
+        ObjectHelper()
+        : aux_is_derived(0) {
+            // empty
+        }
 
         static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) {
             // make sure we don't leak if Fill() throws an exception
@@ -532,10 +537,16 @@ namespace STEP {
     /** Class template used to represent OPTIONAL data members in the converted schema */
     // ------------------------------------------------------------------------------
     template <typename T>
-    struct Maybe
-    {
-        Maybe() : have() {}
-        explicit Maybe(const T& ptr) : ptr(ptr), have(true) {
+    struct Maybe {
+        Maybe()
+        : have() {
+            // empty
+        }
+
+        explicit Maybe(const T& ptr)
+        : ptr(ptr)
+        , have(true) {
+            // empty
         }
 
 
@@ -572,7 +583,6 @@ namespace STEP {
         }
 
     private:
-
         template <typename T2> friend struct InternGenericConvert;
 
         operator T&() {
@@ -587,16 +597,13 @@ namespace STEP {
     /** A LazyObject is created when needed. Before this happens, we just keep
        the text line that contains the object definition. */
     // -------------------------------------------------------------------------------
-    class LazyObject
-    {
+    class LazyObject {
         friend class DB;
-    public:
 
+    public:
         LazyObject(DB& db, uint64_t id, uint64_t line, const char* type,const char* args);
         ~LazyObject();
 
-    public:
-
         Object& operator * () {
             if (!obj) {
                 LazyInit();
@@ -654,38 +661,37 @@ namespace STEP {
         }
 
     private:
-
         void LazyInit() const;
 
     private:
-
         mutable uint64_t id;
         const char* const type;
         DB& db;
-
         mutable const char* args;
         mutable Object* obj;
     };
 
     template <typename T>
-    inline bool operator==( std::shared_ptr<LazyObject> lo, T whatever ) {
+    inline
+    bool operator==( std::shared_ptr<LazyObject> lo, T whatever ) {
         return *lo == whatever; // XXX use std::forward if we have 0x
     }
 
     template <typename T>
-    inline bool operator==( const std::pair<uint64_t, std::shared_ptr<LazyObject> >& lo, T whatever ) {
+    inline
+    bool operator==( const std::pair<uint64_t, std::shared_ptr<LazyObject> >& lo, T whatever ) {
         return *(lo.second) == whatever; // XXX use std::forward if we have 0x
     }
 
-
     // ------------------------------------------------------------------------------
     /** Class template used to represent lazily evaluated object references in the converted schema */
     // ------------------------------------------------------------------------------
     template <typename T>
-    struct Lazy
-    {
+    struct Lazy {
         typedef Lazy Out;
-        Lazy(const LazyObject* obj = NULL) : obj(obj) {
+        Lazy(const LazyObject* obj = nullptr)
+        : obj(obj) {
+            // empty
         }
 
         operator const T*() const {
@@ -711,19 +717,15 @@ namespace STEP {
     /** Class template used to represent LIST and SET data members in the converted schema */
     // ------------------------------------------------------------------------------
     template <typename T, uint64_t min_cnt, uint64_t max_cnt=0uL>
-    struct ListOf : public std::vector<typename T::Out>
-    {
+    struct ListOf : public std::vector<typename T::Out> {
         typedef typename T::Out OutScalar;
         typedef ListOf Out;
 
-
         ListOf() {
             static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt");
         }
-
     };
 
-
     // ------------------------------------------------------------------------------
     template <typename TOut>
     struct PickBaseType {
@@ -735,7 +737,8 @@ namespace STEP {
         typedef EXPRESS::ENTITY Type;
     };
 
-    template <> struct PickBaseType< std::shared_ptr< const EXPRESS::DataType > >;
+    template<>
+    struct PickBaseType< std::shared_ptr< const EXPRESS::DataType > >;
 
     // ------------------------------------------------------------------------------
     template <typename T>
@@ -743,8 +746,7 @@ namespace STEP {
         void operator()(T& out, const std::shared_ptr< const EXPRESS::DataType >& in, const STEP::DB& /*db*/) {
             try{
                 out = dynamic_cast< const typename PickBaseType<T>::Type& > ( *in );
-            }
-            catch(std::bad_cast&) {
+            } catch(std::bad_cast&) {
                 throw TypeError("type error reading literal field");
             }
         }
@@ -817,7 +819,6 @@ namespace STEP {
         return InternGenericConvertList<T1,N1,N2>()(a,b,db);
     }
 
-
     // ------------------------------------------------------------------------------
     /** Lightweight manager class that holds the map of all objects in a
      *  STEP file. DB's are exclusively maintained by the functions in
@@ -834,7 +835,6 @@ namespace STEP {
         friend class LazyObject;
 
     public:
-
         // objects indexed by ID - this can grow pretty large (i.e some hundred million
         // entries), so use raw pointers to avoid *any* overhead.
         typedef std::map<uint64_t,const LazyObject* > ObjectMap;
@@ -859,19 +859,16 @@ namespace STEP {
             : reader(reader)
             , splitter(*reader,true,true)
             , evaluated_count()
-            , schema( NULL )
+            , schema( nullptr )
         {}
 
     public:
-
         ~DB() {
             for(ObjectMap::value_type& o : objects) {
                 delete o.second;
             }
         }
 
-    public:
-
         uint64_t GetObjectCount() const {
             return objects.size();
         }
@@ -900,7 +897,6 @@ namespace STEP {
             return refs;
         }
 
-
         bool KeepInverseIndicesForType(const char* const type) const {
             return inv_whitelist.find(type) != inv_whitelist.end();
         }
@@ -912,7 +908,7 @@ namespace STEP {
             if (it != objects.end()) {
                 return (*it).second;
             }
-            return NULL;
+            return nullptr;
         }
 
 
diff --git a/scripts/StepImporter/CppGenerator.py b/scripts/StepImporter/CppGenerator.py
index b6b692db7..156f19523 100644
--- a/scripts/StepImporter/CppGenerator.py
+++ b/scripts/StepImporter/CppGenerator.py
@@ -48,11 +48,27 @@ if sys.version_info < (3, 0):
     print("must use python 3.0 or greater")
     sys.exit(-2)
 
-input_template_h = 'IFCReaderGen.h.template'
-input_template_cpp = 'IFCReaderGen.cpp.template'
+use_ifc_template = False
+	
+input_step_template_h   = 'StepReaderGen.h.template'
+input_step_template_cpp = 'StepReaderGen.cpp.template'
+input_ifc_template_h        = 'IFCReaderGen.h.template'
+input_ifc_template_cpp      = 'IFCReaderGen.cpp.template'
 
-output_file_h = os.path.join('..','..','code','IFCReaderGen.h')
-output_file_cpp = os.path.join('..','..','code','IFCReaderGen.cpp')
+cpp_keywords = "class"
+
+output_file_h = ""
+output_file_cpp = ""
+if (use_ifc_template ):
+    input_template_h = input_ifc_template_h
+    input_template_cpp = input_ifc_template_cpp
+    output_file_h = os.path.join('..','..','code','IFCReaderGen.h')
+    output_file_cpp = os.path.join('..','..','code','IFCReaderGen.cpp')
+else:
+    input_template_h = input_step_template_h
+    input_template_cpp = input_step_template_cpp
+    output_file_h = os.path.join('..','..','code/Importer/StepFile','StepReaderGen.h')
+    output_file_cpp = os.path.join('..','..','code/Importer/StepFile','StepReaderGen.cpp')
 
 template_entity_predef = '\tstruct {entity};\n'
 template_entity_predef_ni = '\ttypedef NotImplemented {entity}; // (not currently used by Assimp)\n'
@@ -99,7 +115,6 @@ template_converter_epilogue = '\treturn base;'
 
 import ExpressReader
 
-
 def get_list_bounds(collection_spec):
     start,end = [(int(n) if n!='?' else 0) for n in re.findall(r'(\d+|\?)',collection_spec)]
     return start,end
@@ -221,9 +236,11 @@ def work(filename):
     schema = ExpressReader.read(filename,silent=True)
     entities, stub_decls, schema_table, converters, typedefs, predefs = '','',[],'','',''
 
-    
+    entitylist = 'ifc_entitylist.txt'
+    if not use_ifc_template:
+        entitylist = 'step_entitylist.txt'
     whitelist = []
-    with open('entitylist.txt', 'rt') as inp:
+    with open(entitylist, 'rt') as inp:
         whitelist = [n.strip() for n in inp.read().split('\n') if n[:1]!='#' and n.strip()]
 
     schema.whitelist = set()
@@ -242,12 +259,14 @@ def work(filename):
     schema.blacklist_partial -= schema.whitelist
     schema.whitelist |= schema.blacklist_partial
 
+    # Generate list with reserved keywords from c++
+    cpp_types = cpp_keywords.split(',')
+
     # uncomment this to disable automatic code reduction based on whitelisting all used entities
     # (blacklisted entities are those who are in the whitelist and may be instanced, but will
     # only be accessed through a pointer to a base-class.
     #schema.whitelist = set(schema.entities.keys())
     #schema.blacklist_partial = set()
-
     for ntype in schema.types.values():
         typedefs += gen_type_struct(ntype,schema)
         schema_table.append(template_schema_type.format(normalized_name=ntype.name.lower()))
@@ -256,6 +275,9 @@ def work(filename):
     for entity in sorted_entities:
         parent = entity.parent+',' if entity.parent else ''
 
+        if ( entity.name in cpp_types ):
+            entity.name = entity.name + "_t"
+            print( "renaming " + entity.name)
         if entity.name in schema.whitelist:
             converters += template_converter.format(type=entity.name,contents=gen_converter(entity,schema))
             schema_table.append(template_schema.format(type=entity.name,normalized_name=entity.name.lower(),argcnt=len(entity.members)))
diff --git a/scripts/StepImporter/IFCReaderGen.cpp.template b/scripts/StepImporter/IFCReaderGen.cpp.template
index 8cd6658ba..562b69807 100644
--- a/scripts/StepImporter/IFCReaderGen.cpp.template
+++ b/scripts/StepImporter/IFCReaderGen.cpp.template
@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2018, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms, 
@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
 
-#include "AssimpPCH.h"
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
 #include "IFCReaderGen.h"
diff --git a/scripts/StepImporter/StepReaderGen.cpp.template b/scripts/StepImporter/StepReaderGen.cpp.template
new file mode 100644
index 000000000..343c43019
--- /dev/null
+++ b/scripts/StepImporter/StepReaderGen.cpp.template
@@ -0,0 +1,78 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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_STEPFILE_IMPORTER
+
+#include "code/Importer/StepFile/StepReaderGen.h"
+
+namespace Assimp {
+using namespace StepFile;
+
+namespace {
+
+	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
+	const SchemaEntry schema_raw[] =  {
+{schema-static-table}
+	};
+}
+
+// -----------------------------------------------------------------------------------------------------------
+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;
+}
+
+
+{converter-impl}
+
+} // ! STEP
+} // ! Assimp
+
+#endif
diff --git a/scripts/StepImporter/StepReaderGen.h.template b/scripts/StepImporter/StepReaderGen.h.template
new file mode 100644
index 000000000..5f9a2fd5d
--- /dev/null
+++ b/scripts/StepImporter/StepReaderGen.h.template
@@ -0,0 +1,91 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, 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/STEPFile.h"
+
+namespace Assimp {
+namespace StepFile {
+	using namespace STEP;
+	using namespace STEP::EXPRESS;
+	
+	
+	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
+		
+	};
+	
+
+	// ******************************************************************************
+	// StepFile Custom data types
+	// ******************************************************************************
+
+{types}
+
+
+	// ******************************************************************************
+	// StepFile Entities
+	// ******************************************************************************
+
+{predefs}
+{entities}
+
+	void GetSchema(EXPRESS::ConversionSchema& out);
+
+} //! StepFile
+namespace STEP {
+
+	// ******************************************************************************
+	// Converter stubs
+	// ******************************************************************************
+	
+#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::type* in)
+	
+{converter-decl}
+
+#undef DECL_CONV_STUB
+
+} //! STEP
+} //! Assimp
+
+#endif // INCLUDED_STEPFILE_READER_GEN_H
diff --git a/scripts/StepImporter/extract_step_token.py b/scripts/StepImporter/extract_step_token.py
new file mode 100644
index 000000000..c7f89537a
--- /dev/null
+++ b/scripts/StepImporter/extract_step_token.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- Coding: UTF-8 -*-
+
+# ---------------------------------------------------------------------------
+# Open Asset Import Library (ASSIMP)
+# ---------------------------------------------------------------------------
+#
+# Copyright (c) 2006-2018, 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.
+# ---------------------------------------------------------------------------
+
+import sys
+
+Entity_token = "ENTITY"
+Type_token   = "TYPE"
+token = []
+file = open(sys.argv[1])
+output = open("step_entitylist.txt", "a")
+lines = file.readlines()
+for line in lines:
+    pos = line.find(Entity_token)
+    if pos != -1:
+        token = line.split(" ")
+        if len(token) > 1:
+            name = token[1]
+            print( "Writing entity " + name)
+            output.write(name)
+
+output.close()
+file.close()
+
+
+    
diff --git a/scripts/StepImporter/entitylist.txt b/scripts/StepImporter/ifc_entitylist.txt
similarity index 100%
rename from scripts/StepImporter/entitylist.txt
rename to scripts/StepImporter/ifc_entitylist.txt
diff --git a/scripts/StepImporter/part403ts_wg3n2635mim_lf.exp b/scripts/StepImporter/part403ts_wg3n2635mim_lf.exp
new file mode 100644
index 000000000..79353049a
--- /dev/null
+++ b/scripts/StepImporter/part403ts_wg3n2635mim_lf.exp
@@ -0,0 +1,16378 @@
+(*
+  $Id: mim_lf.exp,v 1.43 2009/09/10 20:08:09 darla Exp $
+  ISO TC184/SC4/WG3 N2635 - ISO/TS 10303-403 AP203 configuration controlled 3d design of mechanical parts and assemblies - EXPRESS MIM Long form 
+  Supersedes ISO TC184/SC4/WG3 N2464
+*) 
+
+SCHEMA Ap203_configuration_controlled_3d_design_of_mechanical_parts_and_assemblies_mim_lf;
+
+
+CONSTANT
+	deprecated_constructed_data_types : SET [0:?] OF STRING := ['approved_item',
+       'certified_item', 
+       'change_request_item', 
+       'contracted_item', 
+       'cc_classified_item', 
+       'date_time_item', 
+       'cc_person_organization_item', 
+       'cc_specified_item', 
+       'start_request_item', 
+       'work_item'];
+
+
+	deprecated_entity_data_types : SET [0:?] OF STRING := ['cc_design_approval',
+       'cc_design_certification', 
+       'cc_design_contract', 
+       'cc_design_date_and_time_assignment', 
+       'cc_design_person_and_organization_assignment', 
+       'cc_design_security_classification', 
+       'cc_design_specification_reference', 
+       'change', 
+       'change_request', 
+       'design_context', 
+       'design_make_from_relationship', 
+       'mechanical_context', 
+       'start_request', 
+       'start_work', 
+       'supplied_part_relationship'];
+
+
+	deprecated_interfaced_data_types : SET [0:?] OF STRING := ['document_with_class',
+       'ordinal_date', 
+       'product_definition_formation_with_specified_source', 
+       'week_of_year_and_day_date'];
+
+
+	dummy_gri : geometric_representation_item := representation_item('')||
+                                   geometric_representation_item();
+
+
+	dummy_tri : topological_representation_item := representation_item('')||
+                   topological_representation_item();
+
+
+	pre_defined_picture_representation_types : SET [0:?] OF STRING := [ 'JPEG', 'PNG', 'TIFF', 'BMP', 'GIF'];
+
+
+
+END_CONSTANT;
+
+TYPE absorbed_dose_measure = REAL;
+END_TYPE;
+
+TYPE acceleration_measure = REAL;
+END_TYPE;
+
+TYPE action_items = SELECT (
+	action_directive,
+	certification_item,
+	characterized_object,
+	classification_item,
+	configuration_effectivity,
+	document_reference_item,
+	identification_item,
+	organization,
+	person_and_organization,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	requirement_assigned_item);
+END_TYPE;
+
+TYPE action_method_items = SELECT (
+	product,
+	product_definition_formation);
+END_TYPE;
+
+TYPE action_request_item = SELECT (
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	versioned_action_request);
+END_TYPE;
+
+TYPE ahead_or_behind = ENUMERATION OF (
+	ahead,
+	exact,
+	behind );
+END_TYPE;
+
+TYPE amount_of_substance_measure = REAL;
+END_TYPE;
+
+TYPE angle_direction_reference_select = SELECT (
+	direction,
+	curve,
+	point_path);
+END_TYPE;
+
+TYPE angle_direction_reference_with_a2p3d_select = SELECT (
+	angle_direction_reference_select,
+	axis2_placement_3d);
+END_TYPE;
+
+TYPE angle_relator = ENUMERATION OF (
+	equal,
+	large,
+	small );
+END_TYPE;
+
+TYPE annotation_plane_element = SELECT (
+	draughting_callout,
+	styled_item);
+END_TYPE;
+
+TYPE annotation_representation_select = SELECT (
+	presentation_area,
+	presentation_view,
+	symbol_representation);
+END_TYPE;
+
+TYPE annotation_symbol_occurrence_item = SELECT (
+	annotation_symbol,
+	defined_symbol);
+END_TYPE;
+
+TYPE annotation_text_occurrence_item = SELECT (
+	text_literal,
+	annotation_text,
+	annotation_text_character,
+	composite_text);
+END_TYPE;
+
+TYPE approval_item = SELECT (
+	action,
+	action_directive,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_usage_right,
+	assembly_component_usage_substitute,
+	certification,
+	configuration_effectivity,
+	configuration_item,
+	contract,
+	date,
+	directed_action,
+	document,
+	document_file,
+	effectivity,
+	executed_action,
+	general_property_relationship,
+	group,
+	group_relationship,
+	information_usage_right,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	representation,
+	requirement_assignment,
+	security_classification,
+	shape_aspect_relationship,
+	versioned_action_request);
+END_TYPE;
+
+TYPE approved_item = SELECT (
+	certification,
+	change,
+	change_request,
+	configuration_effectivity,
+	configuration_item,
+	contract,
+	product,
+	security_classification,
+	start_request,
+	start_work);
+END_TYPE;
+
+TYPE area_measure = REAL;
+END_TYPE;
+
+TYPE area_or_view = SELECT (
+	presentation_area,
+	presentation_view);
+END_TYPE;
+
+TYPE attribute_classification_item = SELECT (
+	action_directive,
+	action_method,
+	action_property,
+	action_property_representation,
+	action_relationship,
+	action_request_solution,
+	action_request_status,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_action_request_assignment,
+	applied_approval_assignment,
+	applied_certification_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_effectivity_assignment,
+	applied_event_occurrence_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organization_assignment,
+	applied_organizational_project_assignment,
+	applied_person_and_organization_assignment,
+	approval,
+	approval_person_organization,
+	approval_relationship,
+	approval_status,
+	certification,
+	context_dependent_unit,
+	contract,
+	date_and_time_assignment,
+	date_assignment,
+	derived_unit,
+	descriptive_representation_item,
+	document_file,
+	document_relationship,
+	effectivity,
+	event_occurrence_relationship,
+	executed_action,
+	general_property,
+	general_property_relationship,
+	group,
+	group_relationship,
+	information_right,
+	information_usage_right,
+	language,
+	measure_representation_item,
+	measure_with_unit,
+	named_unit,
+	organization_relationship,
+	organizational_address,
+	organizational_project_relationship,
+	person_and_organization,
+	person_and_organization_address,
+	product,
+	product_category,
+	product_concept,
+	product_concept_context,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	property_definition_relationship,
+	property_definition_representation,
+	representation,
+	representation_context,
+	representation_item,
+	security_classification,
+	time_interval_relationship,
+	uncertainty_measure_with_unit,
+	usage_association,
+	versioned_action_request);
+END_TYPE;
+
+TYPE attribute_language_item = SELECT (
+	alternate_product_relationship,
+	application_context,
+	applied_certification_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organizational_project_assignment,
+	applied_security_classification_assignment,
+	approval,
+	approval_relationship,
+	approval_status,
+	assembly_component_usage_substitute,
+	attribute_value_assignment,
+	certification,
+	certification_type,
+	configuration_design,
+	configuration_item,
+	contract,
+	date_role,
+	date_time_role,
+	descriptive_representation_item,
+	document_relationship,
+	document_usage_role,
+	effectivity,
+	effectivity_relationship,
+	event_occurrence,
+	external_source,
+	general_property,
+	general_property_relationship,
+	geometric_representation_item,
+	geometric_tolerance,
+	identification_role,
+	information_right,
+	information_usage_right,
+	make_from_usage_option,
+	mapped_item,
+	multi_language_attribute_assignment,
+	object_role,
+	organization_relationship,
+	organization_role,
+	organizational_project,
+	organizational_project_relationship,
+	organizational_project_role,
+	person_and_organization,
+	person_and_organization_role,
+	product,
+	product_concept,
+	product_concept_relationship,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	product_definition_shape,
+	product_related_product_category,
+	property_definition,
+	representation,
+	security_classification,
+	security_classification_assignment,
+	shape_aspect,
+	shape_aspect_relationship,
+	shape_representation,
+	time_interval_role,
+	topological_representation_item,
+	uncertainty_measure_with_unit,
+	uncertainty_qualifier,
+	usage_association);
+END_TYPE;
+
+TYPE attribute_type = SELECT (
+	label,
+	text);
+END_TYPE;
+
+TYPE axis2_placement = SELECT (
+	axis2_placement_2d,
+	axis2_placement_3d);
+END_TYPE;
+
+TYPE b_spline_curve_form = ENUMERATION OF (
+	polyline_form,
+	circular_arc,
+	elliptic_arc,
+	parabolic_arc,
+	hyperbolic_arc,
+	unspecified );
+END_TYPE;
+
+TYPE b_spline_surface_form = ENUMERATION OF (
+	plane_surf,
+	cylindrical_surf,
+	conical_surf,
+	spherical_surf,
+	toroidal_surf,
+	surf_of_revolution,
+	ruled_surf,
+	generalised_cone,
+	quadric_surf,
+	surf_of_linear_extrusion,
+	unspecified );
+END_TYPE;
+
+TYPE base_solid_select = SELECT (
+	solid_model,
+	csg_primitive,
+	boolean_result);
+WHERE
+	WR1 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRIMITIVE_2D' IN TYPEOF(SELF));
+END_TYPE;
+
+TYPE blend_end_condition_select = SELECT (
+	point_on_curve,
+	edge_curve,
+	vertex);
+END_TYPE;
+
+TYPE blend_radius_variation_type = ENUMERATION OF (
+	linear_blend,
+	cubic_blend,
+	unspecified_blend );
+END_TYPE;
+
+TYPE boolean_operand = SELECT (
+	solid_model,
+	half_space_solid,
+	csg_primitive,
+	boolean_result);
+END_TYPE;
+
+TYPE boolean_operator = ENUMERATION OF (
+	union,
+	intersection,
+	difference );
+END_TYPE;
+
+TYPE box_characteristic_select = SELECT (
+	box_height,
+	box_width,
+	box_slant_angle,
+	box_rotate_angle);
+END_TYPE;
+
+TYPE box_height = positive_ratio_measure;
+END_TYPE;
+
+TYPE box_rotate_angle = plane_angle_measure;
+END_TYPE;
+
+TYPE box_slant_angle = plane_angle_measure;
+END_TYPE;
+
+TYPE box_width = positive_ratio_measure;
+END_TYPE;
+
+TYPE camera_model_d3_multi_clipping_interection_select = SELECT (
+	camera_model_d3_multi_clipping_union,
+	plane);
+END_TYPE;
+
+TYPE camera_model_d3_multi_clipping_union_select = SELECT (
+	camera_model_d3_multi_clipping_intersection,
+	plane);
+END_TYPE;
+
+TYPE capacitance_measure = REAL;
+END_TYPE;
+
+TYPE category_usage_item = SELECT (
+	product_class);
+END_TYPE;
+
+TYPE cc_classified_item = SELECT (
+	assembly_component_usage,
+	product_definition_formation);
+END_TYPE;
+
+TYPE cc_person_organization_item = SELECT (
+	change,
+	change_request,
+	configuration_item,
+	contract,
+	product,
+	product_definition,
+	product_definition_formation,
+	security_classification,
+	start_request,
+	start_work);
+END_TYPE;
+
+TYPE cc_specified_item = SELECT (
+	product_definition,
+	shape_aspect);
+END_TYPE;
+
+TYPE celsius_temperature_measure = REAL;
+END_TYPE;
+
+TYPE central_or_parallel = ENUMERATION OF (
+	central,
+	parallel );
+END_TYPE;
+
+TYPE certification_item = SELECT (
+	alternate_product_relationship,
+	make_from_usage_option,
+	product_definition_formation,
+	product_definition_formation_relationship);
+END_TYPE;
+
+TYPE certified_item = SELECT (
+	supplied_part_relationship);
+END_TYPE;
+
+TYPE change_request_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE character_spacing_select = SELECT (
+	length_measure,
+	ratio_measure,
+	measure_with_unit,
+	descriptive_measure);
+END_TYPE;
+
+TYPE character_style_select = SELECT (
+	character_glyph_style_stroke,
+	character_glyph_style_outline,
+	text_style_for_defined_font);
+END_TYPE;
+
+TYPE characterized_action_definition = SELECT (
+	action,
+	action_method,
+	action_method_relationship,
+	action_relationship);
+END_TYPE;
+
+TYPE characterized_definition = SELECT (
+	characterized_object,
+	characterized_product_definition,
+	shape_definition);
+END_TYPE;
+
+TYPE characterized_material_property = SELECT (
+	material_property_representation,
+	product_material_composition_relationship);
+END_TYPE;
+
+TYPE characterized_product_composition_value = SELECT (
+	measure_with_unit);
+END_TYPE;
+
+TYPE characterized_product_definition = SELECT (
+	product_definition,
+	product_definition_relationship);
+END_TYPE;
+
+TYPE class_usage_effectivity_context_item = SELECT (
+	product_definition);
+END_TYPE;
+
+TYPE classification_item = SELECT (
+	action,
+	action_directive,
+	action_method,
+	action_property,
+	action_relationship,
+	action_request_solution,
+	action_request_status,
+	address,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_action_request_assignment,
+	applied_approval_assignment,
+	applied_certification_assignment,
+	applied_contract_assignment,
+	applied_date_and_time_assignment,
+	applied_date_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_effectivity_assignment,
+	applied_event_occurrence_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organization_assignment,
+	applied_organizational_project_assignment,
+	applied_person_and_organization_assignment,
+	applied_security_classification_assignment,
+	approval,
+	approval_person_organization,
+	approval_relationship,
+	approval_status,
+	assembly_component_usage_substitute,
+	calendar_date,
+	certification,
+	characterized_class,
+	characterized_object,
+	class,
+	classified_item,
+	configuration_item,
+	context_dependent_unit,
+	contract,
+	conversion_based_unit,
+	date_and_time,
+	date_and_time_assignment,
+	date_assignment,
+	derived_unit,
+	descriptive_representation_item,
+	directed_action,
+	document_file,
+	document_relationship,
+	effectivity,
+	event_occurrence,
+	executed_action,
+	general_property,
+	general_property_relationship,
+	group,
+	identification_assignment,
+	information_right,
+	information_usage_right,
+	language,
+	measure_representation_item,
+	measure_with_unit,
+	multi_language_attribute_assignment,
+	named_unit,
+	organization,
+	organization_relationship,
+	organizational_address,
+	organizational_project,
+	organizational_project_relationship,
+	person,
+	person_and_organization_address,
+	product,
+	product_concept,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	property_definition_representation,
+	representation,
+	representation_context,
+	representation_item,
+	security_classification,
+	uncertainty_measure_with_unit,
+	usage_association,
+	versioned_action_request);
+END_TYPE;
+
+TYPE classified_item = SELECT (
+	product,
+	product_definition,
+	product_definition_formation);
+END_TYPE;
+
+TYPE compound_item_definition = SELECT (
+	list_representation_item,
+	set_representation_item);
+END_TYPE;
+
+TYPE conductance_measure = REAL;
+END_TYPE;
+
+TYPE configuration_design_item = SELECT (
+	product_definition,
+	product_definition_formation);
+END_TYPE;
+
+TYPE configured_effectivity_context_item = SELECT (
+	product_concept_feature_association);
+END_TYPE;
+
+TYPE configured_effectivity_item = SELECT (
+	product_definition);
+END_TYPE;
+
+TYPE constructive_geometry_representation_or_shape_represenation = SELECT (
+	constructive_geometry_representation,
+	shape_representation);
+END_TYPE;
+
+TYPE context_dependent_measure = REAL;
+END_TYPE;
+
+TYPE contract_item = SELECT (
+	action_directive,
+	alternate_product_relationship,
+	directed_action,
+	executed_action,
+	information_usage_right,
+	organization,
+	person_and_organization,
+	product,
+	product_definition_formation);
+END_TYPE;
+
+TYPE contracted_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE count_measure = NUMBER;
+END_TYPE;
+
+TYPE csg_primitive = SELECT (
+	sphere,
+	block,
+	right_angular_wedge,
+	torus,
+	right_circular_cone,
+	right_circular_cylinder);
+END_TYPE;
+
+TYPE csg_select = SELECT (
+	boolean_result,
+	csg_primitive);
+END_TYPE;
+
+TYPE curve_font_or_scaled_curve_font_select = SELECT (
+	curve_style_font_select,
+	curve_style_font_and_scaling);
+END_TYPE;
+
+TYPE curve_on_surface = SELECT (
+	pcurve,
+	surface_curve,
+	composite_curve_on_surface);
+END_TYPE;
+
+TYPE curve_or_annotation_curve_occurrence = SELECT (
+	curve,
+	annotation_curve_occurrence);
+END_TYPE;
+
+TYPE curve_or_render = SELECT (
+	curve_style,
+	curve_style_rendering);
+END_TYPE;
+
+TYPE curve_style_font_select = SELECT (
+	curve_style_font,
+	pre_defined_curve_font,
+	externally_defined_curve_font);
+END_TYPE;
+
+TYPE date_and_time_item = SELECT (
+	action,
+	action_directive,
+	applied_action_assignment,
+	applied_organization_assignment,
+	applied_person_and_organization_assignment,
+	applied_security_classification_assignment,
+	approval_person_organization,
+	certification,
+	contract,
+	directed_action,
+	document,
+	document_file,
+	event_occurrence,
+	executed_action,
+	information_usage_right,
+	organizational_project,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	rule_action,
+	security_classification,
+	versioned_action_request);
+END_TYPE;
+
+TYPE date_item = SELECT (
+	action,
+	action_directive,
+	applied_action_assignment,
+	applied_organization_assignment,
+	applied_person_and_organization_assignment,
+	applied_security_classification_assignment,
+	approval_person_organization,
+	certification,
+	contract,
+	directed_action,
+	document,
+	document_file,
+	event_occurrence,
+	executed_action,
+	information_usage_right,
+	organizational_project,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	security_classification,
+	versioned_action_request);
+END_TYPE;
+
+TYPE date_time_item = SELECT (
+	approval_person_organization,
+	certification,
+	change,
+	change_request,
+	contract,
+	product_definition,
+	security_classification,
+	start_request,
+	start_work);
+END_TYPE;
+
+TYPE date_time_or_event_occurrence = SELECT (
+	date_time_select,
+	event_occurrence);
+END_TYPE;
+
+TYPE date_time_select = SELECT (
+	date,
+	date_and_time,
+	local_time);
+END_TYPE;
+
+TYPE day_in_month_number = INTEGER;
+WHERE
+	WR1 : {1 <= SELF <= 31};
+END_TYPE;
+
+TYPE day_in_week_number = INTEGER;
+WHERE
+	WR1 : { 1 <= SELF <= 7 };
+END_TYPE;
+
+TYPE day_in_year_number = INTEGER;
+WHERE
+	WR1 : {1 <= SELF <= 366};
+END_TYPE;
+
+TYPE defined_symbol_select = SELECT (
+	pre_defined_symbol,
+	externally_defined_symbol);
+END_TYPE;
+
+TYPE derived_property_select = SELECT (
+	property_definition,
+	action_property);
+END_TYPE;
+
+TYPE description_attribute_select = SELECT (
+	action_request_solution,
+	application_context,
+	approval_role,
+	configuration_design,
+	date_role,
+	date_time_role,
+	context_dependent_shape_representation,
+	effectivity,
+	external_source,
+	organization_role,
+	person_and_organization_role,
+	person_and_organization,
+	property_definition_representation,
+	representation);
+END_TYPE;
+
+TYPE descriptive_measure = STRING;
+END_TYPE;
+
+TYPE dimension_count = INTEGER;
+WHERE
+	WR1 : SELF > 0;
+END_TYPE;
+
+TYPE dimension_extent_usage = ENUMERATION OF (
+	origin,
+	target );
+END_TYPE;
+
+TYPE dimensional_characteristic = SELECT (
+	dimensional_location,
+	dimensional_size);
+END_TYPE;
+
+TYPE direction_count_select = SELECT (
+	u_direction_count,
+	v_direction_count);
+END_TYPE;
+
+TYPE document_identifier_assigned_item = SELECT (
+	document);
+END_TYPE;
+
+TYPE document_reference_item = SELECT (
+	action_method,
+	applied_external_identification_assignment,
+	assembly_component_usage,
+	characterized_class,
+	characterized_object,
+	configuration_item,
+	descriptive_representation_item,
+	dimensional_size,
+	executed_action,
+	externally_defined_dimension_definition,
+	externally_defined_item,
+	group,
+	group_relationship,
+	information_right,
+	information_usage_right,
+	material_designation,
+	measure_representation_item,
+	product,
+	product_category,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	property_definition,
+	representation,
+	representation_item,
+	rule_set,
+	shape_aspect,
+	shape_aspect_relationship,
+	usage_association,
+	versioned_action_request);
+END_TYPE;
+
+TYPE dose_equivalent_measure = REAL;
+END_TYPE;
+
+TYPE draughting_callout_element = SELECT (
+	annotation_text_occurrence,
+	annotation_symbol_occurrence,
+	annotation_curve_occurrence);
+END_TYPE;
+
+TYPE draughting_model_item_association_select = SELECT (
+	annotation_occurrence,
+	draughting_callout);
+END_TYPE;
+
+TYPE draughting_model_item_select = SELECT (
+	mapped_item,
+	styled_item,
+	axis2_placement,
+	camera_model,
+	draughting_callout);
+END_TYPE;
+
+TYPE draughting_titled_item = SELECT (
+	drawing_revision,
+	drawing_sheet_revision);
+END_TYPE;
+
+TYPE effectivity_item = SELECT (
+	assembly_component_usage_substitute,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	product_definition_substitute);
+END_TYPE;
+
+TYPE electric_charge_measure = REAL;
+END_TYPE;
+
+TYPE electric_current_measure = REAL;
+END_TYPE;
+
+TYPE electric_potential_measure = REAL;
+END_TYPE;
+
+TYPE energy_measure = REAL;
+END_TYPE;
+
+TYPE event_occurrence_item = SELECT (
+	organizational_project);
+END_TYPE;
+
+TYPE external_identification_item = SELECT (
+	action_relationship,
+	action_request_status,
+	applied_organization_assignment,
+	applied_person_and_organization_assignment,
+	approval,
+	approval_status,
+	date_and_time_assignment,
+	date_assignment,
+	document_file,
+	external_source,
+	externally_defined_class,
+	externally_defined_context_dependent_unit,
+	externally_defined_conversion_based_unit,
+	externally_defined_general_property,
+	externally_defined_picture_representation_item,
+	externally_defined_representation_item,
+	organizational_address,
+	product_definition,
+	security_classification,
+	trimmed_curve,
+	versioned_action_request);
+END_TYPE;
+
+TYPE fill_area_style_tile_shape_select = SELECT (
+	fill_area_style_tile_curve_with_style,
+	fill_area_style_tile_coloured_region,
+	fill_area_style_tile_symbol_with_style,
+	pre_defined_tile,
+	externally_defined_tile);
+END_TYPE;
+
+TYPE fill_style_select = SELECT (
+	fill_area_style_colour,
+	externally_defined_tile_style,
+	fill_area_style_tiles,
+	externally_defined_hatch_style,
+	fill_area_style_hatching);
+END_TYPE;
+
+TYPE font_select = SELECT (
+	pre_defined_text_font,
+	externally_defined_text_font,
+	text_font);
+END_TYPE;
+
+TYPE force_measure = REAL;
+END_TYPE;
+
+TYPE founded_item_select = SELECT (
+	founded_item,
+	representation_item);
+END_TYPE;
+
+TYPE frequency_measure = REAL;
+END_TYPE;
+
+TYPE generalized_surface_select = SELECT (
+	surface,
+	face_surface,
+	surfaced_open_shell);
+END_TYPE;
+
+TYPE geometric_item_specific_usage_select = SELECT (
+	shape_aspect,
+	shape_aspect_relationship);
+END_TYPE;
+
+TYPE geometric_set_select = SELECT (
+	point,
+	curve,
+	surface);
+END_TYPE;
+
+TYPE groupable_item = SELECT (
+	geometric_representation_item,
+	group_relationship,
+	mapped_item,
+	package_product_concept_feature,
+	product_concept_feature,
+	product_definition,
+	product_definition_formation,
+	property_definition_representation,
+	representation,
+	representation_item,
+	representation_relationship_with_transformation,
+	shape_aspect,
+	shape_aspect_relationship,
+	shape_representation_relationship,
+	styled_item,
+	topological_representation_item);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GROUP' IN TYPEOF(SELF));
+END_TYPE;
+
+TYPE hour_in_day = INTEGER;
+WHERE
+	WR1 : { 0 <= SELF < 24 };
+END_TYPE;
+
+TYPE id_attribute_select = SELECT (
+	action,
+	address,
+	product_category,
+	property_definition,
+	shape_aspect,
+	shape_aspect_relationship,
+	application_context,
+	group,
+	organizational_project,
+	representation);
+END_TYPE;
+
+TYPE identification_item = SELECT (
+	approval_status,
+	characterized_class,
+	class,
+	configuration_item,
+	contract,
+	dimensional_size,
+	document_file,
+	general_property,
+	group,
+	group_relationship,
+	information_right,
+	information_usage_right,
+	material_designation,
+	organization,
+	person_and_organization,
+	product,
+	product_category,
+	product_class,
+	product_concept,
+	product_concept_feature,
+	product_definition,
+	product_definition_formation,
+	product_identification,
+	representation,
+	rule_set,
+	security_classification,
+	security_classification_level,
+	shape_aspect_relationship,
+	shape_representation,
+	usage_association);
+END_TYPE;
+
+TYPE identifier = STRING;
+END_TYPE;
+
+TYPE illuminance_measure = REAL;
+END_TYPE;
+
+TYPE inductance_measure = REAL;
+END_TYPE;
+
+TYPE instance_usage_context_select = SELECT (
+	product_definition_relationship,
+	product_definition_usage);
+END_TYPE;
+
+TYPE invisibility_context = SELECT (
+	draughting_model,
+	presentation_representation,
+	presentation_set);
+END_TYPE;
+
+TYPE invisible_item = SELECT (
+	draughting_callout,
+	presentation_layer_assignment,
+	representation,
+	styled_item);
+END_TYPE;
+
+TYPE ir_usage_item = action_items;
+WHERE
+	wr1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONFIGURATION_EFFECTIVITY' IN TYPEOF(SELF));
+END_TYPE;
+
+TYPE knot_type = ENUMERATION OF (
+	uniform_knots,
+	quasi_uniform_knots,
+	piecewise_bezier_knots,
+	unspecified );
+END_TYPE;
+
+TYPE label = STRING;
+END_TYPE;
+
+TYPE layered_item = SELECT (
+	presentation_representation,
+	representation_item);
+END_TYPE;
+
+TYPE length_measure = REAL;
+END_TYPE;
+
+TYPE limit_condition = ENUMERATION OF (
+	maximum_material_condition,
+	least_material_condition,
+	regardless_of_feature_size );
+END_TYPE;
+
+TYPE list_of_reversible_topology_item = LIST [0:?] OF reversible_topology_item;
+END_TYPE;
+
+TYPE list_representation_item = LIST [1:?] OF representation_item;
+END_TYPE;
+
+TYPE luminous_flux_measure = REAL;
+END_TYPE;
+
+TYPE luminous_intensity_measure = REAL;
+END_TYPE;
+
+TYPE magnetic_flux_density_measure = REAL;
+END_TYPE;
+
+TYPE magnetic_flux_measure = REAL;
+END_TYPE;
+
+TYPE marker_select = SELECT (
+	marker_type,
+	pre_defined_marker);
+END_TYPE;
+
+TYPE marker_type = ENUMERATION OF (
+	dot,
+	x,
+	plus,
+	asterisk,
+	ring,
+	square,
+	triangle );
+END_TYPE;
+
+TYPE mass_measure = REAL;
+END_TYPE;
+
+TYPE measure_value = SELECT (
+	absorbed_dose_measure,
+	dose_equivalent_measure,
+	radioactivity_measure,
+	acceleration_measure,
+	amount_of_substance_measure,
+	area_measure,
+	celsius_temperature_measure,
+	context_dependent_measure,
+	count_measure,
+	descriptive_measure,
+	capacitance_measure,
+	electric_charge_measure,
+	conductance_measure,
+	electric_current_measure,
+	electric_potential_measure,
+	energy_measure,
+	magnetic_flux_density_measure,
+	force_measure,
+	frequency_measure,
+	illuminance_measure,
+	inductance_measure,
+	length_measure,
+	luminous_flux_measure,
+	luminous_intensity_measure,
+	magnetic_flux_measure,
+	mass_measure,
+	numeric_measure,
+	non_negative_length_measure,
+	parameter_value,
+	plane_angle_measure,
+	positive_length_measure,
+	positive_plane_angle_measure,
+	positive_ratio_measure,
+	power_measure,
+	pressure_measure,
+	ratio_measure,
+	resistance_measure,
+	solid_angle_measure,
+	thermodynamic_temperature_measure,
+	time_measure,
+	velocity_measure,
+	volume_measure);
+END_TYPE;
+
+TYPE mechanical_design_and_draughting_relationship_select = SELECT (
+	draughting_model,
+	mechanical_design_geometric_presentation_representation,
+	mechanical_design_presentation_representation_with_draughting,
+	mechanical_design_shaded_presentation_representation,
+	shape_representation);
+END_TYPE;
+
+TYPE mechanical_design_geometric_presentation_area_items = SELECT (
+	axis2_placement,
+	mapped_item);
+END_TYPE;
+
+TYPE mechanical_design_geometric_presentation_representation_items = SELECT (
+	axis2_placement,
+	camera_model_d3,
+	mapped_item,
+	styled_item);
+END_TYPE;
+
+TYPE message = STRING;
+END_TYPE;
+
+TYPE minute_in_hour = INTEGER;
+WHERE
+	WR1 : { 0 <= SELF <= 59 };
+END_TYPE;
+
+TYPE month_in_year_number = INTEGER;
+WHERE
+	WR1 : { 1 <= SELF <= 12 };
+END_TYPE;
+
+TYPE multi_language_attribute_item = SELECT (
+	alternate_product_relationship,
+	application_context,
+	applied_certification_assignment,
+	applied_document_reference,
+	applied_document_usage_constraint_assignment,
+	applied_external_identification_assignment,
+	applied_identification_assignment,
+	applied_organizational_project_assignment,
+	approval,
+	approval_relationship,
+	approval_status,
+	assembly_component_usage_substitute,
+	attribute_value_assignment,
+	certification,
+	certification_type,
+	colour,
+	configuration_design,
+	configuration_item,
+	contract,
+	date_role,
+	date_time_role,
+	descriptive_representation_item,
+	document_relationship,
+	document_usage_role,
+	effectivity,
+	effectivity_relationship,
+	event_occurrence,
+	external_source,
+	general_property,
+	general_property_relationship,
+	geometric_representation_item,
+	geometric_tolerance,
+	identification_role,
+	information_right,
+	information_usage_right,
+	make_from_usage_option,
+	mapped_item,
+	object_role,
+	organization_relationship,
+	organization_role,
+	organizational_project,
+	organizational_project_relationship,
+	organizational_project_role,
+	person_and_organization,
+	person_and_organization_role,
+	product,
+	product_concept,
+	product_concept_relationship,
+	product_definition,
+	product_definition_context,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	product_definition_relationship,
+	product_definition_shape,
+	product_related_product_category,
+	property_definition,
+	representation,
+	representation_relationship,
+	security_classification,
+	security_classification_assignment,
+	shape_aspect,
+	shape_aspect_relationship,
+	shape_representation,
+	time_interval_role,
+	topological_representation_item,
+	uncertainty_measure_with_unit,
+	usage_association);
+END_TYPE;
+
+TYPE name_attribute_select = SELECT (
+	action_request_solution,
+	address,
+	configuration_design,
+	context_dependent_shape_representation,
+	derived_unit,
+	effectivity,
+	person_and_organization,
+	product_definition,
+	product_definition_substitute,
+	property_definition_representation);
+END_TYPE;
+
+TYPE name_item = SELECT (
+	assembly_component_usage,
+	external_class_library,
+	group,
+	group_relationship,
+	product,
+	product_definition);
+END_TYPE;
+
+TYPE non_negative_length_measure = length_measure;
+WHERE
+	WR1 : SELF >= 0.0;
+END_TYPE;
+
+TYPE nonnegative_integer = INTEGER;
+WHERE
+	nonnegativity : SELF >= 0;
+END_TYPE;
+
+TYPE null_style = ENUMERATION OF (
+	null );
+END_TYPE;
+
+TYPE numeric_measure = NUMBER;
+END_TYPE;
+
+TYPE organization_item = SELECT (
+	action,
+	action_directive,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_classification_assignment,
+	applied_identification_assignment,
+	applied_security_classification_assignment,
+	approval,
+	assembly_component_usage_substitute,
+	certification,
+	class,
+	configuration_item,
+	contract,
+	document_file,
+	executed_action,
+	general_property,
+	information_usage_right,
+	organizational_project,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	property_definition,
+	rule_action,
+	security_classification,
+	shape_representation,
+	versioned_action_request);
+END_TYPE;
+
+TYPE orientation_basis_select = SELECT (
+	axis2_placement_3d,
+	min_and_major_ply_orientation_basis);
+END_TYPE;
+
+TYPE parameter_value = REAL;
+END_TYPE;
+
+TYPE pcurve_or_surface = SELECT (
+	pcurve,
+	surface);
+END_TYPE;
+
+TYPE person_and_organization_item = SELECT (
+	action,
+	action_directive,
+	alternate_product_relationship,
+	applied_action_assignment,
+	applied_classification_assignment,
+	applied_identification_assignment,
+	applied_security_classification_assignment,
+	approval,
+	assembly_component_usage_substitute,
+	certification,
+	configuration_item,
+	contract,
+	document_file,
+	executed_action,
+	general_property,
+	information_usage_right,
+	organizational_project,
+	person_and_organization,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_formation_relationship,
+	property_definition,
+	rule_action,
+	security_classification,
+	shape_representation,
+	versioned_action_request);
+END_TYPE;
+
+TYPE person_organization_select = SELECT (
+	person,
+	organization,
+	person_and_organization);
+END_TYPE;
+
+TYPE picture_representation_item_select = SELECT (
+	styled_item,
+	planar_box,
+	axis2_placement_2d);
+END_TYPE;
+
+TYPE plane_angle_measure = REAL;
+END_TYPE;
+
+TYPE plane_or_planar_box = SELECT (
+	plane,
+	planar_box);
+END_TYPE;
+
+TYPE point_and_vector_member = SELECT (
+	point,
+	direction);
+END_TYPE;
+
+TYPE point_and_vector_members = LIST [2:3] OF point_and_vector_member;
+END_TYPE;
+
+TYPE point_path_members = LIST [1:?] OF point_and_vector;
+END_TYPE;
+
+TYPE positive_integer = nonnegative_integer;
+WHERE
+	positivity : SELF > 0;
+END_TYPE;
+
+TYPE positive_length_measure = non_negative_length_measure;
+WHERE
+	WR1 : SELF > 0.0;
+END_TYPE;
+
+TYPE positive_plane_angle_measure = plane_angle_measure;
+WHERE
+	WR1 : SELF > 0.0;
+END_TYPE;
+
+TYPE positive_ratio_measure = ratio_measure;
+WHERE
+	WR1 : SELF > 0.0;
+END_TYPE;
+
+TYPE power_measure = REAL;
+END_TYPE;
+
+TYPE preferred_surface_curve_representation = ENUMERATION OF (
+	curve_3d,
+	pcurve_s1,
+	pcurve_s2 );
+END_TYPE;
+
+TYPE presentable_text = STRING;
+WHERE
+	WR1 : control_characters_free(SELF);
+END_TYPE;
+
+TYPE presentation_representation_select = SELECT (
+	presentation_representation,
+	presentation_set);
+END_TYPE;
+
+TYPE presentation_size_assignment_select = SELECT (
+	presentation_view,
+	presentation_area,
+	area_in_set);
+END_TYPE;
+
+TYPE presentation_style_select = SELECT (
+	point_style,
+	curve_style,
+	surface_style_usage,
+	symbol_style,
+	fill_area_style,
+	text_style,
+	null_style);
+END_TYPE;
+
+TYPE presented_item_select = SELECT (
+	action,
+	action_method,
+	action_relationship,
+	product_concept,
+	product_concept_feature,
+	product_concept_feature_category,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship);
+END_TYPE;
+
+TYPE pressure_measure = REAL;
+END_TYPE;
+
+TYPE product_definition_or_assembly_relationship = SELECT (
+	assembly_component_usage,
+	product_definition);
+END_TYPE;
+
+TYPE product_definition_or_breakdown_element_usage = SELECT (
+	product_definition,
+	product_definition_usage);
+END_TYPE;
+
+TYPE product_definition_or_product_definition_relationship = SELECT (
+	product_definition,
+	product_definition_usage);
+END_TYPE;
+
+TYPE product_or_formation_or_definition = SELECT (
+	product,
+	product_definition_formation,
+	product_definition);
+END_TYPE;
+
+TYPE project_item = SELECT (
+	executed_action,
+	product_concept);
+END_TYPE;
+
+TYPE radioactivity_measure = REAL;
+END_TYPE;
+
+TYPE ratio_measure = REAL;
+END_TYPE;
+
+TYPE rendering_properties_select = SELECT (
+	surface_style_reflectance_ambient,
+	surface_style_transparent);
+END_TYPE;
+
+TYPE represented_definition = SELECT (
+	general_property,
+	property_definition,
+	property_definition_relationship,
+	shape_aspect,
+	shape_aspect_relationship);
+END_TYPE;
+
+TYPE requirement_assigned_item = SELECT (
+	configuration_item,
+	descriptive_representation_item,
+	product,
+	product_class,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	representation,
+	shape_aspect);
+END_TYPE;
+
+TYPE requirement_satisfaction_item = SELECT (
+	requirement_assigned_item);
+END_TYPE;
+
+TYPE requirement_source_item = SELECT (
+	characterized_object,
+	group,
+	group_relationship,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_relationship,
+	shape_aspect);
+END_TYPE;
+
+TYPE resistance_measure = REAL;
+END_TYPE;
+
+TYPE reversible_topology = SELECT (
+	reversible_topology_item,
+	list_of_reversible_topology_item,
+	set_of_reversible_topology_item);
+END_TYPE;
+
+TYPE reversible_topology_item = SELECT (
+	edge,
+	path,
+	face,
+	face_bound,
+	closed_shell,
+	open_shell);
+END_TYPE;
+
+TYPE role_select = SELECT (
+	action_assignment,
+	action_request_assignment,
+	approval_assignment,
+	approval_date_time,
+	certification_assignment,
+	contract_assignment,
+	document_reference,
+	effectivity_assignment,
+	group_assignment,
+	name_assignment,
+	security_classification_assignment);
+END_TYPE;
+
+TYPE rule_superseded_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE second_in_minute = REAL;
+WHERE
+	WR1 : { 0 <= SELF <= 60.0 };
+END_TYPE;
+
+TYPE security_classification_item = SELECT (
+	assembly_component_usage,
+	document,
+	document_file,
+	make_from_usage_option,
+	product,
+	product_definition,
+	product_definition_formation,
+	product_definition_usage);
+END_TYPE;
+
+TYPE set_of_reversible_topology_item = SET [0:?] OF reversible_topology_item;
+END_TYPE;
+
+TYPE set_representation_item = SET [1:?] OF representation_item;
+END_TYPE;
+
+TYPE shading_curve_method = ENUMERATION OF (
+	constant_colour,
+	linear_colour );
+END_TYPE;
+
+TYPE shading_surface_method = ENUMERATION OF (
+	constant_shading,
+	colour_shading,
+	dot_shading,
+	normal_shading );
+END_TYPE;
+
+TYPE shape_definition = SELECT (
+	product_definition_shape,
+	shape_aspect,
+	shape_aspect_relationship);
+END_TYPE;
+
+TYPE shell = SELECT (
+	vertex_shell,
+	wire_shell,
+	open_shell,
+	closed_shell);
+END_TYPE;
+
+TYPE si_prefix = ENUMERATION OF (
+	exa,
+	peta,
+	tera,
+	giga,
+	mega,
+	kilo,
+	hecto,
+	deca,
+	deci,
+	centi,
+	milli,
+	micro,
+	nano,
+	pico,
+	femto,
+	atto );
+END_TYPE;
+
+TYPE si_unit_name = ENUMERATION OF (
+	metre,
+	gram,
+	second,
+	ampere,
+	kelvin,
+	mole,
+	candela,
+	radian,
+	steradian,
+	hertz,
+	newton,
+	pascal,
+	joule,
+	watt,
+	coulomb,
+	volt,
+	farad,
+	ohm,
+	siemens,
+	weber,
+	tesla,
+	henry,
+	degree_Celsius,
+	lumen,
+	lux,
+	becquerel,
+	gray,
+	sievert );
+END_TYPE;
+
+TYPE size_select = SELECT (
+	positive_length_measure,
+	measure_with_unit,
+	descriptive_measure);
+END_TYPE;
+
+TYPE sketch_basis_select = SELECT (
+	curve_bounded_surface,
+	face_surface);
+END_TYPE;
+
+TYPE solid_angle_measure = REAL;
+END_TYPE;
+
+TYPE source = ENUMERATION OF (
+	made,
+	bought,
+	not_known );
+END_TYPE;
+
+TYPE source_item = SELECT (
+	identifier,
+	message);
+END_TYPE;
+
+TYPE start_request_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE string_representation_item_select = SELECT (
+	descriptive_representation_item,
+	included_text_block,
+	structured_text_composition);
+END_TYPE;
+
+TYPE style_context_select = SELECT (
+	group,
+	presentation_layer_assignment,
+	presentation_set,
+	representation,
+	representation_item,
+	representation_relationship);
+END_TYPE;
+
+TYPE surface_side = ENUMERATION OF (
+	positive,
+	negative,
+	both );
+END_TYPE;
+
+TYPE surface_side_style_select = SELECT (
+	surface_side_style,
+	pre_defined_surface_side_style);
+END_TYPE;
+
+TYPE surface_style_element_select = SELECT (
+	surface_style_fill_area,
+	surface_style_boundary,
+	surface_style_silhouette,
+	surface_style_segmentation_curve,
+	surface_style_control_grid,
+	surface_style_parameter_line,
+	surface_style_rendering);
+END_TYPE;
+
+TYPE symbol_style_select = SELECT (
+	symbol_colour);
+END_TYPE;
+
+TYPE text = STRING;
+END_TYPE;
+
+TYPE text_alignment = label;
+END_TYPE;
+
+TYPE text_delineation = label;
+END_TYPE;
+
+TYPE text_or_character = SELECT (
+	annotation_text,
+	annotation_text_character,
+	composite_text,
+	text_literal);
+END_TYPE;
+
+TYPE text_path = ENUMERATION OF (
+	left,
+	right,
+	up,
+	down );
+END_TYPE;
+
+TYPE text_string_representation_item = SELECT (
+	text_literal,
+	annotation_text,
+	annotation_text_character,
+	composite_text,
+	axis2_placement);
+END_TYPE;
+
+TYPE thermodynamic_temperature_measure = REAL;
+END_TYPE;
+
+TYPE time_interval_item = SELECT (
+	action,
+	time_interval_based_effectivity);
+END_TYPE;
+
+TYPE time_measure = REAL;
+END_TYPE;
+
+TYPE tolerance_method_definition = SELECT (
+	tolerance_value,
+	limits_and_fits);
+END_TYPE;
+
+TYPE transformation = SELECT (
+	item_defined_transformation,
+	functionally_defined_transformation);
+END_TYPE;
+
+TYPE transition_code = ENUMERATION OF (
+	discontinuous,
+	continuous,
+	cont_same_gradient,
+	cont_same_gradient_same_curvature );
+END_TYPE;
+
+TYPE trim_condition_select = SELECT (
+	length_measure,
+	plane_angle_measure,
+	generalized_surface_select,
+	solid_model);
+END_TYPE;
+
+TYPE trim_intent = ENUMERATION OF (
+	blind,
+	offset,
+	through_all,
+	unspecified,
+	up_to_next );
+END_TYPE;
+
+TYPE trimming_preference = ENUMERATION OF (
+	cartesian,
+	parameter,
+	unspecified );
+END_TYPE;
+
+TYPE trimming_select = SELECT (
+	cartesian_point,
+	parameter_value);
+END_TYPE;
+
+TYPE u_direction_count = INTEGER;
+WHERE
+	WR1 : SELF > 1;
+END_TYPE;
+
+TYPE unit = SELECT (
+	derived_unit,
+	named_unit);
+END_TYPE;
+
+TYPE v_direction_count = INTEGER;
+WHERE
+	WR1 : SELF > 1;
+END_TYPE;
+
+TYPE value_qualifier = SELECT (
+	precision_qualifier,
+	type_qualifier,
+	uncertainty_qualifier);
+END_TYPE;
+
+TYPE vector_or_direction = SELECT (
+	vector,
+	direction);
+END_TYPE;
+
+TYPE velocity_measure = REAL;
+END_TYPE;
+
+TYPE volume_measure = REAL;
+END_TYPE;
+
+TYPE week_in_year_number = INTEGER;
+WHERE
+	WR1 : { 1 <= SELF <= 53 };
+END_TYPE;
+
+TYPE work_item = SELECT (
+	product_definition_formation);
+END_TYPE;
+
+TYPE year_number = INTEGER;
+END_TYPE;
+
+ENTITY absorbed_dose_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABSORBED_DOSE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY absorbed_dose_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.gray);
+END_ENTITY;
+
+
+ENTITY abstract_variable
+	SUBTYPE OF (property_definition, property_definition_representation, representation, representation_item);
+END_ENTITY;
+
+
+ENTITY acceleration_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACCELERATION_UNIT' IN TYPEOF (SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY acceleration_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+       dimensional_exponents ( 1.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY action;
+	name : label;
+	description : OPTIONAL text;
+	chosen_method : action_method;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_action : action;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_directive;
+	name : label;
+	description : OPTIONAL text;
+	analysis : text;
+	comment : text;
+	requests : SET [1:?] OF versioned_action_request;
+END_ENTITY;
+
+
+ENTITY action_method;
+	name : label;
+	description : OPTIONAL text;
+	consequence : text;
+	purpose : text;
+END_ENTITY;
+
+
+ENTITY action_method_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_action_method : action_method;
+	role : action_method_role;
+END_ENTITY;
+
+
+ENTITY action_method_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_method : action_method;
+	related_method : action_method;
+END_ENTITY;
+
+
+ENTITY action_method_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY action_property;
+	name : label;
+	description : text;
+	definition : characterized_action_definition;
+END_ENTITY;
+
+
+ENTITY action_property_representation;
+	name : label;
+	description : text;
+	property : action_property;
+	representation : representation;
+END_ENTITY;
+
+
+ENTITY action_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_action : action;
+	related_action : action;
+END_ENTITY;
+
+
+ENTITY action_request_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_action_request : versioned_action_request;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_request_solution;
+	method : action_method;
+	request : versioned_action_request;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY action_request_status;
+	status : label;
+	assigned_request : versioned_action_request;
+END_ENTITY;
+
+
+ENTITY action_status;
+	status : label;
+	assigned_action : executed_action;
+END_ENTITY;
+
+
+ENTITY address;
+	internal_location : OPTIONAL label;
+	street_number : OPTIONAL label;
+	street : OPTIONAL label;
+	postal_box : OPTIONAL label;
+	town : OPTIONAL label;
+	region : OPTIONAL label;
+	postal_code : OPTIONAL label;
+	country : OPTIONAL label;
+	facsimile_number : OPTIONAL label;
+	telephone_number : OPTIONAL label;
+	electronic_mail_address : OPTIONAL label;
+	telex_number : OPTIONAL label;
+DERIVE
+	name : label := get_name_value(SELF);
+	url : identifier := get_id_value(SELF);
+WHERE
+	WR1 : EXISTS(internal_location) OR EXISTS(street_number) OR EXISTS(street) OR EXISTS(postal_box) OR EXISTS(town) OR EXISTS(region) OR EXISTS(postal_code) OR EXISTS(country) OR EXISTS(facsimile_number) OR EXISTS(telephone_number) OR EXISTS(electronic_mail_address) OR EXISTS(telex_number);
+END_ENTITY;
+
+
+ENTITY advanced_brep_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) > 0;
+	WR3 : SIZEOF ( 
+QUERY ( msb <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* msb_shells(msb)| NOT ( SIZEOF ( 
+QUERY ( fcs <* csh\connected_face_set.cfs_faces| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fcs)) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( msb <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF (it)) )| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF (msb\manifold_solid_brep.outer)) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( brv <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BREP_WITH_VOIDS' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* brv\brep_with_voids.voids| csh\oriented_closed_shell.orientation )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_BREP_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+END_ENTITY;
+
+
+ENTITY advanced_face
+	SUBTYPE OF (face_surface);
+WHERE
+	WR1 : SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' ] * TYPEOF (face_geometry)) = 1;
+	WR2 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (oe\oriented_edge.edge_element)) )) = 0) )) = 0;
+	WR3 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' ] * TYPEOF (oe.edge_element\edge_curve.edge_geometry)) = 1) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| NOT ((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (oe\edge.edge_start)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (oe\edge.edge_start\vertex_point.vertex_geometry))) AND (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (oe\edge.edge_end)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (oe\edge.edge_end\vertex_point.vertex_geometry)))) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_PATH' IN TYPEOF (elp_fbnds.bound)) )) = 0;
+	WR6 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (face_geometry)) OR ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' ] * TYPEOF (face_geometry\swept_surface.swept_curve)) = 1);
+	WR7 : SIZEOF ( 
+QUERY ( vlp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) )| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex\vertex_point.vertex_geometry))) )) = 0;
+	WR8 : SIZEOF ( 
+QUERY ( bnd <* bounds| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' ] * TYPEOF (bnd.bound)) = 1) )) = 0;
+	WR9 : SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF (oe\oriented_edge.edge_element\edge_curve.edge_geometry)) AND NOT ( SIZEOF ( 
+QUERY ( sc_ag <* oe.edge_element\edge_curve.edge_geometry\surface_curve.associated_geometry| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF (sc_ag)) )) = 0) )) = 0) )) = 0;
+	WR10 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (face_geometry)) OR (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (face_geometry\swept_surface.swept_curve)) OR ( SIZEOF (face_geometry\swept_surface.swept_curve\polyline.points) >= 3))) AND ( SIZEOF ( 
+QUERY ( elp_fbnds <* 
+QUERY ( bnds <* bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) )| NOT ( SIZEOF ( 
+QUERY ( oe <* elp_fbnds.bound\path.edge_list| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (oe\oriented_edge.edge_element\edge_curve.edge_geometry)) AND NOT ( SIZEOF (oe\oriented_edge.edge_element\edge_curve.edge_geometry\polyline.points) >= 3) )) = 0) )) = 0);
+END_ENTITY;
+
+
+ENTITY alternate_product_relationship;
+	name : label;
+	definition : OPTIONAL text;
+	alternate : product;
+	base : product;
+	basis : text;
+UNIQUE
+	UR1 : alternate, base;
+WHERE
+	WR1 : alternate :<>: base;
+END_ENTITY;
+
+
+ENTITY amount_of_substance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AMOUNT_OF_SUBSTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY amount_of_substance_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 1.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY angle_direction_reference
+	SUBTYPE OF (representation_item_relationship, geometric_representation_item);
+	SELF\representation_item_relationship.related_representation_item : angle_direction_reference_select;
+	SELF\representation_item_relationship.relating_representation_item : orientation_basis_select;
+WHERE
+	WR1 : ((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_PATH' IN TYPEOF(related_representation_item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MIN_AND_MAJOR_PLY_ORIENTATION_BASIS' IN TYPEOF(relating_representation_item))) 
+        OR
+		(NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_PATH' IN TYPEOF(related_representation_item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' IN TYPEOF(relating_representation_item))));
+END_ENTITY;
+
+
+ENTITY angular_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY angular_location
+	SUBTYPE OF (dimensional_location);
+	angle_selection : angle_relator;
+END_ENTITY;
+
+
+ENTITY angular_size
+	SUBTYPE OF (dimensional_size);
+	angle_selection : angle_relator;
+END_ENTITY;
+
+
+ENTITY angularity_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) < 3;
+END_ENTITY;
+
+
+ENTITY annotation_curve_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	SELF\styled_item.item : curve;
+END_ENTITY;
+
+
+ENTITY annotation_fill_area
+	SUBTYPE OF (geometric_representation_item);
+	boundaries : SET [1:?] OF curve;
+WHERE
+	WR1 : (SELF\geometric_representation_item.dim = 3) OR (SIZEOF (QUERY (curve <* SELF.boundaries |
+          NOT (
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE' IN TYPEOF (curve)) OR 
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE' IN TYPEOF (curve)) OR 
+              ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (curve)) 
+                   AND (curve\b_spline_curve.closed_curve = TRUE) ) OR 
+              ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF (curve)) 
+                   AND (curve\composite_curve.closed_curve = TRUE) ) OR 
+              ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (curve)) 
+                   AND (curve\polyline.points[LOINDEX(curve\polyline.points)] = 
+                        curve\polyline.points[HIINDEX(curve\polyline.points)]) )
+              ) )) = 0);
+END_ENTITY;
+
+
+ENTITY annotation_fill_area_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	fill_style_target : point;
+	SELF\styled_item.item : annotation_fill_area;
+END_ENTITY;
+
+
+ENTITY annotation_occurrence
+	SUPERTYPE OF (ONEOF (annotation_curve_occurrence, annotation_fill_area_occurrence, annotation_text_occurrence, annotation_symbol_occurrence))
+	SUBTYPE OF (styled_item);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+             TYPEOF (SELF);
+	WR2 : SIZEOF (QUERY (reps <* using_representations(SELF) | 
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_REPRESENTATION_SELECT' IN TYPEOF(reps)))) = 0;
+END_ENTITY;
+
+
+ENTITY annotation_occurrence_associativity
+	SUBTYPE OF (annotation_occurrence_relationship);
+WHERE
+	WR1 : SIZEOF (TYPEOF (SELF.related_annotation_occurrence) *
+          ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE',
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE',
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE']) = 1;
+END_ENTITY;
+
+
+ENTITY annotation_occurrence_relationship;
+	name : label;
+	description : text;
+	relating_annotation_occurrence : annotation_occurrence;
+	related_annotation_occurrence : annotation_occurrence;
+END_ENTITY;
+
+
+ENTITY annotation_plane
+	SUBTYPE OF (annotation_occurrence, geometric_representation_item);
+	elements : OPTIONAL SET [1:?] OF annotation_plane_element;
+	SELF\styled_item.item : plane_or_planar_box;
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 3;
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PLANAR_BOX' IN TYPEOF(SELF\styled_item.item)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'AXIS2_PLACEMENT_3D' IN TYPEOF(SELF\styled_item.item\planar_box.placement));
+	WR3 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PLANAR_BOX' IN TYPEOF(SELF\styled_item.item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'CURVE_STYLE' IN TYPEOF(SELF\styled_item.styles[1]\presentation_style_assignment.styles[1]))) OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PLANE' IN TYPEOF(SELF\styled_item.item)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'FILL_AREA_STYLE' IN TYPEOF(SELF\styled_item.styles[1]\presentation_style_assignment.styles[1])));
+	WR4 : (SIZEOF(SELF\styled_item.styles) = 1) AND
+        (SIZEOF(SELF\styled_item.styles[1]\presentation_style_assignment.styles) = 1);
+END_ENTITY;
+
+
+ENTITY annotation_subfigure_occurrence
+	SUBTYPE OF (annotation_symbol_occurrence);
+WHERE
+	WR1 : SIZEOF (QUERY (sty <* SELF.styles |
+         NOT (SIZEOF (sty.styles) = 1)
+       )) = 0;
+	WR2 : SIZEOF (QUERY (sty <* SELF.styles |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NULL_STYLE'
+               IN TYPEOF (sty.styles[1]))       ))=0;
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL'
+           IN TYPEOF (SELF.item));
+	WR4 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_SUBFIGURE_REPRESENTATION'
+           IN TYPEOF
+           (SELF.item\mapped_item.mapping_source.mapped_representation));
+END_ENTITY;
+
+
+ENTITY annotation_symbol
+	SUBTYPE OF (mapped_item);
+	SELF\mapped_item.mapping_source : symbol_representation_map;
+	SELF\mapped_item.mapping_target : symbol_target;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+          TYPEOF (SELF);
+END_ENTITY;
+
+
+ENTITY annotation_symbol_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	SELF\styled_item.item : annotation_symbol_occurrence_item;
+END_ENTITY;
+
+
+ENTITY annotation_text
+	SUBTYPE OF (mapped_item);
+	SELF\mapped_item.mapping_target : axis2_placement;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STRING_REPRESENTATION' IN
+        TYPEOF( SELF\mapped_item.mapping_source.mapped_representation);
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+        TYPEOF( SELF);
+END_ENTITY;
+
+
+ENTITY annotation_text_character
+	SUBTYPE OF (mapped_item);
+	alignment : text_alignment;
+	SELF\mapped_item.mapping_target : axis2_placement;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTER_GLYPH_SYMBOL' IN
+         TYPEOF (SELF\mapped_item.mapping_source.mapped_representation);
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM' IN
+         TYPEOF (SELF);
+END_ENTITY;
+
+
+ENTITY annotation_text_occurrence
+	SUBTYPE OF (annotation_occurrence);
+	SELF\styled_item.item : annotation_text_occurrence_item;
+END_ENTITY;
+
+
+ENTITY apex
+	SUBTYPE OF (derived_shape_aspect);
+END_ENTITY;
+
+
+ENTITY application_context;
+	application : label;
+DERIVE
+	description : text := get_description_value(SELF);
+	id : identifier := get_id_value(SELF);
+INVERSE
+	context_elements: SET [1:?] OF application_context_element FOR frame_of_reference;
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY application_context_element
+	SUPERTYPE OF (ONEOF (product_concept_context, product_context, product_definition_context));
+	name : label;
+	frame_of_reference : application_context;
+END_ENTITY;
+
+
+ENTITY application_protocol_definition;
+	status : label;
+	application_interpreted_model_schema_name : label;
+	application_protocol_year : year_number;
+	application : application_context;
+END_ENTITY;
+
+
+ENTITY applied_action_assignment
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF action_items;
+END_ENTITY;
+
+
+ENTITY applied_action_method_assignment
+	SUBTYPE OF (action_method_assignment);
+	items : SET [1:?] OF action_method_items;
+END_ENTITY;
+
+
+ENTITY applied_action_request_assignment
+	SUBTYPE OF (action_request_assignment);
+	items : SET [1:?] OF action_request_item;
+END_ENTITY;
+
+
+ENTITY applied_approval_assignment
+	SUBTYPE OF (approval_assignment);
+	items : SET [1:?] OF approval_item;
+END_ENTITY;
+
+
+ENTITY applied_attribute_classification_assignment
+	SUBTYPE OF (attribute_classification_assignment);
+	items : SET [1:?] OF attribute_classification_item;
+	SELF\attribute_classification_assignment.assigned_class : class;
+END_ENTITY;
+
+
+ENTITY applied_certification_assignment
+	SUBTYPE OF (certification_assignment);
+	items : SET [1:?] OF certification_item;
+END_ENTITY;
+
+
+ENTITY applied_classification_assignment
+	SUBTYPE OF (classification_assignment);
+	items : SET [1:?] OF classification_item;
+END_ENTITY;
+
+
+ENTITY applied_contract_assignment
+	SUBTYPE OF (contract_assignment);
+	items : SET [1:?] OF contract_item;
+END_ENTITY;
+
+
+ENTITY applied_date_and_time_assignment
+	SUBTYPE OF (date_and_time_assignment);
+	items : SET [1:?] OF date_and_time_item;
+END_ENTITY;
+
+
+ENTITY applied_date_assignment
+	SUBTYPE OF (date_assignment);
+	items : SET [1:?] OF date_item;
+END_ENTITY;
+
+
+ENTITY applied_document_reference
+	SUBTYPE OF (document_reference);
+	items : SET [1:?] OF document_reference_item;
+END_ENTITY;
+
+
+ENTITY applied_document_usage_constraint_assignment
+	SUBTYPE OF (document_usage_constraint_assignment);
+	items : SET [1:?] OF document_reference_item;
+END_ENTITY;
+
+
+ENTITY applied_effectivity_assignment
+	SUBTYPE OF (effectivity_assignment);
+	items : SET [1:?] OF effectivity_item;
+END_ENTITY;
+
+
+ENTITY applied_event_occurrence_assignment
+	SUBTYPE OF (event_occurrence_assignment);
+	items : SET [1:?] OF event_occurrence_item;
+END_ENTITY;
+
+
+ENTITY applied_external_identification_assignment
+	SUBTYPE OF (external_identification_assignment);
+	items : SET [1:?] OF external_identification_item;
+END_ENTITY;
+
+
+ENTITY applied_group_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:?] OF groupable_item;
+END_ENTITY;
+
+
+ENTITY applied_identification_assignment
+	SUBTYPE OF (identification_assignment);
+	items : SET [1:?] OF identification_item;
+END_ENTITY;
+
+
+ENTITY applied_name_assignment
+	SUBTYPE OF (name_assignment);
+	item : name_item;
+END_ENTITY;
+
+
+ENTITY applied_organization_assignment
+	SUBTYPE OF (organization_assignment);
+	items : SET [1:?] OF organization_item;
+END_ENTITY;
+
+
+ENTITY applied_organizational_project_assignment
+	SUBTYPE OF (organizational_project_assignment);
+	items : SET [1:?] OF project_item;
+END_ENTITY;
+
+
+ENTITY applied_person_and_organization_assignment
+	SUBTYPE OF (person_and_organization_assignment);
+	items : SET [1:?] OF person_and_organization_item;
+END_ENTITY;
+
+
+ENTITY applied_presented_item
+	SUBTYPE OF (presented_item);
+	items : SET [1:?] OF presented_item_select;
+END_ENTITY;
+
+
+ENTITY applied_security_classification_assignment
+	SUBTYPE OF (security_classification_assignment);
+	items : SET [1:?] OF security_classification_item;
+END_ENTITY;
+
+
+ENTITY applied_time_interval_assignment
+	SUBTYPE OF (time_interval_assignment);
+	items : SET [0:?] OF time_interval_item;
+END_ENTITY;
+
+
+ENTITY applied_usage_right
+	SUBTYPE OF (applied_action_assignment);
+	SELF\applied_action_assignment.items : SET [1:?] OF ir_usage_item;
+END_ENTITY;
+
+
+ENTITY approval;
+	status : approval_status;
+	level : label;
+END_ENTITY;
+
+
+ENTITY approval_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_approval : approval;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY approval_date_time;
+	date_time : date_time_select;
+	dated_approval : approval;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY approval_person_organization;
+	person_organization : person_organization_select;
+	authorized_approval : approval;
+	role : approval_role;
+END_ENTITY;
+
+
+ENTITY approval_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_approval : approval;
+	related_approval : approval;
+END_ENTITY;
+
+
+ENTITY approval_role;
+	role : label;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY approval_status;
+	name : label;
+END_ENTITY;
+
+
+ENTITY area_in_set;
+	area : presentation_area;
+	in_set : presentation_set;
+END_ENTITY;
+
+
+ENTITY area_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AREA_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY area_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+      dimensional_exponents ( 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY assembly_component_usage
+	SUPERTYPE OF (ONEOF (next_assembly_usage_occurrence, specified_higher_usage_occurrence, promissory_usage_occurrence))
+	SUBTYPE OF (product_definition_usage);
+	reference_designator : OPTIONAL identifier;
+END_ENTITY;
+
+
+ENTITY assembly_component_usage_substitute;
+	name : label;
+	definition : OPTIONAL text;
+	base : assembly_component_usage;
+	substitute : assembly_component_usage;
+UNIQUE
+	UR1 : base, substitute;
+WHERE
+	WR1 : base.relating_product_definition :=:
+       substitute.relating_product_definition;
+	WR2 : base :<>: substitute;
+END_ENTITY;
+
+
+ENTITY assigned_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition;
+	SELF\group_assignment.assigned_group : requirement_assignment;
+END_ENTITY;
+
+
+ENTITY atomic_formula
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY attribute_assertion
+	SUBTYPE OF (fact_type, property_definition_representation, representation);
+END_ENTITY;
+
+
+ENTITY attribute_classification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_class : group;
+	attribute_name : label;
+	role : classification_role;
+END_ENTITY;
+
+
+ENTITY attribute_language_assignment
+	SUBTYPE OF (attribute_classification_assignment);
+	items : SET [1:?] OF attribute_language_item;
+	SELF\attribute_classification_assignment.assigned_class : language;
+WHERE
+	WR1 : SELF\attribute_classification_assignment.role.name IN ['primary', 'translated'];
+	WR2 : SELF\attribute_classification_assignment.attribute_name<> '';
+END_ENTITY;
+
+
+ENTITY attribute_value_assignment
+	ABSTRACT SUPERTYPE;
+	attribute_name : label;
+	attribute_value : attribute_type;
+	role : attribute_value_role;
+END_ENTITY;
+
+
+ENTITY attribute_value_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY auxiliary_geometric_representation_item
+	SUBTYPE OF (geometric_representation_item, variational_representation_item);
+END_ENTITY;
+
+
+ENTITY axis1_placement
+	SUBTYPE OF (placement);
+	axis : OPTIONAL direction;
+DERIVE
+	z : direction := NVL(normalise(axis), dummy_gri ||
+                                 direction([0.0,0.0,1.0]));
+WHERE
+	WR1 : SELF\geometric_representation_item.dim  = 3;
+END_ENTITY;
+
+
+ENTITY axis2_placement_2d
+	SUBTYPE OF (placement);
+	ref_direction : OPTIONAL direction;
+DERIVE
+	p : LIST [2:2] OF direction := build_2axes(ref_direction);
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 2;
+END_ENTITY;
+
+
+ENTITY axis2_placement_3d
+	SUBTYPE OF (placement);
+	axis : OPTIONAL direction;
+	ref_direction : OPTIONAL direction;
+DERIVE
+	p : LIST [3:3] OF direction := build_axes(axis,ref_direction);
+WHERE
+	WR1 : SELF\placement.location.dim = 3;
+	WR2 : (NOT (EXISTS (axis))) OR (axis.dim = 3);
+	WR3 : (NOT (EXISTS (ref_direction))) OR (ref_direction.dim = 3);
+	WR4 : (NOT (EXISTS (axis))) OR (NOT (EXISTS (ref_direction))) OR
+          (cross_product(axis,ref_direction).magnitude > 0.0);
+END_ENTITY;
+
+
+ENTITY b_spline_curve
+	SUPERTYPE OF ((ONEOF (uniform_curve, b_spline_curve_with_knots, quasi_uniform_curve, bezier_curve) ANDOR rational_b_spline_curve))
+	SUBTYPE OF (bounded_curve);
+	degree : INTEGER;
+	control_points_list : LIST [2:?] OF cartesian_point;
+	curve_form : b_spline_curve_form;
+	closed_curve : LOGICAL;
+	self_intersect : LOGICAL;
+DERIVE
+	control_points : ARRAY [0:upper_index_on_control_points] OF cartesian_point := list_to_array(control_points_list,0,
+                                             upper_index_on_control_points);
+	upper_index_on_control_points : INTEGER := (SIZEOF(control_points_list) - 1);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.UNIFORM_CURVE' IN TYPEOF(self)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.QUASI_UNIFORM_CURVE' IN TYPEOF(self)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BEZIER_CURVE' IN TYPEOF(self)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE_WITH_KNOTS' IN TYPEOF(self));
+END_ENTITY;
+
+
+ENTITY b_spline_curve_with_knots
+	SUBTYPE OF (b_spline_curve);
+	knot_multiplicities : LIST [2:?] OF INTEGER;
+	knots : LIST [2:?] OF parameter_value;
+	knot_spec : knot_type;
+DERIVE
+	upper_index_on_knots : INTEGER := SIZEOF(knots);
+WHERE
+	WR1 : constraints_param_b_spline(degree, upper_index_on_knots,
+                               upper_index_on_control_points,
+                               knot_multiplicities, knots);
+	WR2 : SIZEOF(knot_multiplicities) = upper_index_on_knots;
+END_ENTITY;
+
+
+ENTITY b_spline_surface
+	SUPERTYPE OF ((ONEOF (b_spline_surface_with_knots, uniform_surface, quasi_uniform_surface, bezier_surface) ANDOR rational_b_spline_surface))
+	SUBTYPE OF (bounded_surface);
+	u_degree : INTEGER;
+	v_degree : INTEGER;
+	control_points_list : LIST [2:?] OF LIST [2:?] OF cartesian_point;
+	surface_form : b_spline_surface_form;
+	u_closed : LOGICAL;
+	v_closed : LOGICAL;
+	self_intersect : LOGICAL;
+DERIVE
+	control_points : ARRAY [0:u_upper] OF ARRAY [0:v_upper] OF cartesian_point := make_array_of_array(control_points_list,
+                                              0,u_upper,0,v_upper);
+	u_upper : INTEGER := SIZEOF(control_points_list) - 1;
+	v_upper : INTEGER := SIZEOF(control_points_list[1]) - 1;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.UNIFORM_SURFACE' IN TYPEOF(SELF)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.QUASI_UNIFORM_SURFACE' IN TYPEOF(SELF)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BEZIER_SURFACE' IN TYPEOF(SELF)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE_WITH_KNOTS' IN TYPEOF(SELF));
+END_ENTITY;
+
+
+ENTITY b_spline_surface_with_knots
+	SUBTYPE OF (b_spline_surface);
+	u_multiplicities : LIST [2:?] OF INTEGER;
+	v_multiplicities : LIST [2:?] OF INTEGER;
+	u_knots : LIST [2:?] OF parameter_value;
+	v_knots : LIST [2:?] OF parameter_value;
+	knot_spec : knot_type;
+DERIVE
+	knot_u_upper : INTEGER := SIZEOF(u_knots);
+	knot_v_upper : INTEGER := SIZEOF(v_knots);
+WHERE
+	WR1 : constraints_param_b_spline(SELF\b_spline_surface.u_degree,
+                   knot_u_upper, SELF\b_spline_surface.u_upper,
+                               u_multiplicities, u_knots);
+	WR2 : constraints_param_b_spline(SELF\b_spline_surface.v_degree,
+                   knot_v_upper, SELF\b_spline_surface.v_upper,
+                               v_multiplicities, v_knots);
+	WR3 : SIZEOF(u_multiplicities) = knot_u_upper;
+	WR4 : SIZEOF(v_multiplicities) = knot_v_upper;
+END_ENTITY;
+
+
+ENTITY back_chaining_rule
+	SUBTYPE OF (rule_definition);
+END_ENTITY;
+
+
+ENTITY back_chaining_rule_body
+	SUBTYPE OF (property_definition, property_definition_representation, representation);
+END_ENTITY;
+
+
+ENTITY background_colour
+	SUBTYPE OF (colour);
+	presentation : area_or_view;
+UNIQUE
+	UR1 : presentation;
+END_ENTITY;
+
+
+ENTITY beveled_sheet_representation
+	SUBTYPE OF (shape_representation);
+END_ENTITY;
+
+
+ENTITY bezier_curve
+	SUBTYPE OF (b_spline_curve);
+END_ENTITY;
+
+
+ENTITY bezier_surface
+	SUBTYPE OF (b_spline_surface);
+END_ENTITY;
+
+
+ENTITY binary_generic_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (generic_expression);
+	operands : LIST [2:2] OF generic_expression;
+END_ENTITY;
+
+
+ENTITY binary_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, binary_generic_expression);
+	SELF\binary_generic_expression.operands : LIST [2:2] OF numeric_expression;
+END_ENTITY;
+
+
+ENTITY binary_representation_item
+	SUBTYPE OF (representation_item);
+	binary_value : BINARY;
+END_ENTITY;
+
+
+ENTITY block
+	SUBTYPE OF (geometric_representation_item);
+	position : axis2_placement_3d;
+	x : positive_length_measure;
+	y : positive_length_measure;
+	z : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY boolean_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (simple_boolean_expression, multiple_arity_boolean_expression, comparison_expression, interval_expression))
+	SUBTYPE OF (expression);
+END_ENTITY;
+
+
+ENTITY boolean_literal
+	SUBTYPE OF (simple_boolean_expression, generic_literal);
+	the_value : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY boolean_representation_item
+	SUBTYPE OF (representation_item, boolean_literal);
+END_ENTITY;
+
+
+ENTITY boolean_result
+	SUBTYPE OF (geometric_representation_item);
+	operator : boolean_operator;
+	first_operand : boolean_operand;
+	second_operand : boolean_operand;
+END_ENTITY;
+
+
+ENTITY boundary_curve
+	SUBTYPE OF (composite_curve_on_surface);
+WHERE
+	WR1 : SELF\composite_curve.closed_curve;
+END_ENTITY;
+
+
+ENTITY bounded_curve
+	SUPERTYPE OF (ONEOF (polyline, b_spline_curve, trimmed_curve, bounded_pcurve, bounded_surface_curve, composite_curve))
+	SUBTYPE OF (curve);
+END_ENTITY;
+
+
+ENTITY bounded_pcurve
+	SUBTYPE OF (pcurve, bounded_curve);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE' IN
+                   TYPEOF(SELF\pcurve.reference_to_curve.items[1]));
+END_ENTITY;
+
+
+ENTITY bounded_surface
+	SUPERTYPE OF (ONEOF (b_spline_surface, rectangular_trimmed_surface, curve_bounded_surface, rectangular_composite_surface))
+	SUBTYPE OF (surface);
+END_ENTITY;
+
+
+ENTITY bounded_surface_curve
+	SUBTYPE OF (surface_curve, bounded_curve);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE' IN
+             TYPEOF(SELF\surface_curve.curve_3d));
+END_ENTITY;
+
+
+ENTITY box_domain
+	SUBTYPE OF (founded_item);
+	corner : cartesian_point;
+	xlength : positive_length_measure;
+	ylength : positive_length_measure;
+	zlength : positive_length_measure;
+WHERE
+	WR1 : SIZEOF(QUERY(item <* USEDIN(SELF,'')|
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOXED_HALF_SPACE'
+                    IN TYPEOF(item)))) = 0;
+END_ENTITY;
+
+
+ENTITY boxed_half_space
+	SUBTYPE OF (half_space_solid);
+	enclosure : box_domain;
+END_ENTITY;
+
+
+ENTITY breakdown_context
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY breakdown_element_group_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition_or_breakdown_element_usage;
+	SELF\group_assignment.assigned_group : product_definition_element_relationship;
+END_ENTITY;
+
+
+ENTITY breakdown_element_realization
+	SUBTYPE OF (characterized_object, product_definition_element_relationship);
+END_ENTITY;
+
+
+ENTITY breakdown_element_usage
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY breakdown_of
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY brep_with_voids
+	SUBTYPE OF (manifold_solid_brep);
+	voids : SET [1:?] OF oriented_closed_shell;
+END_ENTITY;
+
+
+ENTITY bytes_representation_item
+	SUBTYPE OF (binary_representation_item);
+DERIVE
+	no_of_bytes : INTEGER := BLENGTH(SELF\binary_representation_item.binary_value) DIV 8;
+WHERE
+	WR1 : BLENGTH(SELF\binary_representation_item.binary_value) MOD 8 = 0;
+END_ENTITY;
+
+
+ENTITY calendar_date
+	SUBTYPE OF (date);
+	day_component : day_in_month_number;
+	month_component : month_in_year_number;
+WHERE
+	WR1 : valid_calendar_date (SELF);
+END_ENTITY;
+
+
+ENTITY camera_image
+	SUBTYPE OF (mapped_item);
+	SELF\mapped_item.mapping_source : camera_usage;
+	SELF\mapped_item.mapping_target : planar_box;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_ITEM'
+        IN TYPEOF (SELF);
+END_ENTITY;
+
+
+ENTITY camera_image_3d_with_scale
+	SUBTYPE OF (camera_image);
+DERIVE
+	scale : positive_ratio_measure := ((SELF\mapped_item.mapping_target\
+           planar_extent.size_in_x) / (SELF\mapped_item.mapping_source.
+           mapping_origin\camera_model_d3.perspective_of_volume.view_window.
+           size_in_x));
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAMERA_MODEL_D3'
+         IN TYPEOF (SELF\mapped_item.mapping_source.mapping_origin));
+	WR2 : aspect_ratio(SELF\mapped_item.mapping_target) =
+           aspect_ratio(SELF\mapped_item.mapping_source.mapping_origin\
+           camera_model_d3.perspective_of_volume.view_window);
+	WR3 : SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.front_plane_clipping
+           AND
+           SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.view_volume_sides_clipping;
+	WR4 : (SELF\mapped_item.mapping_target\planar_extent.size_in_x > 0)
+           AND
+           (SELF\mapped_item.mapping_target\planar_extent.size_in_y > 0);
+	WR5 : (SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.view_window.size_in_x > 0)
+           AND
+           (SELF\mapped_item.mapping_source.mapping_origin\camera_model_d3.
+           perspective_of_volume.view_window.size_in_y > 0);
+	WR6 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+            'AXIS2_PLACEMENT_2D' IN TYPEOF (SELF\mapped_item.
+           mapping_target\planar_box.placement))
+           AND NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+           'AXIS2_PLACEMENT_3D' IN TYPEOF (SELF\mapped_item.
+           mapping_target\planar_box.placement));
+END_ENTITY;
+
+
+ENTITY camera_model
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (geometric_representation_item);
+WHERE
+	WR1 : (SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'ITEM_DEFINED_TRANSFORMATION.' +
+                                  'TRANSFORM_ITEM_1')) +
+            SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'REPRESENTATION_MAP.MAPPING_ORIGIN'))
+            ) > 0;
+	WR2 : SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                              'STYLED_ITEM.ITEM')) = 0;
+END_ENTITY;
+
+
+ENTITY camera_model_d3
+	SUBTYPE OF (camera_model);
+	view_reference_system : axis2_placement_3d;
+	perspective_of_volume : view_volume;
+WHERE
+	WR1 : (dot_product (SELF.view_reference_system.p[3],
+           SELF.perspective_of_volume.view_window.placement.p[3]) = 1.0)
+           AND
+           (SELF.view_reference_system.location.coordinates[3] =
+           SELF.perspective_of_volume.view_window.
+             placement.location.coordinates[3]);
+	WR2 : SELF\geometric_representation_item.dim = 3;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_multi_clipping
+	SUBTYPE OF (camera_model_d3);
+	shape_clipping : SET [1:?] OF camera_model_d3_multi_clipping_interection_select;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_multi_clipping_intersection
+	SUBTYPE OF (geometric_representation_item);
+	shape_clipping : SET [2:?] OF camera_model_d3_multi_clipping_interection_select;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_multi_clipping_union
+	SUBTYPE OF (geometric_representation_item);
+	shape_clipping : SET [2:?] OF camera_model_d3_multi_clipping_union_select;
+END_ENTITY;
+
+
+ENTITY camera_model_d3_with_hlhsr
+	SUBTYPE OF (camera_model_d3);
+	hidden_line_surface_removal : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY camera_model_with_light_sources
+	SUBTYPE OF (camera_model_d3);
+	sources : SET [1:?] OF light_source;
+END_ENTITY;
+
+
+ENTITY camera_usage
+	SUBTYPE OF (representation_map);
+	SELF\representation_map.mapping_origin : camera_model;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_REPRESENTATION'
+          IN TYPEOF(SELF\representation_map.mapped_representation));
+END_ENTITY;
+
+
+ENTITY capacitance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAPACITANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY capacitance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.farad);
+END_ENTITY;
+
+
+ENTITY cartesian_point
+	SUBTYPE OF (point);
+	coordinates : LIST [1:3] OF length_measure;
+END_ENTITY;
+
+
+ENTITY cartesian_transformation_operator
+	SUPERTYPE OF (ONEOF (cartesian_transformation_operator_2d, cartesian_transformation_operator_3d))
+	SUBTYPE OF (geometric_representation_item, functionally_defined_transformation);
+	axis1 : OPTIONAL direction;
+	axis2 : OPTIONAL direction;
+	local_origin : cartesian_point;
+	scale : OPTIONAL REAL;
+DERIVE
+	scl : REAL := NVL(scale, 1.0);
+WHERE
+	WR1 : scl > 0.0;
+END_ENTITY;
+
+
+ENTITY cartesian_transformation_operator_2d
+	SUBTYPE OF (cartesian_transformation_operator);
+DERIVE
+	u : LIST [2:2] OF direction := base_axis(2,SELF\cartesian_transformation_operator.axis1,
+                   SELF\cartesian_transformation_operator.axis2,?);
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 2;
+END_ENTITY;
+
+
+ENTITY cartesian_transformation_operator_3d
+	SUBTYPE OF (cartesian_transformation_operator);
+	axis3 : OPTIONAL direction;
+DERIVE
+	u : LIST [3:3] OF direction := base_axis(3,SELF\cartesian_transformation_operator.axis1,
+                        SELF\cartesian_transformation_operator.axis2,axis3);
+WHERE
+	WR1 : SELF\geometric_representation_item.dim = 3;
+END_ENTITY;
+
+
+ENTITY cc_design_approval
+	SUBTYPE OF (approval_assignment);
+	items : SET [1:?] OF approved_item;
+END_ENTITY;
+
+
+ENTITY cc_design_certification
+	SUBTYPE OF (certification_assignment);
+	items : SET [1:?] OF certified_item;
+END_ENTITY;
+
+
+ENTITY cc_design_contract
+	SUBTYPE OF (contract_assignment);
+	items : SET [1:?] OF contracted_item;
+END_ENTITY;
+
+
+ENTITY cc_design_date_and_time_assignment
+	SUBTYPE OF (date_and_time_assignment);
+	items : SET [1:?] OF date_time_item;
+END_ENTITY;
+
+
+ENTITY cc_design_person_and_organization_assignment
+	SUBTYPE OF (person_and_organization_assignment);
+	items : SET [1:?] OF cc_person_organization_item;
+WHERE
+	WR1 : cc_design_person_and_organization_correlation(SELF);
+END_ENTITY;
+
+
+ENTITY cc_design_security_classification
+	SUBTYPE OF (security_classification_assignment);
+	items : SET [1:?] OF cc_classified_item;
+END_ENTITY;
+
+
+ENTITY cc_design_specification_reference
+	SUBTYPE OF (document_reference);
+	items : SET [1:?] OF cc_specified_item;
+END_ENTITY;
+
+
+ENTITY celsius_temperature_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMODYNAMIC_TEMPERATURE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY centre_of_symmetry
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF
+        (QUERY(sadr<*SELF\derived_shape_aspect.deriving_relationships|
+    NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMMETRIC_SHAPE_ASPECT'
+     IN TYPEOF
+     (sadr\shape_aspect_relationship.related_shape_aspect))))=0;
+END_ENTITY;
+
+
+ENTITY certification;
+	name : label;
+	purpose : text;
+	kind : certification_type;
+END_ENTITY;
+
+
+ENTITY certification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_certification : certification;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY certification_type;
+	description : label;
+END_ENTITY;
+
+
+ENTITY change
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF work_item;
+END_ENTITY;
+
+
+ENTITY change_request
+	SUBTYPE OF (action_request_assignment);
+	items : SET [1:?] OF change_request_item;
+END_ENTITY;
+
+
+ENTITY character_glyph_font_usage;
+	character : generic_character_glyph_symbol;
+	font : text_font;
+END_ENTITY;
+
+
+ENTITY character_glyph_style_outline
+	SUBTYPE OF (founded_item);
+	outline_style : curve_style;
+END_ENTITY;
+
+
+ENTITY character_glyph_style_stroke
+	SUBTYPE OF (founded_item);
+	stroke_style : curve_style;
+END_ENTITY;
+
+
+ENTITY character_glyph_symbol
+	SUBTYPE OF (generic_character_glyph_symbol);
+	character_box : planar_extent;
+	baseline_ratio : ratio_measure;
+DERIVE
+	box_height : length_measure := character_box.size_in_y;
+WHERE
+	WR1 : {0.0 <= baseline_ratio <= 1.0};
+	WR2 : item_in_context(SELF.character_box, 
+                       SELF\representation.context_of_items);
+	WR3 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE'
+        IN TYPEOF (SELF.box_height);
+END_ENTITY;
+
+
+ENTITY character_glyph_symbol_outline
+	SUBTYPE OF (character_glyph_symbol);
+	outlines : SET [1:?] OF annotation_fill_area;
+WHERE
+	WR1 : SELF.outlines <= SELF\representation.items;
+END_ENTITY;
+
+
+ENTITY character_glyph_symbol_stroke
+	SUBTYPE OF (character_glyph_symbol);
+	strokes : SET [1:?] OF curve;
+WHERE
+	WR1 : SELF.strokes <= SELF\representation.items;
+END_ENTITY;
+
+
+ENTITY characteristic_data_column_header
+	SUBTYPE OF (general_property);
+END_ENTITY;
+
+
+ENTITY characteristic_data_column_header_link
+	SUBTYPE OF (general_property_relationship);
+END_ENTITY;
+
+
+ENTITY characteristic_data_table_header
+	SUBTYPE OF (general_property);
+END_ENTITY;
+
+
+ENTITY characteristic_data_table_header_decomposition
+	SUBTYPE OF (general_property_relationship);
+END_ENTITY;
+
+
+ENTITY characteristic_type
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY characterized_class
+	SUBTYPE OF (characterized_object, class);
+END_ENTITY;
+
+
+ENTITY characterized_object;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY circle
+	SUBTYPE OF (conic);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY circular_runout_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 2;
+END_ENTITY;
+
+
+ENTITY class
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY class_by_extension
+	SUBTYPE OF (class);
+END_ENTITY;
+
+
+ENTITY class_by_intension
+	SUBTYPE OF (class);
+END_ENTITY;
+
+
+ENTITY class_system
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY class_usage_effectivity_context_assignment
+	SUBTYPE OF (effectivity_context_assignment);
+	items : SET [1:?] OF class_usage_effectivity_context_item;
+WHERE
+	WR1 : SELF.role.name = 'class usage influence';
+	WR2 : SIZEOF( QUERY( i <* SELF.items | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) )) = 0;
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLIED_EFFECTIVITY_ASSIGNMENT' IN TYPEOF(SELF.assigned_effectivity_assignment)) AND 
+        (SIZEOF(TYPEOF(SELF.assigned_effectivity_assignment.assigned_effectivity) ) = 1) AND 
+        (SELF.assigned_effectivity_assignment.assigned_effectivity.id = 'class usage') AND 
+        (SIZEOF( QUERY( i <* SELF.assigned_effectivity_assignment\applied_effectivity_assignment.items | 
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CONCEPT_FEATURE_CATEGORY_USAGE' IN TYPEOF(i)) )) = 0);
+END_ENTITY;
+
+
+ENTITY classification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_class : group;
+	role : classification_role;
+END_ENTITY;
+
+
+ENTITY classification_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY closed_shell
+	SUBTYPE OF (connected_face_set);
+END_ENTITY;
+
+
+ENTITY coaxiality_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 2;
+END_ENTITY;
+
+
+ENTITY colour;
+END_ENTITY;
+
+
+ENTITY colour_rgb
+	SUBTYPE OF (colour_specification);
+	red : REAL;
+	green : REAL;
+	blue : REAL;
+WHERE
+	WR1 : {0.0 <= red <= 1.0};
+	WR2 : {0.0 <= green <= 1.0};
+	WR3 : {0.0 <= blue <= 1.0};
+END_ENTITY;
+
+
+ENTITY colour_specification
+	SUBTYPE OF (colour);
+	name : label;
+END_ENTITY;
+
+
+ENTITY common_datum
+	SUBTYPE OF (composite_shape_aspect, datum);
+WHERE
+	WR1 : SIZEOF (SELF\composite_shape_aspect.component_relationships) = 2;
+	WR2 : SIZEOF (QUERY ( sar <* SELF\composite_shape_aspect.component_relationships| 
+                      NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM' IN TYPEOF (sar.related_shape_aspect)) AND 
+                          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMMON_DATUM' IN TYPEOF (sar.related_shape_aspect))) )) = 0;
+END_ENTITY;
+
+
+ENTITY comparison_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (boolean_expression, binary_generic_expression);
+	SELF\binary_generic_expression.operands : LIST [2:2] OF expression;
+WHERE
+	WR1 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[1]))
+		AND 
+		 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[2]))) 
+OR
+ (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[1]))
+		AND 
+		 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_EXPRESSION' 
+	IN TYPEOF(SELF\binary_generic_expression.operands[2])))
+OR
+(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[1]))
+		AND 
+		 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+IN TYPEOF(SELF\binary_generic_expression.operands[2])));
+END_ENTITY;
+
+
+ENTITY complex_clause
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY complex_conjunctive_clause
+	SUBTYPE OF (complex_clause);
+END_ENTITY;
+
+
+ENTITY complex_disjunctive_clause
+	SUBTYPE OF (complex_clause);
+END_ENTITY;
+
+
+ENTITY complex_shelled_solid
+	SUBTYPE OF (shelled_solid);
+	thickened_face_list : LIST [1:?] OF SET [1:?] OF face_surface;
+	thickness_list : LIST [1:?] OF length_measure;
+WHERE
+	WR1 : SIZEOF(thickened_face_list) = SIZEOF(thickness_list);
+	WR2 : SIZEOF(QUERY(q <* thickness_list | (q = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY composite_assembly_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) = 1;
+END_ENTITY;
+
+
+ENTITY composite_assembly_sequence_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) > 0;
+END_ENTITY;
+
+
+ENTITY composite_assembly_table
+	SUBTYPE OF (part_laminate_table);
+END_ENTITY;
+
+
+ENTITY composite_curve
+	SUBTYPE OF (bounded_curve);
+	segments : LIST [1:?] OF composite_curve_segment;
+	self_intersect : LOGICAL;
+DERIVE
+	closed_curve : LOGICAL := segments[n_segments].transition <> discontinuous;
+	n_segments : INTEGER := SIZEOF(segments);
+WHERE
+	WR1 : ((NOT closed_curve) AND (SIZEOF(QUERY(temp <* segments |
+                temp.transition = discontinuous)) = 1)) OR
+            ((closed_curve) AND (SIZEOF(QUERY(temp <* segments | 
+                temp.transition = discontinuous)) = 0));
+END_ENTITY;
+
+
+ENTITY composite_curve_on_surface
+	SUPERTYPE OF (boundary_curve)
+	SUBTYPE OF (composite_curve);
+DERIVE
+	basis_surface : SET [0:2] OF surface := get_basis_surface(SELF);
+WHERE
+	WR1 : SIZEOF(basis_surface) > 0;
+	WR2 : constraints_composite_curve_on_surface(SELF);
+END_ENTITY;
+
+
+ENTITY composite_curve_segment
+	SUBTYPE OF (founded_item);
+	transition : transition_code;
+	same_sense : BOOLEAN;
+	parent_curve : curve;
+INVERSE
+	using_curves: BAG [1:?] OF composite_curve FOR segments;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE' IN TYPEOF(parent_curve));
+END_ENTITY;
+
+
+ENTITY composite_material_designation
+	SUBTYPE OF (material_designation);
+END_ENTITY;
+
+
+ENTITY composite_shape_aspect
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	component_relationships: SET [2:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+END_ENTITY;
+
+
+ENTITY composite_sheet_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MANIFOLD_SURFACE_SHAPE_REPRESENTATION'] * TYPEOF (SELF)) = 1;
+END_ENTITY;
+
+
+ENTITY composite_text
+	SUBTYPE OF (geometric_representation_item);
+	collected_text : SET [2:?] OF text_or_character;
+WHERE
+	WR1 : acyclic_composite_text( SELF, SELF.collected_text);
+END_ENTITY;
+
+
+ENTITY composite_text_with_associated_curves
+	SUBTYPE OF (composite_text);
+	associated_curves : SET [1:?] OF curve;
+END_ENTITY;
+
+
+ENTITY composite_text_with_blanking_box
+	SUBTYPE OF (composite_text);
+	blanking : planar_box;
+END_ENTITY;
+
+
+ENTITY composite_text_with_delineation
+	SUBTYPE OF (composite_text);
+	delineation : text_delineation;
+END_ENTITY;
+
+
+ENTITY composite_text_with_extent
+	SUBTYPE OF (composite_text);
+	extent : planar_extent;
+END_ENTITY;
+
+
+ENTITY compound_representation_item
+	SUPERTYPE OF (ONEOF (point_and_vector, point_path, row_representation_item, table_representation_item))
+	SUBTYPE OF (representation_item);
+	item_element : compound_item_definition;
+END_ENTITY;
+
+
+ENTITY compound_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'GEOMETRIC_REPRESENTATION_CONTEXT'
+        IN TYPEOF ( SELF.context_of_items ) ) AND (
+        SELF.context_of_items\
+        geometric_representation_context.coordinate_space_dimension =3 );
+	WR2 : SIZEOF ( QUERY ( cbsr_i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'EDGE_BASED_WIREFRAME_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'FACE_BASED_SURFACE_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MAPPED_ITEM' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'AXIS2_PLACEMENT_3D']* TYPEOF ( cbsr_i ) ) <>1 ) ) =0;
+	WR3 : SIZEOF ( QUERY ( cbsr_i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'EDGE_BASED_WIREFRAME_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'FACE_BASED_SURFACE_MODEL' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MAPPED_ITEM']* TYPEOF ( cbsr_i ) ) =1 ) ) >0;
+	WR4 : SIZEOF ( QUERY ( cbsr_i <* SELF.items | (
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MAPPED_ITEM' IN TYPEOF ( cbsr_i ) )
+         AND ( SIZEOF ( ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'COMPOUND_SHAPE_REPRESENTATION' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'NON_MANIFOLD_SURFACE_SHAPE_REPRESENTATION']* TYPEOF (
+         cbsr_i\ mapped_item.mapping_source ) ) <>1 ) ) ) =0;
+END_ENTITY;
+
+
+ENTITY concentricity_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) = 1;
+END_ENTITY;
+
+
+ENTITY concept_feature_operator;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY concept_feature_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_concept_feature : product_concept_feature;
+	related_product_concept_feature : product_concept_feature;
+END_ENTITY;
+
+
+ENTITY concept_feature_relationship_with_condition
+	SUBTYPE OF (concept_feature_relationship);
+	conditional_operator : concept_feature_operator;
+END_ENTITY;
+
+
+ENTITY conditional_concept_feature
+	SUBTYPE OF (product_concept_feature);
+	condition : concept_feature_relationship_with_condition;
+END_ENTITY;
+
+
+ENTITY conductance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONDUCTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY conductance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.siemens);
+END_ENTITY;
+
+
+ENTITY configurable_item
+	SUBTYPE OF (configuration_item);
+	item_concept_feature : SET [1:?] OF product_concept_feature_association;
+END_ENTITY;
+
+
+ENTITY configuration_design;
+	configuration : configuration_item;
+	design : configuration_design_item;
+DERIVE
+	description : text := get_description_value (SELF);
+	name : label := get_name_value (SELF);
+UNIQUE
+	UR1 : configuration, design;
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+	WR2 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY configuration_effectivity
+	SUBTYPE OF (product_definition_effectivity);
+	configuration : configuration_design;
+UNIQUE
+  UR1: configuration, SELF\product_definition_effectivity.usage, SELF\effectivity.id;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_USAGE' IN
+        TYPEOF (SELF\product_definition_effectivity.usage);
+END_ENTITY;
+
+
+ENTITY configuration_item;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	item_concept : product_concept;
+	purpose : OPTIONAL label;
+END_ENTITY;
+
+
+ENTITY configuration_item_hierarchical_relationship
+	SUBTYPE OF (configuration_item_relationship);
+END_ENTITY;
+
+
+ENTITY configuration_item_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_configuration_item : configuration_item;
+	related_configuration_item : configuration_item;
+END_ENTITY;
+
+
+ENTITY configuration_item_revision_sequence
+	SUBTYPE OF (configuration_item_relationship);
+END_ENTITY;
+
+
+ENTITY configured_effectivity_assignment
+	SUBTYPE OF (effectivity_assignment);
+	items : SET [1:?] OF configured_effectivity_item;
+WHERE
+	WR1 : (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EFFECTIVITY'] * TYPEOF(SELF.assigned_effectivity) ) = 1) 
+	AND (SELF.assigned_effectivity.id = 'configuration validity');
+	WR2 : SIZEOF(SELF.items) = 1;
+	WR3 : SIZEOF( QUERY( i <* SELF.items | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) 
+	OR NOT (i\product_definition.frame_of_reference.name IN ['conceptual definition','part occurrence', 'functional definition','alternative definition']) )) = 0;
+	WR4 : SELF.role.name IN ['design', 'usage'];
+	WR5 : (SELF.role.name <> 'design') 
+	OR (SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) AND (i\product_definition.frame_of_reference.name = 'part occurrence') )) = 0);
+	WR6 : (SELF.role.name <> 'usage') OR (SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(i)) AND (i\product_definition.frame_of_reference.name = 'conceptual definition') )) = 0);
+	WR7 : SELF.role.description IN ['exception', 'inherited', 'local'];
+	WR8 : SIZEOF( QUERY( x <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EFFECTIVITY_CONTEXT_ASSIGNMENT.ASSIGNED_EFFECTIVITY_ASSIGNMENT') | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONFIGURED_EFFECTIVITY_CONTEXT_ASSIGNMENT' IN TYPEOF(x) )) = 1;
+END_ENTITY;
+
+
+ENTITY configured_effectivity_context_assignment
+	SUBTYPE OF (effectivity_context_assignment);
+	items : SET [1:?] OF configured_effectivity_context_item;
+	SELF\effectivity_context_assignment.assigned_effectivity_assignment : configured_effectivity_assignment;
+WHERE
+	WR1 : SIZEOF(SELF.items) = 1;
+END_ENTITY;
+
+
+ENTITY conic
+	SUPERTYPE OF (ONEOF (circle, ellipse, hyperbola, parabola))
+	SUBTYPE OF (curve);
+	position : axis2_placement;
+END_ENTITY;
+
+
+ENTITY conical_stepped_hole_transition
+	SUBTYPE OF (geometric_representation_item);
+	transition_number : positive_integer;
+	cone_apex_angle : plane_angle_measure;
+	cone_base_radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY conical_surface
+	SUBTYPE OF (elementary_surface);
+	radius : length_measure;
+	semi_angle : plane_angle_measure;
+WHERE
+	WR1 : radius >= 0.0;
+END_ENTITY;
+
+
+ENTITY connected_edge_set
+	SUBTYPE OF (topological_representation_item);
+	ces_edges : SET [1:?] OF edge;
+END_ENTITY;
+
+
+ENTITY connected_face_set
+	SUPERTYPE OF (ONEOF (closed_shell, open_shell))
+	SUBTYPE OF (topological_representation_item);
+	cfs_faces : SET [1:?] OF face;
+END_ENTITY;
+
+
+ENTITY connected_face_sub_set
+	SUBTYPE OF (connected_face_set);
+	parent_face_set : connected_face_set;
+END_ENTITY;
+
+
+ENTITY constructive_geometry_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_CONTEXT' IN TYPEOF(SELF.context_of_items)) AND ({2 <= SELF.context_of_items\geometric_representation_context. coordinate_space_dimension <= 3});
+	WR2 : SIZEOF( QUERY( cgr_i <* SELF.items | SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLACEMENT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT'] * TYPEOF(cgr_i)) <> 1 )) = 0;
+	WR3 : SIZEOF( USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_2') ) > 0;
+	WR4 : SIZEOF( USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_MAP.MAPPED_REPRESENTATION') ) = 0;
+END_ENTITY;
+
+
+ENTITY constructive_geometry_representation_relationship
+	SUBTYPE OF (representation_relationship);
+	SELF\representation_relationship.rep_1 : constructive_geometry_representation_or_shape_represenation;
+	SELF\representation_relationship.rep_2 : constructive_geometry_representation;
+WHERE
+	WR1 : (SELF.rep_1.context_of_items :=: SELF.rep_2.context_of_items) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_CONTEXT' IN TYPEOF(SELF.rep_1.context_of_items));
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION' IN TYPEOF(SELF));
+END_ENTITY;
+
+
+ENTITY contact_ratio_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ( SIZEOF ( SELF.items ) =1 ) AND ( SIZEOF ( QUERY ( i <*
+        SELF.items | ( SIZEOF ( ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'MEASURE_REPRESENTATION_ITEM' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'VALUE_RANGE']* TYPEOF ( i ) ) =1 ) AND ( i.name =
+        'ratio value' ) ) ) =1 );
+	WR2 : ( SIZEOF ( QUERY ( pdr <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | pdr. name =
+        'contact ratio reference' ) ) =1 ) AND ( SIZEOF ( QUERY (
+        pdr <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | ( pdr. name =
+        'contact ratio reference' ) AND ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'PRODUCT_DEFINITION' IN TYPEOF ( pdr.
+        definition.definition ) ) ) ) =1 );
+	WR3 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )
+        ) =1 );
+END_ENTITY;
+
+
+ENTITY context_dependent_invisibility
+	SUBTYPE OF (invisibility);
+	presentation_context : invisibility_context;
+END_ENTITY;
+
+
+ENTITY context_dependent_over_riding_styled_item
+	SUBTYPE OF (over_riding_styled_item);
+	style_context : LIST [1:?] OF style_context_select;
+WHERE
+	WR1 : (SIZEOF(QUERY(sc <* SELF.style_context | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM' IN TYPEOF(sc)))= 1) OR
+(SIZEOF(QUERY(sc <* SELF.style_context |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(sc))
+  OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_RELATIONSHIP' IN TYPEOF(sc)) ))
+  = SIZEOF(style_context));
+END_ENTITY;
+
+
+ENTITY context_dependent_shape_representation;
+	representation_relation : shape_representation_relationship;
+	represented_product_relation : product_definition_shape;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_RELATIONSHIP' IN TYPEOF(SELF.represented_product_relation.definition);
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR3 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY context_dependent_unit
+	SUBTYPE OF (named_unit);
+	name : label;
+END_ENTITY;
+
+
+ENTITY contract;
+	name : label;
+	purpose : text;
+	kind : contract_type;
+END_ENTITY;
+
+
+ENTITY contract_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_contract : contract;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY contract_relationship;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	relating_contract : contract;
+	related_contract : contract;
+END_ENTITY;
+
+
+ENTITY contract_type;
+	description : label;
+END_ENTITY;
+
+
+ENTITY conversion_based_unit
+	SUBTYPE OF (named_unit);
+	name : label;
+	conversion_factor : measure_with_unit;
+WHERE
+	WR1 : SELF\named_unit.dimensions = derive_dimensional_exponents(conversion_factor\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY coordinated_universal_time_offset;
+	hour_offset : INTEGER;
+	minute_offset : OPTIONAL INTEGER;
+	sense : ahead_or_behind;
+DERIVE
+	actual_minute_offset : INTEGER := NVL(minute_offset,0);
+WHERE
+	WR1 : { 0 <= hour_offset < 24 };
+	WR2 : { 0 <= actual_minute_offset <= 59 };
+	WR3 : NOT (((hour_offset <> 0) OR (actual_minute_offset <>0)) AND (sense = exact));
+END_ENTITY;
+
+
+ENTITY csg_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SELF.context_of_items\geometric_representation_context.coordinate_space_dimension = 3;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CSG_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_REPLICA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REVOLVED_FACE_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXTRUDED_FACE_SOLID' ] * TYPEOF (it)) <> 1) )) = 0;
+	WR3 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CSG_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( sr <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_REPLICA' IN TYPEOF (it)) )| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CSG_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REVOLVED_FACE_SOLID', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXTRUDED_FACE_SOLID' ] * TYPEOF (sr\solid_replica.parent_solid)) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' IN TYPEOF (it)) )) > 0;
+END_ENTITY;
+
+
+ENTITY csg_solid
+	SUBTYPE OF (solid_model);
+	tree_root_expression : csg_select;
+END_ENTITY;
+
+
+ENTITY currency
+	ABSTRACT SUPERTYPE OF (ONEOF (externally_defined_currency, iso4217_currency))
+	SUBTYPE OF (context_dependent_unit);
+WHERE
+	WR1 : ((SELF\named_unit.dimensions.length_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.mass_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.time_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND
+           (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0));
+END_ENTITY;
+
+
+ENTITY currency_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+	SELF\measure_with_unit.unit_component : currency;
+END_ENTITY;
+
+
+ENTITY curve
+	SUPERTYPE OF (ONEOF (line, conic, pcurve, surface_curve, offset_curve_2d, offset_curve_3d, curve_replica))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY curve_bounded_surface
+	SUBTYPE OF (bounded_surface);
+	basis_surface : surface;
+	boundaries : SET [1:?] OF boundary_curve;
+	implicit_outer : BOOLEAN;
+WHERE
+	WR1 : (NOT implicit_outer) OR
+         (SIZEOF (QUERY (temp <* boundaries |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OUTER_BOUNDARY_CURVE' IN TYPEOF(temp))) = 0);
+	WR2 : (NOT(implicit_outer)) OR
+                ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_SURFACE' IN TYPEOF(basis_surface));
+	WR3 : SIZEOF(QUERY(temp <* boundaries |
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OUTER_BOUNDARY_CURVE' IN
+                                         TYPEOF(temp))) <= 1;
+	WR4 : SIZEOF(QUERY(temp <* boundaries |
+            (temp\composite_curve_on_surface.basis_surface [1] <>
+                                         SELF.basis_surface))) = 0;
+END_ENTITY;
+
+
+ENTITY curve_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY curve_replica
+	SUBTYPE OF (curve);
+	parent_curve : curve;
+	transformation : cartesian_transformation_operator;
+WHERE
+	WR1 : transformation.dim = parent_curve.dim;
+	WR2 : acyclic_curve_replica (SELF, parent_curve);
+END_ENTITY;
+
+
+ENTITY curve_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	curve_font : curve_font_or_scaled_curve_font_select;
+	curve_width : size_select;
+	curve_colour : colour;
+END_ENTITY;
+
+
+ENTITY curve_style_font
+	SUBTYPE OF (founded_item);
+	name : label;
+	pattern_list : LIST [1:?] OF curve_style_font_pattern;
+END_ENTITY;
+
+
+ENTITY curve_style_font_and_scaling
+	SUBTYPE OF (founded_item);
+	name : label;
+	curve_font : curve_style_font_select;
+	curve_font_scaling : REAL;
+END_ENTITY;
+
+
+ENTITY curve_style_font_pattern
+	SUBTYPE OF (founded_item);
+	visible_segment_length : positive_length_measure;
+	invisible_segment_length : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY curve_style_rendering;
+	rendering_method : shading_curve_method;
+	rendering_properties : surface_rendering_properties;
+END_ENTITY;
+
+
+ENTITY curve_swept_solid_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+          NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_AREA_SOLID',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_DISK_SOLID',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] *
+                   TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+         SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_AREA_SOLID',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_DISK_SOLID',
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) =1 )) > 0;
+	WR3 : SIZEOF (QUERY (mi <*  QUERY (it <* items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) |
+   NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_SWEPT_SOLID_SHAPE_REPRESENTATION' IN
+             TYPEOF(mi\mapped_item.mapping_source.
+                           mapped_representation)))) = 0;
+	WR4 : SIZEOF (QUERY (scsas <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE_SWEPT_AREA_SOLID' IN
+              TYPEOF(it)) |
+          NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN
+                 TYPEOF(scsas\surface_curve_swept_area_solid.directrix)) OR
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+                   TYPEOF(scsas\surface_curve_swept_area_solid.directrix))))) = 0;
+END_ENTITY;
+
+
+ENTITY cylindrical_surface
+	SUBTYPE OF (elementary_surface);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY cylindricity_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY data_environment;
+	name : label;
+	description : text;
+	elements : SET [1:?] OF property_definition_representation;
+END_ENTITY;
+
+
+ENTITY date
+	SUPERTYPE OF (ONEOF (calendar_date, ordinal_date, week_of_year_and_day_date, year_month));
+	year_component : year_number;
+END_ENTITY;
+
+
+ENTITY date_and_time;
+	date_component : date;
+	time_component : local_time;
+END_ENTITY;
+
+
+ENTITY date_and_time_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_date_and_time : date_and_time;
+	role : date_time_role;
+END_ENTITY;
+
+
+ENTITY date_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_date : date;
+	role : date_role;
+END_ENTITY;
+
+
+ENTITY date_representation_item
+	SUBTYPE OF (representation_item, date);
+END_ENTITY;
+
+
+ENTITY date_role;
+	name : label;
+DERIVE
+	description : text := get_description_value (SELF);
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY date_time_representation_item
+	SUBTYPE OF (representation_item, date_and_time);
+END_ENTITY;
+
+
+ENTITY date_time_role;
+	name : label;
+DERIVE
+	description : text := get_description_value (SELF);
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY dated_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_end_date : OPTIONAL date_time_or_event_occurrence;
+	effectivity_start_date : date_time_or_event_occurrence;
+END_ENTITY;
+
+
+ENTITY datum
+	SUBTYPE OF (shape_aspect);
+	identification : identifier;
+INVERSE
+	established_by_relationships: SET [1:?] OF shape_aspect_relationship FOR related_shape_aspect;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMMON_DATUM' IN TYPEOF(SELF)) XOR
+       ((SIZEOF(QUERY(x <* SELF\datum.established_by_relationships |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_FEATURE' IN TYPEOF(x\shape_aspect_relationship.relating_shape_aspect)))) = 1) XOR
+       (SIZEOF(QUERY(x <* SELF\datum.established_by_relationships |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_TARGET' IN TYPEOF(x\shape_aspect_relationship.relating_shape_aspect)))) >= 1));
+END_ENTITY;
+
+
+ENTITY datum_feature
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	feature_basis_relationship: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF(QUERY(sar <* SELF\datum_feature.feature_basis_relationship 
+       | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM' IN TYPEOF
+       (sar\shape_aspect_relationship.related_shape_aspect)))) = 1;
+	WR2 : SELF\shape_aspect.product_definitional = TRUE;
+END_ENTITY;
+
+
+ENTITY datum_feature_callout
+	SUBTYPE OF (draughting_callout);
+END_ENTITY;
+
+
+ENTITY datum_reference;
+	precedence : INTEGER;
+	referenced_datum : datum;
+WHERE
+	WR1 : precedence > 0;
+END_ENTITY;
+
+
+ENTITY datum_target
+	SUBTYPE OF (shape_aspect);
+	target_id : identifier;
+INVERSE
+	target_basis_relationship: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF(QUERY(sar <* SELF\datum_target.target_basis_relationship 
+       | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM' IN TYPEOF
+       (sar\shape_aspect_relationship.related_shape_aspect)))) = 1;
+	WR2 : SELF\shape_aspect.product_definitional = TRUE;
+END_ENTITY;
+
+
+ENTITY datum_target_callout
+	SUBTYPE OF (draughting_callout);
+END_ENTITY;
+
+
+ENTITY default_tolerance_table
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF( QUERY( i <* SELF.items | NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEFAULT_TOLERANCE_TABLE_CELL' IN TYPEOF(i)) )) = 0;
+	WR2 : (SIZEOF( QUERY( rr <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_1') | rr.name < 'general tolerance definition' )) = 0) AND (SIZEOF( QUERY( rr <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_1') | (rr.name = 'general tolerance definition') AND (rr.rep_2.name < 'default tolerance') )) = 0) AND (SIZEOF( USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.REP_2') ) = 0);
+END_ENTITY;
+
+
+ENTITY default_tolerance_table_cell
+	SUBTYPE OF (compound_representation_item);
+WHERE
+	WR1 : SIZEOF(QUERY( x <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION.ITEMS') | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DEFAULT_TOLERANCE_TABLE' IN TYPEOF(x)))=1;
+	WR2 : default_tolerance_table_cell_wr2(SELF\compound_representation_item.item_element);
+	WR3 : default_tolerance_table_cell_wr3(SELF\compound_representation_item.item_element);
+	WR4 : default_tolerance_table_cell_wr4(SELF\compound_representation_item.item_element);
+	WR5 : default_tolerance_table_cell_wr5(SELF\compound_representation_item.item_element);
+END_ENTITY;
+
+
+ENTITY defined_symbol
+	SUBTYPE OF (geometric_representation_item);
+	definition : defined_symbol_select;
+	target : symbol_target;
+END_ENTITY;
+
+
+ENTITY definitional_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARAMETRIC_REPRESENTATION_CONTEXT' IN
+          TYPEOF (SELF\representation.context_of_items );
+END_ENTITY;
+
+
+ENTITY definitional_representation_relationship
+	SUBTYPE OF (representation_relationship);
+WHERE
+	WR1 : acyclic_representation_relationship(SELF,
+         [SELF\representation_relationship.rep_2],
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION');
+END_ENTITY;
+
+
+ENTITY definitional_representation_relationship_with_same_context
+	SUBTYPE OF (definitional_representation_relationship);
+WHERE
+	WR1 : SELF\representation_relationship.rep_1.context_of_items :=: 
+            SELF\representation_relationship.rep_2.context_of_items;
+END_ENTITY;
+
+
+ENTITY degenerate_pcurve
+	SUBTYPE OF (point);
+	basis_surface : surface;
+	reference_to_curve : definitional_representation;
+WHERE
+	WR1 : SIZEOF(reference_to_curve\representation.items) = 1;
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF
+                    (reference_to_curve\representation.items[1]);
+	WR3 : reference_to_curve\representation.
+                   items[1]\geometric_representation_item.dim =2;
+END_ENTITY;
+
+
+ENTITY degenerate_toroidal_surface
+	SUBTYPE OF (toroidal_surface);
+	select_outer : BOOLEAN;
+WHERE
+	WR1 : major_radius <   minor_radius;
+END_ENTITY;
+
+
+ENTITY derived_shape_aspect
+	SUPERTYPE OF (ONEOF (apex, centre_of_symmetry, geometric_alignment, geometric_intersection, parallel_offset, perpendicular_to, extension, tangent))
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	deriving_relationships: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF (QUERY (dr <*
+          SELF\derived_shape_aspect.deriving_relationships |
+          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+               'SHAPE_ASPECT_DERIVING_RELATIONSHIP'
+          IN TYPEOF (dr)))) = 0;
+END_ENTITY;
+
+
+ENTITY derived_unit
+	SUPERTYPE OF (ONEOF (absorbed_dose_unit, acceleration_unit, radioactivity_unit, area_unit, capacitance_unit, dose_equivalent_unit, electric_charge_unit, conductance_unit, electric_potential_unit, energy_unit, magnetic_flux_density_unit, force_unit, frequency_unit, illuminance_unit, inductance_unit, magnetic_flux_unit, power_unit, pressure_unit, resistance_unit, velocity_unit, volume_unit));
+	elements : SET [1:?] OF derived_unit_element;
+DERIVE
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : (SIZEOF(elements) > 1) OR ((SIZEOF(elements) = 1) AND (elements[1].exponent <> 1.0));
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY derived_unit_element;
+	unit : named_unit;
+	exponent : REAL;
+END_ENTITY;
+
+
+ENTITY description_attribute;
+	attribute_value : text;
+	described_item : description_attribute_select;
+END_ENTITY;
+
+
+ENTITY descriptive_representation_item
+	SUPERTYPE OF (ONEOF (tagged_text_item, uniform_resource_identifier))
+	SUBTYPE OF (representation_item);
+	description : text;
+END_ENTITY;
+
+
+ENTITY design_context
+	SUBTYPE OF (product_definition_context);
+WHERE
+	WR1 : SELF.life_cycle_stage = 'design';
+END_ENTITY;
+
+
+ENTITY design_make_from_relationship
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY diameter_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY dielectric_constant_measure_with_unit
+	SUBTYPE OF (ratio_measure_with_unit);
+END_ENTITY;
+
+
+ENTITY dimension_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT'
+        IN (TYPEOF (SELF))) XOR
+       (SIZEOF (QUERY(dce_1 <* SELF\draughting_callout.contents |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE'
+        IN (TYPEOF(dce_1))))) = 0);
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT'
+        IN (TYPEOF (SELF))) XOR
+       (SIZEOF (QUERY(dce_1 <* SELF\draughting_callout.contents |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE'
+        IN (TYPEOF(dce_1))))) = 0);
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT'
+        IN (TYPEOF (SELF))) XOR
+       (SIZEOF (QUERY(dce_1 <* SELF\draughting_callout.contents |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE'
+        IN (TYPEOF(dce_1))))) = 0);
+END_ENTITY;
+
+
+ENTITY dimension_callout_component_relationship
+	SUBTYPE OF (draughting_callout_relationship);
+WHERE
+	WR1 : SELF.name IN ['prefix', 'suffix'];
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRUCTURED_DIMENSION_CALLOUT'
+           IN TYPEOF (SELF.relating_draughting_callout);
+	WR3 : SIZEOF (TYPEOF (SELF.related_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRUCTURED_DIMENSION_CALLOUT']) = 0;
+	WR4 : SELF.related_draughting_callout.contents *
+       SELF.relating_draughting_callout.contents =
+       SELF.related_draughting_callout.contents;
+	WR5 : ((SELF.name = 'prefix') AND
+       (SIZEOF (QUERY (ato <* QUERY (con <*
+                 SELF.related_draughting_callout.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con))) |
+         NOT (ato.name = 'prefix text')
+       )) = 0));
+	WR6 : ((SELF.name = 'suffix') AND
+       (SIZEOF (QUERY (ato <* QUERY (con <*
+                 SELF.related_draughting_callout.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con))) |
+         NOT (ato.name = 'suffix text')
+       )) = 0));
+END_ENTITY;
+
+
+ENTITY dimension_callout_relationship
+	SUBTYPE OF (draughting_callout_relationship);
+WHERE
+	WR1 : SELF.name IN ['primary', 'secondary'];
+	WR2 : SIZEOF (TYPEOF (SELF.relating_draughting_callout) * 
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIAMETER_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINEAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORDINATE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIUS_DIMENSION'])>=1;
+	WR3 : SIZEOF (TYPEOF (SELF.related_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT']) = 0;
+	WR4 : SELF.related_draughting_callout.contents *
+       SELF.relating_draughting_callout.contents =
+       SELF.related_draughting_callout.contents;
+END_ENTITY;
+
+
+ENTITY dimension_curve
+	SUBTYPE OF (annotation_curve_occurrence);
+WHERE
+	WR1 : (SIZEOF(
+          QUERY(dct <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'TERMINATOR_SYMBOL.ANNOTATED_CURVE')
+               | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                  'DIMENSION_CURVE_TERMINATOR' IN TYPEOF(dct))
+                  ))
+          ) <= 2);
+	WR2 : SIZEOF(
+            QUERY( dcdc <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'DRAUGHTING_CALLOUT.CONTENTS') |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                    'DIMENSION_CURVE_DIRECTED_CALLOUT' IN TYPEOF(dcdc)))
+          )>= 1;
+	WR3 : (SIZEOF(
+            QUERY(dct1 <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                  'TERMINATOR_SYMBOL.ANNOTATED_CURVE') 
+               | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                  'DIMENSION_CURVE_TERMINATOR' IN TYPEOF(dct1)) 
+                  AND (dct1\dimension_curve_terminator.role = dimension_extent_usage.origin)))
+          ) <= 1)
+        AND 
+        (SIZEOF(
+            QUERY (dct2 <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                   'TERMINATOR_SYMBOL.ANNOTATED_CURVE') 
+                 | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                   'DIMENSION_CURVE_TERMINATOR' IN TYPEOF(dct2))
+                   AND (dct2\dimension_curve_terminator.role = dimension_extent_usage.target)))
+         ) <= 1);
+END_ENTITY;
+
+
+ENTITY dimension_curve_directed_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF(QUERY(d_c<*SELF\draughting_callout.contents | 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE' IN (TYPEOF(d_c))))=1;
+	WR2 : SIZEOF(SELF\draughting_callout.contents) >= 2;
+END_ENTITY;
+
+
+ENTITY dimension_curve_terminator
+	SUBTYPE OF (terminator_symbol);
+	role : dimension_extent_usage;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE' IN TYPEOF
+        (SELF\terminator_symbol.annotated_curve);
+END_ENTITY;
+
+
+ENTITY dimension_curve_terminator_to_projection_curve_associativity
+	SUBTYPE OF (annotation_occurrence_associativity);
+	SELF\annotation_occurrence_relationship.related_annotation_occurrence : projection_curve;
+	SELF\annotation_occurrence_relationship.relating_annotation_occurrence : dimension_curve_terminator;
+END_ENTITY;
+
+
+ENTITY dimension_pair
+	SUBTYPE OF (draughting_callout_relationship);
+WHERE
+	WR1 : SELF.name IN ['chained', 'parallel'];
+	WR2 : SIZEOF (TYPEOF (SELF.relating_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIAMETER_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINEAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORDINATE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIUS_DIMENSION'])=1;
+	WR3 : SIZEOF (TYPEOF (SELF.related_draughting_callout) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIAMETER_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINEAR_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORDINATE_DIMENSION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIUS_DIMENSION'])=1;
+END_ENTITY;
+
+
+ENTITY dimension_related_tolerance_zone_element;
+	related_dimension : dimensional_location;
+	related_element : tolerance_zone_definition;
+END_ENTITY;
+
+
+ENTITY dimension_text_associativity
+	SUBTYPE OF (text_literal, mapped_item);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_DIMENSION_REPRESENTATION'
+          IN TYPEOF (SELF\mapped_item.
+                          mapping_source.mapped_representation));
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT'
+          IN TYPEOF (SELF\mapped_item.mapping_target));
+	WR3 : SIZEOF (QUERY (ato <* QUERY (si <* 
+          USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM.ITEM') |
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+              IN TYPEOF(si))) |
+          NOT (SIZEOF( QUERY (dc <*
+             USEDIN (ato, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                          'DRAUGHTING_CALLOUT.CONTENTS') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT'
+             IN TYPEOF (dc)))
+            * [SELF\mapped_item.mapping_target]) = 1)
+          )) = 0;
+END_ENTITY;
+
+
+ENTITY dimensional_characteristic_representation;
+	dimension : dimensional_characteristic;
+	representation : shape_dimension_representation;
+END_ENTITY;
+
+
+ENTITY dimensional_exponents;
+	length_exponent : REAL;
+	mass_exponent : REAL;
+	time_exponent : REAL;
+	electric_current_exponent : REAL;
+	thermodynamic_temperature_exponent : REAL;
+	amount_of_substance_exponent : REAL;
+	luminous_intensity_exponent : REAL;
+END_ENTITY;
+
+
+ENTITY dimensional_location
+	SUPERTYPE OF (ONEOF (angular_location, dimensional_location_with_path))
+	SUBTYPE OF (shape_aspect_relationship);
+END_ENTITY;
+
+
+ENTITY dimensional_location_with_path
+	SUBTYPE OF (dimensional_location);
+	path : shape_aspect;
+END_ENTITY;
+
+
+ENTITY dimensional_size
+	SUPERTYPE OF (ONEOF (angular_size, dimensional_size_with_path));
+	applies_to : shape_aspect;
+	name : label;
+WHERE
+	WR1 : applies_to.product_definitional = TRUE;
+END_ENTITY;
+
+
+ENTITY dimensional_size_with_path
+	SUBTYPE OF (dimensional_size);
+	path : shape_aspect;
+END_ENTITY;
+
+
+ENTITY directed_action
+	SUBTYPE OF (executed_action);
+	directive : action_directive;
+END_ENTITY;
+
+
+ENTITY directed_dimensional_location
+	SUBTYPE OF (dimensional_location);
+END_ENTITY;
+
+
+ENTITY direction
+	SUBTYPE OF (geometric_representation_item);
+	direction_ratios : LIST [2:3] OF REAL;
+WHERE
+	WR1 : SIZEOF(QUERY(tmp <* direction_ratios | tmp <> 0.0)) > 0;
+END_ENTITY;
+
+
+ENTITY document;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	kind : document_type;
+INVERSE
+	representation_types: SET [0:?] OF document_representation_type FOR represented_document;
+END_ENTITY;
+
+
+ENTITY document_file
+	SUBTYPE OF (document, characterized_object);
+WHERE
+	WR1 : SELF\characterized_object.name = '';
+	WR2 : NOT EXISTS(SELF\characterized_object.description);
+	WR3 : SIZEOF( QUERY( drt <* SELF\document.representation_types |
+               drt.name IN ['digital','physical'])) = 1;
+END_ENTITY;
+
+
+ENTITY document_identifier
+	SUBTYPE OF (group);
+UNIQUE
+  UR1: SELF\group.name, SELF\group.description;
+END_ENTITY;
+
+
+ENTITY document_identifier_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:?] OF document_identifier_assigned_item;
+	SELF\group_assignment.assigned_group : document_identifier;
+END_ENTITY;
+
+
+ENTITY document_product_association;
+	name : label;
+	description : OPTIONAL text;
+	relating_document : document;
+	related_product : product_or_formation_or_definition;
+END_ENTITY;
+
+
+ENTITY document_product_equivalence
+	SUBTYPE OF (document_product_association);
+WHERE
+	WR1 : SELF\document_product_association.name = 'equivalence';
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT' IN TYPEOF(SELF\document_product_association.related_product)) OR ((SELF\document_product_association.relating_document.kind. product_data_type = 'configuration controlled document') AND (SIZEOF( QUERY( prpc <* USEDIN(SELF\document_product_association.related_product,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | prpc.name = 'document' )) = 1));
+	WR3 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_FORMATION' IN TYPEOF(SELF.related_product)) OR ((SELF\document_product_association.relating_document.kind.product_data_type = 'configuration controlled document version') AND (SIZEOF( QUERY( prpc <* USEDIN(SELF.related_product\product_definition_formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | prpc.name = 'document')) = 1));
+	WR4 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF(SELF.related_product)) OR ((SELF\document_product_association.relating_document.kind.product_data_type = 'configuration controlled document definition') AND (SIZEOF( QUERY( prpc <* USEDIN(SELF\document_product_association.related_product\product_definition.formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | prpc.name = 'document' )) = 1));
+END_ENTITY;
+
+
+ENTITY document_reference
+	ABSTRACT SUPERTYPE;
+	assigned_document : document;
+	source : label;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY document_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_document : document;
+	related_document : document;
+END_ENTITY;
+
+
+ENTITY document_representation_type;
+	name : label;
+	represented_document : document;
+END_ENTITY;
+
+
+ENTITY document_type;
+	product_data_type : label;
+END_ENTITY;
+
+
+ENTITY document_usage_constraint;
+	source : document;
+	subject_element : label;
+	subject_element_value : text;
+END_ENTITY;
+
+
+ENTITY document_usage_constraint_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_document_usage : document_usage_constraint;
+	role : document_usage_role;
+END_ENTITY;
+
+
+ENTITY document_usage_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY dose_equivalent_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DOSE_EQUIVALENT_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY dose_equivalent_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.sievert);
+END_ENTITY;
+
+
+ENTITY double_offset_shelled_solid
+	SUBTYPE OF (shelled_solid);
+	thickness2 : length_measure;
+WHERE
+	WR1 : thickness2 <> 0;
+	WR2 : SELF\shelled_solid.thickness <> thickness2;
+END_ENTITY;
+
+
+ENTITY draped_defined_transformation
+	SUBTYPE OF (transformation_with_derived_angle);
+END_ENTITY;
+
+
+ENTITY draughting_annotation_occurrence
+	SUBTYPE OF (annotation_occurrence);
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE'
+            IN TYPEOF (SELF))) OR
+    (SIZEOF (QUERY (sty <* SELF.styles |
+       NOT ((SIZEOF (sty.styles) = 1)
+         AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+                 IN TYPEOF (sty.styles[1]))) )) = 0);
+	WR2 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE'
+            IN TYPEOF (SELF))) OR    (SIZEOF (QUERY (sty <* SELF.styles |
+      NOT ((SIZEOF (sty.styles) = 1)
+        AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE'
+                IN TYPEOF (sty.styles[1]))) )) = 0);
+	WR3 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE'
+            IN TYPEOF (SELF))) OR    (SIZEOF (QUERY (bound <*
+                     SELF.item\annotation_fill_area.boundaries |
+       NOT (SIZEOF (QUERY (si <*
+                   USEDIN (bound, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'STYLED_ITEM.ITEM') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+             'ANNOTATION_CURVE_OCCURRENCE' IN TYPEOF (si)))) > 0))) = 0);
+	WR4 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE'
+            IN TYPEOF (SELF))) OR    (SIZEOF (QUERY (sty <* SELF.styles |
+       NOT ((SIZEOF (sty.styles) = 1)           AND
+            (SIZEOF (TYPEOF (sty.styles[1]) *
+                ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMBOL_STYLE',
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NULL_STYLE']) = 1)) )) = 0);
+	WR5 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL'
+             IN TYPEOF(SELF.item)))) OR
+         (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'DRAUGHTING_SYMBOL_REPRESENTATION',
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                  'DRAUGHTING_SUBFIGURE_REPRESENTATION'] *
+          TYPEOF (SELF.item\mapped_item.mapping_source.
+                  mapped_representation)) = 1);
+	WR6 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+            IN TYPEOF (SELF))) OR
+    (SIZEOF (QUERY (sty <* SELF.styles |
+       NOT ((SIZEOF (sty.styles) = 1)
+        AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STYLE'
+                IN TYPEOF (sty.styles[1]))) )) = 0);
+	WR7 : (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF))) OR
+         (SIZEOF (TYPEOF(SELF.item) *
+             ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL']) = 1);
+	WR8 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item)))) OR    (SIZEOF (QUERY (tl <*
+                   SELF.item\composite_text.collected_text |
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL' 
+             IN TYPEOF (tl)) )) = 0);
+	WR9 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL'
+             IN TYPEOF (SELF.item)))) OR (SELF.item\text_literal.alignment 
+             IN ['baseline left', 'baseline centre', 'baseline right']);
+	WR10 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item)))) OR
+         (SIZEOF (QUERY (tl <* QUERY (text <* SELF.
+                  item\composite_text.collected_text
+             |('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL' IN TYPEOF(text))) |
+          NOT (tl\text_literal.alignment IN
+         ['baseline left', 'baseline centre', 'baseline right']) )) = 0);
+	WR11 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item))) OR check_text_alignment(SELF.item);
+	WR12 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+             IN TYPEOF (SELF.item))) OR check_text_font(SELF.item);
+	WR13 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+               IN TYPEOF (SELF.item)))) OR
+         (SIZEOF (QUERY (tl <* QUERY (text <*
+            SELF.item\composite_text.collected_text |
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL' IN TYPEOF (text))) |
+             NOT (SIZEOF (TYPEOF(tl) *
+                  ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'TEXT_LITERAL_WITH_BLANKING_BOX',
+                   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                   'TEXT_LITERAL_WITH_ASSOCIATED_CURVES']) = 0) )) = 0);
+	WR14 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL_WITH_ASSOCIATED_CURVES'
+             IN TYPEOF (SELF.item)))) OR
+    (SIZEOF (QUERY (crv <*
+                   SELF.item\text_literal_with_associated_curves.
+                   associated_curves |
+      NOT (SIZEOF (QUERY (si <*  USEDIN (crv, 
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM.ITEM') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE'
+            IN TYPEOF (si)) )) > 0) )) = 0);
+	WR15 : (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (SELF)) AND
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT_WITH_ASSOCIATED_CURVES'
+             IN TYPEOF (SELF.item)))) OR
+          (SIZEOF (QUERY (crv <*
+                SELF.item\composite_text_with_associated_curves.
+                associated_curves |
+           NOT (SIZEOF (QUERY (si <*  USEDIN (crv,
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM.ITEM') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE'
+           IN TYPEOF (si)) )) > 0) )) = 0);
+	WR16 : SIZEOF (QUERY (cs <* QUERY (sty <* SELF.styles |
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF (sty.styles[1])))
+      | NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT'
+        IN TYPEOF (cs.styles[1]\curve_style.curve_width)) AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE'
+        IN TYPEOF (cs.styles[1]\curve_style.
+        curve_width\measure_with_unit.value_component))))) = 0;
+	WR17 : SIZEOF (QUERY (fas <* QUERY (sty <* SELF.styles |
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE'
+          IN TYPEOF (sty.styles[1]))) |
+      NOT ((SIZEOF (QUERY (fs <* fas.styles[1]\fill_area_style.fill_styles
+                    | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE_TILES'
+                       IN TYPEOF (fs)))) <= 1)
+       AND (SIZEOF (QUERY (fst <* QUERY (fs <*
+                           fas.styles[1]\fill_area_style.fill_styles |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE_TILES'
+                  IN TYPEOF (fs))) |
+                 NOT (SIZEOF (fst\fill_area_style_tiles.tiles) = 1)
+           )) = 0))
+    )) = 0;
+	WR18 : SIZEOF (QUERY (fas <* QUERY (sty <* SELF.styles |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE' 
+            IN TYPEOF (sty.styles[1]))) |
+             NOT (SIZEOF (QUERY (fsh <* QUERY (fs <*
+                          fas.styles[1]\fill_area_style.fill_styles |
+             ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FILL_AREA_STYLE_HATCHING'
+               IN TYPEOF (fs))) |
+        NOT (fsh\fill_area_style_hatching.point_of_reference_hatch_line :=:
+             fsh\fill_area_style_hatching.pattern_start)  )) = 0)  )) = 0;
+	WR19 : SIZEOF (QUERY (ts <* QUERY (sty <* SELF.styles |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STYLE' 
+         IN TYPEOF(sty.styles[1]))) |
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                  'TEXT_STYLE_WITH_BOX_CHARACTERISTICS'
+             IN TYPEOF (ts.styles[1])))) = 0;
+	WR20 : SIZEOF (QUERY (ts <* QUERY (sty <* SELF.styles |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_STYLE_WITH_BOX_CHARACTERISTICS'
+             IN TYPEOF (sty.styles[1]))) |
+           NOT (SIZEOF (ts.styles[1]\text_style_with_box_characteristics.
+                characteristics) = 4) )) = 0;
+END_ENTITY;
+
+
+ENTITY draughting_callout
+	SUPERTYPE OF ((ONEOF (datum_feature_callout, datum_target_callout, dimension_curve_directed_callout, draughting_elements, geometrical_tolerance_callout, leader_directed_callout, projection_directed_callout, structured_dimension_callout) ANDOR surface_condition_callout))
+	SUBTYPE OF (geometric_representation_item);
+	contents : SET [1:?] OF draughting_callout_element;
+WHERE
+	WR1 : (SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN (TYPEOF(l_1)))) = 0) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT' IN (TYPEOF(SELF))) AND
+        (SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN (TYPEOF(l_1)))) = 0) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT' IN (TYPEOF(SELF))) AND  
+        (SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE' IN (TYPEOF(l_1)))) = 0) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT' IN (TYPEOF(SELF)));
+END_ENTITY;
+
+
+ENTITY draughting_callout_relationship;
+	name : label;
+	description : text;
+	relating_draughting_callout : draughting_callout;
+	related_draughting_callout : draughting_callout;
+END_ENTITY;
+
+
+ENTITY draughting_elements
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (l_c <* QUERY (con <* SELF.contents |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN TYPEOF(con))) |
+              NOT (SIZEOF (QUERY (ldc <* USEDIN (l_c,
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DRAUGHTING_CALLOUT.CONTENTS') |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT'
+              IN TYPEOF (ldc)))) <= 1)))=0;
+	WR2 : NOT    ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT'
+              IN TYPEOF(SELF)) OR
+              (SIZEOF (QUERY (con <* SELF.contents |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN
+               TYPEOF (con)))) <= 2);
+	WR3 : SIZEOF (QUERY (rc <* USEDIN (SELF,
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+              'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+               'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (rc)) AND
+              (rc.name = 'primary') )) <= 1;
+	WR4 : SIZEOF (QUERY (rc <* USEDIN (SELF,
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+              'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (rc)) AND
+                (rc.name = 'secondary') )) <= 1;
+	WR5 : SIZEOF (QUERY (sec <* QUERY (rc <* USEDIN (SELF,
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+               'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (rc)) AND         
+                (rc.name = 'secondary') ) |
+         NOT (SIZEOF (QUERY (prim <* USEDIN (SELF,
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT_' +
+               'RELATIONSHIP.RELATING_DRAUGHTING_CALLOUT') |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                'DIMENSION_CALLOUT_RELATIONSHIP' IN TYPEOF (prim)) AND         
+                (prim.name = 'primary') )) = 1))) = 0;
+END_ENTITY;
+
+
+ENTITY draughting_model
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF draughting_model_item_select;
+UNIQUE
+  UR1: SELF\representation.name;
+WHERE
+	WR1 : SIZEOF (QUERY (mi <* QUERY (it <* SELF.items |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it))) |
+         NOT (
+           SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION',
+                    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_MODEL'] *
+              TYPEOF (mi\mapped_item.mapping_source.
+                      mapped_representation)) = 1
+        ))) = 0;
+	WR2 : SIZEOF (QUERY (smi <* QUERY (si <* QUERY (it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM' IN TYPEOF(it))) |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN
+            TYPEOF(si\styled_item.item))) |
+        (NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN
+                 TYPEOF(smi\styled_item.item\mapped_item.
+                        mapping_source.mapped_representation))
+            AND
+             (SIZEOF (QUERY (sty <* smi\styled_item.styles |
+               (NOT (SIZEOF (QUERY (psa <* sty.styles |
+                       (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF(psa))))) = 1
+             )))) = 1)))
+        )) = 0;
+END_ENTITY;
+
+
+ENTITY draughting_model_item_association
+	SUBTYPE OF (item_identified_representation_usage);
+	SELF\item_identified_representation_usage.definition : shape_definition;
+	SELF\item_identified_representation_usage.identified_item : draughting_model_item_association_select;
+	SELF\item_identified_representation_usage.used_representation : draughting_model;
+END_ENTITY;
+
+
+ENTITY draughting_pre_defined_colour
+	SUBTYPE OF (pre_defined_colour);
+WHERE
+	WR1 : SELF.name IN
+      ['red',
+       'green',
+       'blue',
+       'yellow',
+       'magenta',
+       'cyan',
+       'black',
+       'white'];
+END_ENTITY;
+
+
+ENTITY draughting_pre_defined_curve_font
+	SUBTYPE OF (pre_defined_curve_font);
+WHERE
+	WR1 : SELF.name IN
+        ['continuous',
+         'chain',
+         'chain double dash',
+         'dashed',
+         'dotted'];
+END_ENTITY;
+
+
+ENTITY draughting_pre_defined_text_font
+	SUBTYPE OF (pre_defined_text_font);
+WHERE
+	WR1 : SELF.name[1:8] = 'ISO 3098';
+END_ENTITY;
+
+
+ENTITY draughting_subfigure_representation
+	SUBTYPE OF (symbol_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (item <* SELF\representation.items |
+         NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_OCCURRENCE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT']
+               * TYPEOF (item)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (item <* SELF\representation.items |
+         SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_OCCURRENCE',
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT'] *
+           TYPEOF (item)) = 1)) >= 1;
+	WR3 : SIZEOF (QUERY (srm <* QUERY (rm <*
+          USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                        'REPRESENTATION_MAP.MAPPED_REPRESENTATION') |
+          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMBOL_REPRESENTATION_MAP'
+             IN TYPEOF(rm))) | 
+            NOT (SIZEOF (QUERY (a_s <* QUERY (mi <* srm.map_usage |
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL' IN TYPEOF(mi)))
+          | NOT (SIZEOF (QUERY (aso <*
+            USEDIN (a_s, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                         'STYLED_ITEM.ITEM') |
+          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SUBFIGURE_OCCURRENCE'
+            IN TYPEOF(aso)))) = 0))) = 0))) > 0;
+	WR4 : NOT (acyclic_mapped_item_usage (SELF));
+	WR5 : SIZEOF (SELF.context_of_items.representations_in_context) = 1;
+END_ENTITY;
+
+
+ENTITY draughting_symbol_representation
+	SUBTYPE OF (symbol_representation);
+UNIQUE
+  UR1: SELF\representation.name;
+WHERE
+	WR1 : SIZEOF (QUERY (item <* SELF\representation.items |
+         NOT (SIZEOF (TYPEOF (item) *
+            ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT']) = 1)
+       )) = 0;
+	WR2 : SIZEOF (QUERY (item <* SELF\representation.items |
+         (SIZEOF (TYPEOF (item) *
+            ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_CURVE_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_FILL_AREA_OCCURRENCE',
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE']) = 1)
+       )) >= 1;
+	WR3 : SIZEOF (QUERY (item <* SELF\representation.items |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SUBFIGURE_OCCURRENCE'
+          IN TYPEOF (item))) = 0;
+	WR4 : SIZEOF (QUERY (srm <* QUERY (rm <*
+          USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                        'REPRESENTATION_MAP.MAPPED_REPRESENTATION') |
+          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMBOL_REPRESENTATION_MAP'
+             IN TYPEOF(rm))) |
+         (SIZEOF (QUERY (a_s <* QUERY (mi <* srm.map_usage |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL' IN TYPEOF(mi))) |
+         NOT (SIZEOF (QUERY(aso <*
+             USEDIN(a_s, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                         'STYLED_ITEM.ITEM') |
+             NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_SYMBOL_OCCURRENCE'
+                  IN TYPEOF(aso))
+          )) = 0) )) = 0) )) > 0;
+	WR5 : NOT (acyclic_mapped_item_usage (SELF));
+	WR6 : SIZEOF (SELF.context_of_items.representations_in_context) = 1;
+END_ENTITY;
+
+
+ENTITY draughting_text_literal_with_delineation
+	SUBTYPE OF (text_literal_with_delineation);
+WHERE
+	WR1 : SELF.delineation IN ['underline', 'overline'];
+END_ENTITY;
+
+
+ENTITY draughting_title;
+	items : SET [1:?] OF draughting_titled_item;
+	language : label;
+	contents : text;
+END_ENTITY;
+
+
+ENTITY drawing_definition;
+	drawing_number : identifier;
+	drawing_type : OPTIONAL label;
+END_ENTITY;
+
+
+ENTITY drawing_revision
+	SUBTYPE OF (presentation_set);
+	revision_identifier : identifier;
+	drawing_identifier : drawing_definition;
+	intended_scale : OPTIONAL text;
+UNIQUE
+	UR1 : revision_identifier, drawing_identifier;
+END_ENTITY;
+
+
+ENTITY drawing_revision_sequence;
+	predecessor : drawing_revision;
+	successor : drawing_revision;
+WHERE
+	WR1 : predecessor :<>: successor;
+END_ENTITY;
+
+
+ENTITY drawing_sheet_revision
+	SUBTYPE OF (presentation_area);
+	revision_identifier : identifier;
+WHERE
+	WR1 : SIZEOF( QUERY(item <* SELF\representation.items |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN (TYPEOF(item)))
+       AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION' IN
+       (TYPEOF(item\mapped_item.mapping_source.mapped_representation)))))=0;
+END_ENTITY;
+
+
+ENTITY drawing_sheet_revision_sequence
+	SUBTYPE OF (representation_relationship);
+WHERE
+	WR1 : SELF\representation_relationship.rep_1 :<>:                            
+       SELF\representation_relationship.rep_2;
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION'
+       IN TYPEOF (SELF\representation_relationship.rep_1);
+	WR3 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION'
+       IN TYPEOF (SELF\representation_relationship.rep_2);
+END_ENTITY;
+
+
+ENTITY drawing_sheet_revision_usage
+	SUBTYPE OF (area_in_set);
+	sheet_number : identifier;
+UNIQUE
+  UR1: sheet_number, SELF\area_in_set.in_set;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_SHEET_REVISION' IN 
+                  TYPEOF(SELF\area_in_set.area)) 
+              AND
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAWING_REVISION' 
+               IN TYPEOF (SELF\area_in_set.in_set));
+END_ENTITY;
+
+
+ENTITY edge
+	SUPERTYPE OF (ONEOF (edge_curve, oriented_edge, subedge))
+	SUBTYPE OF (topological_representation_item);
+	edge_start : vertex;
+	edge_end : vertex;
+END_ENTITY;
+
+
+ENTITY edge_based_wireframe_model
+	SUBTYPE OF (geometric_representation_item);
+	ebwm_boundary : SET [1:?] OF connected_edge_set;
+END_ENTITY;
+
+
+ENTITY edge_based_wireframe_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) >= 1;
+	WR3 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (edges)) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( pline_edges <* 
+QUERY ( edges <* eb.ces_edges| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (edges\edge_curve.edge_geometry)) )| NOT ( SIZEOF (pline_edges\edge_curve.edge_geometry\polyline.points) > 2) )) = 0) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (edges.edge_start)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (edges.edge_end))) )) = 0) )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT valid_wireframe_edge_curve(edges\edge_curve.edge_geometry) )) = 0) )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( ebwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( eb <* ebwm\edge_based_wireframe_model.ebwm_boundary| NOT ( SIZEOF ( 
+QUERY ( edges <* eb.ces_edges| NOT (valid_wireframe_vertex_point(edges.edge_start\vertex_point.vertex_geometry) AND valid_wireframe_vertex_point(edges.edge_end\vertex_point.vertex_geometry)) )) = 0) )) = 0) )) = 0;
+	WR8 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+	WR9 : SELF.context_of_items\geometric_representation_context.coordinate_space_dimension = 3;
+END_ENTITY;
+
+
+ENTITY edge_blended_solid
+	ABSTRACT SUPERTYPE OF ((track_blended_solid ANDOR ONEOF (solid_with_constant_radius_edge_blend, solid_with_variable_radius_edge_blend, solid_with_chamfered_edges)))
+	SUBTYPE OF (modified_solid);
+	blended_edges : LIST [1:?] OF  UNIQUE edge_curve;
+END_ENTITY;
+
+
+ENTITY edge_curve
+	SUBTYPE OF (edge, geometric_representation_item);
+	edge_geometry : curve;
+	same_sense : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY edge_loop
+	SUBTYPE OF (loop, path);
+DERIVE
+	ne : INTEGER := SIZEOF(SELF\path.edge_list);
+WHERE
+	WR1 : (SELF\path.edge_list[1].edge_start) :=:
+        (SELF\path.edge_list[ne].edge_end);
+END_ENTITY;
+
+
+ENTITY effectivity
+	SUPERTYPE OF (ONEOF (serial_numbered_effectivity, dated_effectivity, lot_effectivity, time_interval_based_effectivity));
+	id : identifier;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY effectivity_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_effectivity : effectivity;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY effectivity_context_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_effectivity_assignment : effectivity_assignment;
+	role : effectivity_context_role;
+END_ENTITY;
+
+
+ENTITY effectivity_context_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY effectivity_relationship;
+	name : label;
+	description : OPTIONAL text;
+	related_effectivity : effectivity;
+	relating_effectivity : effectivity;
+END_ENTITY;
+
+
+ENTITY electric_charge_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CHARGE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY electric_charge_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.coulomb);
+END_ENTITY;
+
+
+ENTITY electric_current_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CURRENT_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY electric_current_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 1.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY electric_potential_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_POTENTIAL_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY electric_potential_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.volt);
+END_ENTITY;
+
+
+ENTITY elementary_brep_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+          NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] *
+                   TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+         SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP',
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) =1 )) > 0;
+	WR3 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+            NOT (SIZEOF (QUERY(fcs <* csh.cfs_faces |
+              NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF(fcs)))) = 0
+                 ))) = 0
+                   ))) = 0;
+	WR4 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+            NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+              NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN
+                   TYPEOF(fcs\face_surface.face_geometry))
+             ))) = 0
+                 ))) = 0
+                   ))) = 0;
+	WR5 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                  NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN
+            TYPEOF(oe.edge_element)))) = 0
+                   ))) = 0
+                 ))) = 0
+               ))) = 0
+             ))) = 0;
+	WR6 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE'] *
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) = 1 )
+               )) = 0
+               ))) = 0
+                 ))) = 0
+                   ))) = 0
+                    ))) = 0;
+	WR7 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+            NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF(oe.edge_start))
+                AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+                 TYPEOF(oe.edge_end))
+            ))) = 0
+              ))) = 0
+               ))) = 0
+                 ))) = 0
+                   ))) = 0;
+	WR8 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+           NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+             NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) AND
+            (NOT (SIZEOF (oe\oriented_edge.edge_element\
+                  edge_curve.edge_geometry\polyline.points) >= 3))
+               )) = 0
+               ))) = 0
+                 ))) = 0
+                   ))) = 0
+                    ))) = 0;
+	WR9 : SIZEOF (QUERY (msb <* QUERY (it <* items |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF
+              (msb\manifold_solid_brep.outer)))
+             = 0;
+	WR10 : SIZEOF (QUERY (brv <* QUERY (it <* items |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BREP_WITH_VOIDS' IN TYPEOF(it)) |
+          NOT (SIZEOF (QUERY (csh <* brv\brep_with_voids.voids |
+           csh\oriented_closed_shell.orientation)) = 0))) = 0;
+	WR11 : SIZEOF (QUERY (mi <*  QUERY (it <* items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) |
+          NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_BREP_SHAPE_REPRESENTATION' IN
+             TYPEOF(mi\mapped_item.mapping_source.
+                           mapped_representation)))) = 0;
+	WR12 : SIZEOF (QUERY (msb <* QUERY (it <* SELF.items |
+            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF(it)) |
+            NOT (SIZEOF (QUERY (csh <* msb_shells(msb) |
+              NOT (SIZEOF (QUERY(fcs <* csh\connected_face_set.cfs_faces |
+               NOT (SIZEOF(QUERY (vlp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF(bnds.bound)) |
+           NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+               TYPEOF(vlp_fbnds\face_bound.bound\vertex_loop.loop_vertex)) AND
+                ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN
+                   TYPEOF(vlp_fbnds\face_bound.bound\vertex_loop.
+                     loop_vertex\vertex_point.vertex_geometry))
+            ))) = 0))) = 0))) = 0))) =0;
+END_ENTITY;
+
+
+ENTITY elementary_surface
+	SUPERTYPE OF (ONEOF (plane, cylindrical_surface, conical_surface, spherical_surface, toroidal_surface))
+	SUBTYPE OF (surface);
+	position : axis2_placement_3d;
+END_ENTITY;
+
+
+ENTITY ellipse
+	SUBTYPE OF (conic);
+	semi_axis_1 : positive_length_measure;
+	semi_axis_2 : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY energy_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ENERGY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY energy_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.joule);
+END_ENTITY;
+
+
+ENTITY entity_assertion
+	SUBTYPE OF (fact_type);
+END_ENTITY;
+
+
+ENTITY enum_reference_prefix
+	SUBTYPE OF (descriptive_representation_item);
+END_ENTITY;
+
+
+ENTITY environment;
+	syntactic_representation : generic_variable;
+	semantics : variable_semantics;
+END_ENTITY;
+
+
+ENTITY evaluated_characteristic
+	SUBTYPE OF (representation, representation_relationship);
+UNIQUE
+  UR1: SELF\representation_relationship.rep_1, SELF\representation_relationship.rep_2;
+WHERE
+	WR1 : SELF\representation_relationship.rep_1 <> 
+       SELF\representation_relationship.rep_2;
+END_ENTITY;
+
+
+ENTITY evaluated_degenerate_pcurve
+	SUBTYPE OF (degenerate_pcurve);
+	equivalent_point : cartesian_point;
+END_ENTITY;
+
+
+ENTITY evaluation_product_definition
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY event_occurrence;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY event_occurrence_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_event_occurrence : event_occurrence;
+	role : event_occurrence_role;
+END_ENTITY;
+
+
+ENTITY event_occurrence_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_event : event_occurrence;
+	related_event : event_occurrence;
+END_ENTITY;
+
+
+ENTITY event_occurrence_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY exclusive_product_concept_feature_category
+	SUBTYPE OF (product_concept_feature_category);
+END_ENTITY;
+
+
+ENTITY executed_action
+	SUBTYPE OF (action);
+END_ENTITY;
+
+
+ENTITY expanded_uncertainty
+	SUBTYPE OF (standard_uncertainty);
+	coverage_factor : REAL;
+END_ENTITY;
+
+
+ENTITY explicit_procedural_geometric_representation_item_relationship
+	SUBTYPE OF (explicit_procedural_representation_item_relationship);
+	SELF\representation_item_relationship.related_representation_item : geometric_representation_item;
+	SELF\representation_item_relationship.relating_representation_item : procedural_shape_representation_sequence;
+WHERE
+	WR1 : NOT (
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROCEDURAL_SHAPE_REPRESENTATION_SEQUENCE'
+    IN TYPEOF(
+      SELF\representation_item_relationship.related_representation_item));
+END_ENTITY;
+
+
+ENTITY explicit_procedural_representation_item_relationship
+	SUBTYPE OF (representation_item_relationship);
+	SELF\representation_item_relationship.relating_representation_item : procedural_representation_sequence;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROCEDURAL_REPRESENTATION_SEQUENCE'
+    IN TYPEOF(
+      SELF\representation_item_relationship.related_representation_item));
+	WR2 : SIZEOF(QUERY(q <* using_representations(
+    SELF\representation_item_relationship.related_representation_item) |
+    item_in_context(
+      SELF\representation_item_relationship.relating_representation_item,
+      q.context_of_items))) > 0;
+END_ENTITY;
+
+
+ENTITY explicit_procedural_representation_relationship
+	SUBTYPE OF (representation_relationship);
+	SELF\representation_relationship.rep_1 : procedural_representation;
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROCEDURAL_REPRESENTATION' 
+    IN TYPEOF(SELF\representation_relationship.rep_2))) AND 
+    (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VARIATIONAL_REPRESENTATION'
+    IN TYPEOF(SELF\representation_relationship.rep_2)));
+	WR2 : SELF\representation_relationship.rep_1.context_of_items :=:
+    SELF\representation_relationship.rep_2.context_of_items;
+END_ENTITY;
+
+
+ENTITY explicit_procedural_shape_representation_relationship
+	SUBTYPE OF (explicit_procedural_representation_relationship);
+	SELF\representation_relationship.rep_1 : procedural_shape_representation;
+	SELF\representation_relationship.rep_2 : shape_representation;
+END_ENTITY;
+
+
+ENTITY expression
+	ABSTRACT SUPERTYPE OF (ONEOF (numeric_expression, boolean_expression))
+	SUBTYPE OF (generic_expression);
+END_ENTITY;
+
+
+ENTITY expression_conversion_based_unit
+	SUBTYPE OF (context_dependent_unit, variable_semantics);
+INVERSE
+	associated_variable_environment: environment FOR semantics;
+END_ENTITY;
+
+
+ENTITY extension
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY extent
+	SUBTYPE OF (characterized_object);
+END_ENTITY;
+
+
+ENTITY external_class_library
+	SUBTYPE OF (external_source);
+END_ENTITY;
+
+
+ENTITY external_identification_assignment
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (identification_assignment);
+	source : external_source;
+END_ENTITY;
+
+
+ENTITY external_source;
+	source_id : source_item;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY external_source_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_source : external_source;
+	related_source : external_source;
+END_ENTITY;
+
+
+ENTITY externally_defined_class
+	SUBTYPE OF (class, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_colour
+	SUBTYPE OF (colour_specification, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_context_dependent_unit
+	SUBTYPE OF (context_dependent_unit, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_conversion_based_unit
+	SUBTYPE OF (conversion_based_unit, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_currency
+	SUBTYPE OF (currency, externally_defined_context_dependent_unit);
+END_ENTITY;
+
+
+ENTITY externally_defined_curve_font
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_dimension_definition
+	SUBTYPE OF (dimensional_size, externally_defined_item);
+WHERE
+	WR1 : (SELF\externally_defined_item.item_id = 'external size dimension') AND (SELF\externally_defined_item.source.source_id = 'external size dimension specification');
+	WR2 : 1 >= SIZEOF(QUERY ( adr <* USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLIED_DOCUMENT_REFERENCE.ITEMS')| (adr.assigned_document.description = 'external size dimension specification') ));
+END_ENTITY;
+
+
+ENTITY externally_defined_general_property
+	SUBTYPE OF (general_property, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_hatch_style
+	SUBTYPE OF (externally_defined_item, geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_item;
+	item_id : source_item;
+	source : external_source;
+END_ENTITY;
+
+
+ENTITY externally_defined_item_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_item : externally_defined_item;
+	related_item : externally_defined_item;
+END_ENTITY;
+
+
+ENTITY externally_defined_marker
+	SUBTYPE OF (externally_defined_symbol, pre_defined_marker);
+END_ENTITY;
+
+
+ENTITY externally_defined_picture_representation_item
+	SUBTYPE OF (picture_representation_item);
+INVERSE
+	source: applied_external_identification_assignment FOR items;
+WHERE
+	WR1 : NOT (SELF\representation_item.name IN pre_defined_picture_representation_types);
+END_ENTITY;
+
+
+ENTITY externally_defined_representation_item
+	SUBTYPE OF (representation_item, externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_string
+	SUBTYPE OF (externally_defined_representation_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_symbol
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_terminator_symbol
+	SUBTYPE OF (externally_defined_symbol);
+END_ENTITY;
+
+
+ENTITY externally_defined_text_font
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_tile
+	SUBTYPE OF (externally_defined_item);
+END_ENTITY;
+
+
+ENTITY externally_defined_tile_style
+	SUBTYPE OF (externally_defined_item, geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY extruded_area_solid
+	SUBTYPE OF (swept_area_solid);
+	extruded_direction : direction;
+	depth : positive_length_measure;
+WHERE
+	WR1 : dot_product(
+        (SELF\swept_area_solid.swept_area.basis_surface\
+        elementary_surface.position.p[3]), extruded_direction) <> 0.0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid
+	SUBTYPE OF (swept_face_solid);
+	extruded_direction : direction;
+	depth : positive_length_measure;
+WHERE
+	WR1 : dot_product(
+        (SELF\swept_face_solid.swept_face.face_geometry\
+        elementary_surface.position.p[3]), extruded_direction) <> 0.0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid_with_draft_angle
+	SUBTYPE OF (extruded_face_solid_with_trim_conditions);
+	draft_angle : plane_angle_measure;
+WHERE
+	WR1 : draft_angle <> 0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid_with_multiple_draft_angles
+	SUBTYPE OF (extruded_face_solid_with_trim_conditions);
+	drafted_edges : LIST [2:?] OF SET [1:?] OF edge_curve;
+	draft_angles : LIST [2:?] OF plane_angle_measure;
+WHERE
+	WR1 : SIZEOF(drafted_edges) = SIZEOF(draft_angles);
+	WR2 : SIZEOF(QUERY(q <* draft_angles | q = 0)) = 0;
+	WR3 : SIZEOF(QUERY(q <* drafted_edges | (SIZEOF(QUERY(r <* q | NOT 
+         (SELF\swept_face_solid.swept_face IN 
+          using_items(r,[])))) > 0))) = 0;
+END_ENTITY;
+
+
+ENTITY extruded_face_solid_with_trim_conditions
+	SUPERTYPE OF (ONEOF (extruded_face_solid_with_draft_angle, extruded_face_solid_with_multiple_draft_angles))
+	SUBTYPE OF (extruded_face_solid);
+	first_trim_condition : trim_condition_select;
+	second_trim_condition : trim_condition_select;
+	first_trim_intent : trim_intent;
+	second_trim_intent : trim_intent;
+	first_offset : non_negative_length_measure;
+	second_offset : non_negative_length_measure;
+WHERE
+	WR1 : NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(first_trim_condition)) OR
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(second_trim_condition)));
+	WR2 : NOT ((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition)) AND 
+         ((first_trim_intent = trim_intent.offset) 
+         OR (first_trim_intent = trim_intent.up_to_next))) OR  
+         (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition)) AND 
+         ((second_trim_intent = trim_intent.offset) 
+         OR (second_trim_intent = trim_intent.up_to_next))));
+	WR3 : NOT (((NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition))) AND 
+         ((first_trim_intent = trim_intent.blind) 
+         OR (first_trim_intent = trim_intent.through_all))) OR  
+         ((NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition))) AND 
+         ((second_trim_intent = trim_intent.blind) 
+         OR (second_trim_intent = trim_intent.through_all))));
+	WR4 : (((first_trim_intent = trim_intent.offset) 
+           AND (first_offset > 0)) XOR
+         ((first_trim_intent <> trim_intent.offset) 
+           AND (first_offset = 0))) AND 
+         (((second_trim_intent = trim_intent.offset) 
+           AND (second_offset > 0)) XOR
+         ((second_trim_intent <> trim_intent.offset) 
+            AND (second_offset = 0)));
+	WR5 : NOT((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition)) AND
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition))) AND
+         (first_trim_condition = second_trim_condition));
+END_ENTITY;
+
+
+ENTITY face
+	SUPERTYPE OF (ONEOF (face_surface, subface, oriented_face))
+	SUBTYPE OF (topological_representation_item);
+	bounds : SET [1:?] OF face_bound;
+WHERE
+	WR1 : NOT (mixed_loop_type_set(list_to_set(list_face_loops(SELF))));
+	WR2 : SIZEOF(QUERY(temp <* bounds | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_OUTER_BOUND' IN
+                                               TYPEOF(temp))) <= 1;
+END_ENTITY;
+
+
+ENTITY face_based_surface_model
+	SUBTYPE OF (geometric_representation_item);
+	fbsm_faces : SET [1:?] OF connected_face_set;
+END_ENTITY;
+
+
+ENTITY face_bound
+	SUBTYPE OF (topological_representation_item);
+	bound : loop;
+	orientation : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY face_outer_bound
+	SUBTYPE OF (face_bound);
+END_ENTITY;
+
+
+ENTITY face_surface
+	SUBTYPE OF (face, geometric_representation_item);
+	face_geometry : surface;
+	same_sense : BOOLEAN;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_SURFACE' IN TYPEOF(face_geometry));
+END_ENTITY;
+
+
+ENTITY faceted_brep
+	SUBTYPE OF (manifold_solid_brep);
+END_ENTITY;
+
+
+ENTITY faceted_brep_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) > 0;
+	WR3 : SIZEOF ( 
+QUERY ( fbrep <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* msb_shells(fbrep)| NOT ( SIZEOF ( 
+QUERY ( fcs <* csh\connected_face_set.cfs_faces| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF (fcs)) AND (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF (fcs\face_surface.face_geometry)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (fcs\face_surface.face_geometry\elementary_surface.position.location)))) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( fbrep <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* msb_shells(fbrep)| NOT ( SIZEOF ( 
+QUERY ( fcs <* csh\connected_face_set.cfs_faces| NOT ( SIZEOF ( 
+QUERY ( bnds <* fcs.bounds| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_OUTER_BOUND' IN TYPEOF (bnds)) )) = 1) )) = 0) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( msb <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SOLID_BREP' IN TYPEOF (it)) )| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF (msb\manifold_solid_brep.outer)) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( brv <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BREP_WITH_VOIDS' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( csh <* brv\brep_with_voids.voids| csh\oriented_closed_shell.orientation )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACETED_BREP_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+END_ENTITY;
+
+
+ENTITY fact_type
+	SUBTYPE OF (property_definition);
+END_ENTITY;
+
+
+ENTITY fill_area_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	fill_styles : SET [1:?] OF fill_style_select;
+WHERE
+	WR1 : SIZEOF(QUERY(fill_style <* SELF.fill_styles |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'FILL_AREA_STYLE_COLOUR' IN
+         TYPEOF(fill_style)
+         )) <= 1;
+END_ENTITY;
+
+
+ENTITY fill_area_style_colour;
+	name : label;
+	fill_colour : colour;
+END_ENTITY;
+
+
+ENTITY fill_area_style_hatching
+	SUBTYPE OF (geometric_representation_item);
+	hatch_line_appearance : curve_style;
+	start_of_next_hatch_line : one_direction_repeat_factor;
+	point_of_reference_hatch_line : cartesian_point;
+	pattern_start : cartesian_point;
+	hatch_line_angle : plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY fill_area_style_tile_coloured_region
+	SUBTYPE OF (geometric_representation_item);
+	closed_curve : curve_or_annotation_curve_occurrence;
+	region_colour : colour;
+WHERE
+	WR1 : (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF (closed_curve))) OR 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE' IN TYPEOF (closed_curve)) OR 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE' IN TYPEOF (closed_curve)) OR 
+        ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (closed_curve)) 
+             AND (closed_curve\b_spline_curve.closed_curve = TRUE) ) OR 
+        ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF (closed_curve)) 
+             AND (closed_curve\composite_curve.closed_curve = TRUE) ) OR 
+        ( ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (closed_curve)) 
+             AND (closed_curve\polyline.points[LOINDEX(closed_curve\polyline.points)] = 
+                  closed_curve\polyline.points[HIINDEX(closed_curve\polyline.points)]) );
+END_ENTITY;
+
+
+ENTITY fill_area_style_tile_curve_with_style
+	SUBTYPE OF (geometric_representation_item);
+	styled_curve : annotation_curve_occurrence;
+END_ENTITY;
+
+
+ENTITY fill_area_style_tile_symbol_with_style
+	SUBTYPE OF (geometric_representation_item);
+	symbol : annotation_symbol_occurrence;
+END_ENTITY;
+
+
+ENTITY fill_area_style_tiles
+	SUBTYPE OF (geometric_representation_item);
+	tiling_pattern : two_direction_repeat_factor;
+	tiles : SET [1:?] OF fill_area_style_tile_shape_select;
+	tiling_scale : positive_ratio_measure;
+END_ENTITY;
+
+
+ENTITY flat_pattern_ply_representation_relationship
+	SUBTYPE OF (shape_representation_relationship);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN
+        (TYPEOF (SELF\representation_relationship.rep_1) *
+         TYPEOF (SELF\representation_relationship.rep_2));
+	WR2 : SELF\representation_relationship.rep_1.
+        context_of_items\geometric_representation_context.
+        coordinate_space_dimension = 3;
+END_ENTITY;
+
+
+ENTITY flatness_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY force_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FORCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY force_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.newton);
+END_ENTITY;
+
+
+ENTITY forward_chaining_rule
+	SUBTYPE OF (rule_definition);
+END_ENTITY;
+
+
+ENTITY forward_chaining_rule_premise
+	SUBTYPE OF (property_definition, property_definition_representation, representation);
+END_ENTITY;
+
+
+ENTITY founded_item
+	SUPERTYPE OF (ONEOF (character_glyph_style_outline, character_glyph_style_stroke, curve_style, curve_style_font, curve_style_font_and_scaling, curve_style_font_pattern, fill_area_style, point_style, presentation_style_assignment, surface_side_style, surface_style_boundary, surface_style_control_grid, surface_style_fill_area, surface_style_parameter_line, surface_style_segmentation_curve, surface_style_silhouette, surface_style_usage, symbol_style, text_style));
+DERIVE
+	users : SET [0:?] OF founded_item_select := using_items(SELF,[]);
+WHERE
+	WR1 : SIZEOF(users) > 0;
+	WR2 : NOT(SELF IN users);
+END_ENTITY;
+
+
+ENTITY frequency_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FREQUENCY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY frequency_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.hertz);
+END_ENTITY;
+
+
+ENTITY func
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY functional_breakdown_context
+	SUBTYPE OF (breakdown_context);
+END_ENTITY;
+
+
+ENTITY functional_element_usage
+	SUBTYPE OF (breakdown_element_usage);
+END_ENTITY;
+
+
+ENTITY functionally_defined_transformation;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY general_material_property
+	SUBTYPE OF (general_property);
+WHERE
+	WR1 : SIZEOF( QUERY( gpa <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GENERAL_PROPERTY_ASSOCIATION.BASE_DEFINITION') | 
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MATERIAL_PROPERTY' IN TYPEOF(gpa.derived_definition)) )) = 0;
+END_ENTITY;
+
+
+ENTITY general_property;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY general_property_association;
+	name : label;
+	description : OPTIONAL text;
+	base_definition : general_property;
+	derived_definition : derived_property_select;
+WHERE
+	WR1 : SIZEOF(USEDIN(derived_definition, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GENERAL_PROPERTY_ASSOCIATION.' + 'DERIVED_DEFINITION')) = 1;
+	WR2 : derived_definition.name = base_definition.name;
+END_ENTITY;
+
+
+ENTITY general_property_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_property : general_property;
+	related_property : general_property;
+END_ENTITY;
+
+
+ENTITY generic_character_glyph_symbol
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (symbol_representation);
+END_ENTITY;
+
+
+ENTITY generic_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (simple_generic_expression, unary_generic_expression, binary_generic_expression, multiple_arity_generic_expression));
+WHERE
+	WR1 : is_acyclic(SELF);
+END_ENTITY;
+
+
+ENTITY generic_literal
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (simple_generic_expression);
+END_ENTITY;
+
+
+ENTITY generic_variable
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (simple_generic_expression);
+INVERSE
+	interpretation: environment FOR syntactic_representation;
+END_ENTITY;
+
+
+ENTITY geometric_alignment
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)> 1;
+END_ENTITY;
+
+
+ENTITY geometric_curve_set
+	SUBTYPE OF (geometric_set);
+WHERE
+	WR1 : SIZEOF(QUERY(temp <* SELF\geometric_set.elements |
+                            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(temp))) = 0;
+END_ENTITY;
+
+
+ENTITY geometric_intersection
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)> 1;
+END_ENTITY;
+
+
+ENTITY geometric_item_specific_usage
+	SUBTYPE OF (item_identified_representation_usage);
+	SELF\item_identified_representation_usage.definition : geometric_item_specific_usage_select;
+	SELF\item_identified_representation_usage.identified_item : geometric_representation_item;
+	SELF\item_identified_representation_usage.used_representation : shape_representation;
+END_ENTITY;
+
+
+ENTITY geometric_model_element_relationship
+	SUBTYPE OF (geometric_representation_item, representation_item_relationship);
+	SELF\representation_item_relationship.related_representation_item : geometric_representation_item;
+	SELF\representation_item_relationship.relating_representation_item : geometric_representation_item;
+UNIQUE
+	UR1 : relating_representation_item, related_representation_item;
+WHERE
+	WR1 : SELF\representation_item_relationship.relating_representation_item :<>: 
+        SELF\representation_item_relationship.related_representation_item;
+END_ENTITY;
+
+
+ENTITY geometric_representation_context
+	SUBTYPE OF (representation_context);
+	coordinate_space_dimension : dimension_count;
+END_ENTITY;
+
+
+ENTITY geometric_representation_item
+	SUPERTYPE OF (ONEOF (point, direction, vector, placement, cartesian_transformation_operator, curve, surface, edge_curve, face_surface, poly_loop, vertex_point, solid_model, boolean_result, sphere, right_circular_cone, right_circular_cylinder, torus, block, right_angular_wedge, half_space_solid, shell_based_surface_model, face_based_surface_model, shell_based_wireframe_model, edge_based_wireframe_model, geometric_set, camera_model, camera_model_d3_multi_clipping_intersection, camera_model_d3_multi_clipping_union, light_source))
+	SUBTYPE OF (representation_item);
+DERIVE
+	dim : dimension_count := dimension_of(SELF);
+WHERE
+	WR1 : SIZEOF (QUERY (using_rep <* using_representations (SELF) |
+      NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_REPRESENTATION_CONTEXT' IN
+      TYPEOF (using_rep.context_of_items)))) = 0;
+END_ENTITY;
+
+
+ENTITY geometric_set
+	SUBTYPE OF (geometric_representation_item);
+	elements : SET [1:?] OF geometric_set_select;
+END_ENTITY;
+
+
+ENTITY geometric_tolerance;
+	name : label;
+	description : text;
+	magnitude : measure_with_unit;
+	toleranced_shape_aspect : shape_aspect;
+WHERE
+	WR1 : ('NUMBER' IN TYPEOF
+       (magnitude\measure_with_unit.value_component)) AND
+       (magnitude\measure_with_unit.value_component >= 0.0);
+END_ENTITY;
+
+
+ENTITY geometric_tolerance_relationship;
+	name : label;
+	description : text;
+	relating_geometric_tolerance : geometric_tolerance;
+	related_geometric_tolerance : geometric_tolerance;
+END_ENTITY;
+
+
+ENTITY geometric_tolerance_with_datum_reference
+	SUBTYPE OF (geometric_tolerance);
+	datum_system : SET [1:?] OF datum_reference;
+END_ENTITY;
+
+
+ENTITY geometric_tolerance_with_defined_unit
+	SUBTYPE OF (geometric_tolerance);
+	unit_size : measure_with_unit;
+WHERE
+	WR1 : ('NUMBER' IN TYPEOF
+       (unit_size\measure_with_unit.value_component)) AND
+       (unit_size\measure_with_unit.value_component > 0.0);
+END_ENTITY;
+
+
+ENTITY geometrical_tolerance_callout
+	SUBTYPE OF (draughting_callout);
+END_ENTITY;
+
+
+ENTITY geometrically_bounded_2d_wireframe_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SELF.context_of_items\geometric_representation_context.
+            coordinate_space_dimension = 2;
+	WR2 : SIZEOF (QUERY (item <* SELF.items |
+         NOT (SIZEOF (TYPEOF (item) *
+['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET',          
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_2D',
+            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM']) = 1)
+       )) = 0;
+	WR3 : SIZEOF (QUERY (item <* SELF.items |
+         SIZEOF (TYPEOF (item) *          
+['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET',
+            'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM']) = 1
+       )) >= 1;
+	WR4 : SIZEOF (QUERY (mi <* QUERY (item <* SELF.items |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+           IN TYPEOF (item))) |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+              'GEOMETRICALLY_BOUNDED_2D_WIREFRAME_REPRESENTATION'
+           IN TYPEOF
+              (mi\mapped_item.mapping_source.mapped_representation))
+       )) = 0;
+	WR5 : SIZEOF (QUERY (gcs <* QUERY (item <* SELF.items |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET'
+                IN TYPEOF (item))) |
+         NOT (SIZEOF (QUERY (elem <* gcs\geometric_set.elements |
+           NOT (SIZEOF (TYPEOF (elem) *
+             ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_2D',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+              'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE']) =
+               1)
+         )) = 0)
+       )) = 0;
+	WR6 : SIZEOF (QUERY (gcs <* QUERY (item <* SELF.items |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET'
+                IN TYPEOF (item))) |
+         NOT (SIZEOF (QUERY (crv <* 
+           QUERY (elem <* gcs\geometric_set.elements |
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE'
+                   IN TYPEOF (elem))) |
+           NOT (valid_basis_curve_in_2d_wireframe
+              (crv))
+         )) = 0)
+       )) = 0;
+	WR7 : SIZEOF (QUERY (gcs <* QUERY (item <* SELF.items |         
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET'
+                IN TYPEOF (item))) |
+         NOT (SIZEOF (QUERY (pnt <*
+           QUERY (elem <* gcs\geometric_set.elements |
+             ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT'
+                  IN TYPEOF(elem))) |
+             NOT (SIZEOF (TYPEOF (pnt) *
+               ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE'])
+          = 1)
+         )) = 0)
+       )) = 0;
+END_ENTITY;
+
+
+ENTITY geometrically_bounded_surface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF(QUERY(it <* SELF.items | NOT (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] * TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF(QUERY(it <* SELF.items | SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) = 1)) > 0;
+	WR3 : SIZEOF(QUERY(mi <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) | NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION' IN TYPEOF(mi\mapped_item.mapping_source.mapped_representation)) AND (SIZEOF(QUERY(mr_it <* mi\mapped_item.mapping_source.mapped_representation.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(mr_it)))) > 0)))) = 0;
+	WR4 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | NOT (SIZEOF(QUERY(pnt <* QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT' IN TYPEOF(gsel)) | NOT (gbsf_check_point(pnt)))) = 0))) = 0;
+	WR5 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | NOT (SIZEOF(QUERY(cv <* QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF(gsel)) | NOT (gbsf_check_curve(cv)))) = 0))) = 0;
+	WR6 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | NOT (SIZEOF(QUERY(sf <* QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(gsel)) | NOT (gbsf_check_surface(sf)))) = 0))) = 0;
+	WR7 : SIZEOF(QUERY(gs <* QUERY(it <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_SET' IN TYPEOF(it)) | SIZEOF(QUERY(gsel <* gs\geometric_set.elements | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(gsel))) > 0)) > 0;
+END_ENTITY;
+
+
+ENTITY geometrically_bounded_wireframe_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ( TYPEOF (it) * [ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ]) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ( TYPEOF (it) * [ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ]) = 1) )) >= 1;
+	WR3 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( crv <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF (elem)) )| NOT valid_geometrically_bounded_wf_curve(crv) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( pnts <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT' IN TYPEOF (elem)) )| NOT valid_geometrically_bounded_wf_point(pnts) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( cnc <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC' IN TYPEOF (elem)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' IN TYPEOF (cnc\conic.position)) )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( gcs <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRIC_CURVE_SET' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( pline <* 
+QUERY ( elem <* gcs\geometric_set.elements| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (elem)) )| NOT ( SIZEOF (pline\polyline.points) > 2) )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+END_ENTITY;
+
+
+ENTITY global_assignment
+	SUBTYPE OF (representation_item_relationship);
+END_ENTITY;
+
+
+ENTITY global_uncertainty_assigned_context
+	SUBTYPE OF (representation_context);
+	uncertainty : SET [1:?] OF uncertainty_measure_with_unit;
+END_ENTITY;
+
+
+ENTITY global_unit_assigned_context
+	SUBTYPE OF (representation_context);
+	units : SET [1:?] OF unit;
+END_ENTITY;
+
+
+ENTITY ground_fact
+	SUBTYPE OF (atomic_formula);
+END_ENTITY;
+
+
+ENTITY group;
+	name : label;
+	description : OPTIONAL text;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY group_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_group : group;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY group_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_group : group;
+	related_group : group;
+END_ENTITY;
+
+
+ENTITY half_space_solid
+	SUBTYPE OF (geometric_representation_item);
+	base_surface : surface;
+	agreement_flag : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY hardness_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ( {2<= SIZEOF ( SELF.items ) <=4} ) AND ( SIZEOF ( QUERY (
+        i <* items | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND (
+        i.name IN [ 'measuring method' , 'measuring position' ] ) )
+        ) + SIZEOF ( QUERY ( i <* items | ( SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) =1 )
+        AND ( i.name IN ['depth' , 'hardness'] ) ) ) = SIZEOF (
+        SELF.items ) );
+	WR2 : SIZEOF ( QUERY ( i <* SELF.items | i.name =
+        'measuring method' ) ) =1;
+	WR3 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='hardness' ) )
+        =1;
+	WR4 : SIZEOF ( QUERY ( i <* SELF.items | i.name =
+        'measuring position' ) ) <=1;
+	WR5 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='depth' ) )
+        <=1;
+	WR6 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )
+        ) =1 );
+END_ENTITY;
+
+
+ENTITY hidden_element_over_riding_styled_item
+	SUBTYPE OF (context_dependent_over_riding_styled_item);
+	SELF\styled_item.item : camera_image;
+	SELF\context_dependent_over_riding_styled_item.style_context : LIST [1:1] OF presentation_view;
+INVERSE
+	container: SET [1:?] OF presentation_view FOR items;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAMERA_MODEL_D3_WITH_HLHSR' IN TYPEOF
+                (SELF.item\mapped_item.mapping_source.mapping_origin);
+END_ENTITY;
+
+
+ENTITY hyperbola
+	SUBTYPE OF (conic);
+	semi_axis : positive_length_measure;
+	semi_imag_axis : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY id_attribute;
+	attribute_value : identifier;
+	identified_item : id_attribute_select;
+END_ENTITY;
+
+
+ENTITY identification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_id : identifier;
+	role : identification_role;
+END_ENTITY;
+
+
+ENTITY identification_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY illuminance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ILLUMINANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY illuminance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.lux);
+END_ENTITY;
+
+
+ENTITY included_text_block
+	SUBTYPE OF (mapped_item);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRUCTURED_TEXT_REPRESENTATION' IN TYPEOF(SELF\mapped_item.mapping_source.mapped_representation);
+END_ENTITY;
+
+
+ENTITY inclusion_product_concept_feature
+	SUBTYPE OF (conditional_concept_feature);
+WHERE
+	WR1 : NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PACKAGE_PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( SELF ) );
+	WR2 : SIZEOF (QUERY
+									( cfr <* USEDIN 
+											( SELF ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP.RELATING_PRODUCT_CONCEPT_FEATURE' ) 
+											| 
+											'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION' IN TYPEOF( cfr ) 
+									) 
+								) + 
+				 SIZEOF(QUERY
+				 					( cfr <* USEDIN 
+				 							(SELF , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP.RELATED_PRODUCT_CONCEPT_FEATURE' ) 
+				 							| 
+											'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION' IN TYPEOF(cfr)
+									)
+								)= 0;
+	WR3 : SELF.condition.conditional_operator.name = 'implication';
+END_ENTITY;
+
+
+ENTITY indirectly_selected_elements
+	SUBTYPE OF (user_selected_elements);
+	indirectly_picked_items : SET [1:?] OF representation_item;
+END_ENTITY;
+
+
+ENTITY indirectly_selected_shape_elements
+	SUBTYPE OF (indirectly_selected_elements, user_selected_shape_elements);
+WHERE
+	WR1 : SIZEOF(QUERY(q <*
+    SELF\indirectly_selected_elements.indirectly_picked_items
+    | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_ITEM'
+    IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY inductance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INDUCTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY inductance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.henry);
+END_ENTITY;
+
+
+ENTITY information_right
+	SUBTYPE OF (action_method);
+END_ENTITY;
+
+
+ENTITY information_usage_right
+	SUBTYPE OF (action_method);
+END_ENTITY;
+
+
+ENTITY instance_usage_context_assignment
+	SUBTYPE OF (product_definition_context);
+	items : SET [1:?] OF instance_usage_context_select;
+END_ENTITY;
+
+
+ENTITY instanced_feature
+	SUBTYPE OF (shape_aspect, shape_feature_definition);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN
+         TYPEOF(SELF\shape_aspect.of_shape.definition);
+	WR2 : SELF\shape_aspect.product_definitional;
+END_ENTITY;
+
+
+ENTITY int_literal
+	SUBTYPE OF (literal_number);
+	SELF\literal_number.the_value : INTEGER;
+END_ENTITY;
+
+
+ENTITY integer_representation_item
+	SUBTYPE OF (representation_item, int_literal);
+END_ENTITY;
+
+
+ENTITY intersection_curve
+	SUBTYPE OF (surface_curve);
+WHERE
+	WR1 : SIZEOF(SELF\surface_curve.associated_geometry) = 2;
+	WR2 : associated_surface(SELF\surface_curve.associated_geometry[1]) <>
+             associated_surface(SELF\surface_curve.associated_geometry[2]);
+END_ENTITY;
+
+
+ENTITY interval_expression
+	SUBTYPE OF (boolean_expression, multiple_arity_generic_expression);
+DERIVE
+	interval_high : generic_expression := SELF\multiple_arity_generic_expression.operands[3];
+	interval_item : generic_expression := SELF\multiple_arity_generic_expression.operands[2];
+	interval_low : generic_expression := SELF\multiple_arity_generic_expression.operands[1];
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXPRESSION' 
+				IN TYPEOF(interval_low))
+		AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXPRESSION' 
+				IN TYPEOF(interval_item) )
+		AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXPRESSION' 
+				IN TYPEOF(interval_high));
+	WR2 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+				IN TYPEOF (SELF.interval_low)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION'  
+				IN TYPEOF (SELF.interval_high)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+				IN TYPEOF (SELF.interval_item))) 
+		OR
+		(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_EXPRESSION' 
+				IN TYPEOF(SELF.interval_low)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+				IN TYPEOF(SELF.interval_item)) 
+			AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_EXPRESSION' 
+				IN TYPEOF(SELF.interval_high)));
+END_ENTITY;
+
+
+ENTITY invisibility;
+	invisible_items : SET [1:?] OF invisible_item;
+END_ENTITY;
+
+
+ENTITY iso4217_currency
+	SUBTYPE OF (currency);
+END_ENTITY;
+
+
+ENTITY item_defined_transformation;
+	name : label;
+	description : OPTIONAL text;
+	transform_item_1 : representation_item;
+	transform_item_2 : representation_item;
+END_ENTITY;
+
+
+ENTITY item_identified_representation_usage;
+	name : label;
+	description : OPTIONAL text;
+	definition : represented_definition;
+	used_representation : representation;
+	identified_item : representation_item;
+WHERE
+	WR1 : SELF.used_representation IN using_representations(SELF.identified_item);
+END_ENTITY;
+
+
+ENTITY known_source
+	SUBTYPE OF (external_source, pre_defined_item);
+END_ENTITY;
+
+
+ENTITY laid_defined_transformation
+	SUBTYPE OF (transformation_with_derived_angle);
+END_ENTITY;
+
+
+ENTITY laminate_table
+	SUPERTYPE OF (ONEOF (part_laminate_table, zone_structural_makeup))
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY language
+	SUBTYPE OF (group);
+WHERE
+	WR1 : SELF\group.name <> '';
+END_ENTITY;
+
+
+ENTITY leader_curve
+	SUBTYPE OF (annotation_curve_occurrence);
+WHERE
+	WR1 : SIZEOF( 
+          QUERY(ldc <* USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                       'DRAUGHTING_CALLOUT.CONTENTS')
+                   |   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                       'LEADER_DIRECTED_CALLOUT'  IN TYPEOF(ldc))) >= 1;
+END_ENTITY;
+
+
+ENTITY leader_directed_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (l_1 <* SELF\draughting_callout.contents |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN (TYPEOF(l_1)))) >= 1;
+	WR2 : SIZEOF(SELF\draughting_callout.contents) >=2;
+END_ENTITY;
+
+
+ENTITY leader_directed_dimension
+	SUBTYPE OF (leader_directed_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (con <* SELF.contents |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN TYPEOF (con)))=1;
+END_ENTITY;
+
+
+ENTITY leader_terminator
+	SUBTYPE OF (terminator_symbol);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_CURVE' IN TYPEOF
+        (SELF\terminator_symbol.annotated_curve);
+END_ENTITY;
+
+
+ENTITY length_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY length_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 1.0) AND 
+    (SELF\named_unit.dimensions.mass_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.time_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND 
+    (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY light_source
+	SUPERTYPE OF (ONEOF (light_source_ambient, light_source_directional, light_source_positional, light_source_spot))
+	SUBTYPE OF (geometric_representation_item);
+	light_colour : colour;
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                              'STYLED_ITEM.ITEM')) = 0;
+END_ENTITY;
+
+
+ENTITY light_source_ambient
+	SUBTYPE OF (light_source);
+END_ENTITY;
+
+
+ENTITY light_source_directional
+	SUBTYPE OF (light_source);
+	orientation : direction;
+END_ENTITY;
+
+
+ENTITY light_source_positional
+	SUBTYPE OF (light_source);
+	position : cartesian_point;
+	constant_attenuation : REAL;
+	distance_attenuation : REAL;
+END_ENTITY;
+
+
+ENTITY light_source_spot
+	SUBTYPE OF (light_source);
+	position : cartesian_point;
+	orientation : direction;
+	concentration_exponent : REAL;
+	constant_attenuation : REAL;
+	distance_attenuation : REAL;
+	spread_angle : positive_plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY limits_and_fits;
+	form_variance : label;
+	zone_variance : label;
+	grade : label;
+	source : text;
+END_ENTITY;
+
+
+ENTITY line
+	SUBTYPE OF (curve);
+	pnt : cartesian_point;
+	dir : vector;
+WHERE
+	WR1 : dir.dim  = pnt.dim;
+END_ENTITY;
+
+
+ENTITY line_profile_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF)) OR ( SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3);
+	WR2 : SIZEOF ( 
+QUERY ( sar <* USEDIN (SELF\geometric_tolerance.toleranced_shape_aspect, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'SHAPE_ASPECT_RELATIONSHIP.RELATING_SHAPE_ASPECT')| (sar.name IN [ 'affected plane association', 'resulting intersection curve association' ]) )) = 1;
+END_ENTITY;
+
+
+ENTITY linear_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+END_ENTITY;
+
+
+ENTITY literal_conjunction
+	SUBTYPE OF (simple_clause);
+END_ENTITY;
+
+
+ENTITY literal_disjunction
+	SUBTYPE OF (simple_clause);
+END_ENTITY;
+
+
+ENTITY literal_number
+	ABSTRACT SUPERTYPE OF (ONEOF (int_literal, real_literal))
+	SUBTYPE OF (simple_numeric_expression, generic_literal);
+	the_value : NUMBER;
+END_ENTITY;
+
+
+ENTITY local_time;
+	hour_component : hour_in_day;
+	minute_component : OPTIONAL minute_in_hour;
+	second_component : OPTIONAL second_in_minute;
+	zone : coordinated_universal_time_offset;
+WHERE
+	WR1 : valid_time (SELF);
+END_ENTITY;
+
+
+ENTITY logical_literal
+	SUBTYPE OF (generic_literal);
+	lit_value : LOGICAL;
+END_ENTITY;
+
+
+ENTITY logical_representation_item
+	SUBTYPE OF (representation_item, logical_literal);
+END_ENTITY;
+
+
+ENTITY loop
+	SUPERTYPE OF (ONEOF (vertex_loop, edge_loop, poly_loop))
+	SUBTYPE OF (topological_representation_item);
+END_ENTITY;
+
+
+ENTITY loss_tangent_measure_with_unit
+	SUBTYPE OF (ratio_measure_with_unit);
+END_ENTITY;
+
+
+ENTITY lot_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_lot_id : identifier;
+	effectivity_lot_size : measure_with_unit;
+END_ENTITY;
+
+
+ENTITY luminous_flux_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_FLUX_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY luminous_flux_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.lumen);
+END_ENTITY;
+
+
+ENTITY luminous_intensity_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_INTENSITY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY luminous_intensity_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 1.0);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_density_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_DENSITY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_density_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.tesla);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY magnetic_flux_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.weber);
+END_ENTITY;
+
+
+ENTITY make_from_usage_option
+	SUBTYPE OF (product_definition_usage);
+	ranking : INTEGER;
+	ranking_rationale : text;
+	quantity : measure_with_unit;
+WHERE
+	WR1 : (NOT ('NUMBER' IN TYPEOF(quantity.value_component)))
+       OR (quantity.value_component > 0);
+END_ENTITY;
+
+
+ENTITY manifold_solid_brep
+	SUBTYPE OF (solid_model);
+	outer : closed_shell;
+END_ENTITY;
+
+
+ENTITY manifold_subsurface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+          NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] *
+                   TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+         SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET',
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF(it)) =1 )) > 0;
+	WR3 : SIZEOF (QUERY (mi <*  QUERY (it <* items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF(it)) |
+   NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SUBSURFACE_SHAPE_REPRESENTATION' IN
+             TYPEOF(mi\mapped_item.mapping_source.
+                           mapped_representation)))) = 0;
+	WR4 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+          NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL' IN TYPEOF(cfss)))) = 0;
+	WR5 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+          NOT( (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN
+                   TYPEOF(cfss\connected_face_sub_set.parent_face_set))AND
+           (SIZEOF(QUERY(fac <* cfss\connected_face_sub_set.parent_face_set\connected_face_set.cfs_faces | NOT
+                 advanced_face_properties(fac))) = 0)) OR
+            (SIZEOF(QUERY(fac <* cfss\connected_face_sub_set.parent_face_set\connected_face_set.cfs_faces | NOT
+              ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF(fac)))) = 0)
+                    ))) = 0;
+	WR6 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+          ( SIZEOF (QUERY (fac <* cfss\connected_face_set.cfs_faces  | NOT
+              advanced_face_properties(fac))) = 0))) = 0;
+	WR7 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+               ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+            NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                  NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN
+            TYPEOF(oe.edge_element)) OR
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBEDGE' IN
+            TYPEOF(oe.edge_element)) ))) = 0
+                   ))) = 0
+                 ))) = 0
+             ))) = 0;
+	WR8 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+               NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+          NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF(oe.edge_start))
+                AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+                 TYPEOF(oe.edge_end))
+            ))) = 0
+              ))) = 0
+               ))) = 0
+                   ))) = 0;
+	WR9 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+              ( NOT (SIZEOF(QUERY  (bnds <* fcs.bounds |
+         NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP',
+                'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP'] *
+                   TYPEOF(bnds.bound)) = 1 )
+                   )) = 0)
+                 ))) = 0
+             ))) = 0;
+	WR10 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+              ( NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                 NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' ] *
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) = 1 )
+               )) = 0
+               ))) = 0
+                 )))) = 0
+                    ))) = 0;
+	WR11 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+               (NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) AND
+            (NOT ((SIZEOF (QUERY (sc_ag <*
+            oe.edge_element\edge_curve.edge_geometry\
+            surface_curve.associated_geometry |
+            NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+            TYPEOF(sc_ag)))) = 0)))
+               )) = 0
+               ))) = 0
+                   )))) = 0
+                    ))) = 0;
+	WR12 : SIZEOF (QUERY (cfss <* QUERY (it <* SELF.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONNECTED_FACE_SUB_SET' IN TYPEOF(it)) |
+             NOT (SIZEOF (QUERY(fcs <* cfss\connected_face_set.cfs_faces |
+              ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(fcs)) AND
+               (NOT (SIZEOF(QUERY (elp_fbnds <* QUERY (bnds <* fcs.bounds |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF(bnds.bound)) |
+                NOT (SIZEOF (QUERY (oe <* elp_fbnds.bound\path.edge_list |
+                   ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN
+            TYPEOF(oe.edge_element\edge_curve.edge_geometry)) AND
+            (NOT (SIZEOF (oe\oriented_edge.edge_element\
+                  edge_curve.edge_geometry\polyline.points) >= 3))
+               )) = 0
+               ))) = 0
+                   )))) = 0
+                    ))) = 0;
+END_ENTITY;
+
+
+ENTITY manifold_surface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] * TYPEOF (it)) = 1))) = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+       SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF (it)) = 1)) > 0;
+	WR3 : SIZEOF (QUERY (mi <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MANIFOLD_SURFACE_SHAPE_REPRESENTATION'
+       IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation))
+       AND
+       (SIZEOF(QUERY (mr_it <*
+       mi\mapped_item.mapping_source.mapped_representation.items |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL'
+       IN TYPEOF (mr_it)))) > 0 )))) = 0;
+	WR4 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (sh <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLOSED_SHELL']
+       * TYPEOF (sh)) = 1))) = 0))) = 0;
+	WR5 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF (fa)) )) = 0)))
+       = 0))) = 0;
+	WR6 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (msf_surface_check(fa\face_surface.face_geometry))))) = 0))) 
+       = 0))) = 0;
+	WR7 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (bnds <* fa.bounds |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP']
+       * TYPEOF (bnds.bound)) = 1))) = 0)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items|
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF 
+       (oe.edge_element)))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR9 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe_cv <* QUERY (oe <* 
+       elp_fbnds\path.edge_list |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (oe.edge_element)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE'] * 
+       TYPEOF (oe_cv.edge_element\edge_curve.edge_geometry)) 
+       = 1))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR10 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT (msf_curve_check (oe.edge_element\edge_curve.edge_geometry)))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR11 : SIZEOF (QUERY(sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list|
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (oe.edge_element.edge_start))
+       AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+       TYPEOF (oe.edge_element.edge_end))))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ((SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_start\vertex_point.vertex_geometry)) = 1)
+       AND
+       (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_end\vertex_point.vertex_geometry)) = 1
+       )))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex)))) = 0)))) = 0))) 
+       = 0))) = 0;
+	WR14 : SIZEOF (QUERY (sbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       sbsm\shell_based_surface_model.sbsm_boundary |
+       NOT (SIZEOF (QUERY (fa <* cfs\connected_face_set.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex\vertex_point.vertex_geometry)) 
+       = 1))) = 0)))) = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY mapped_item
+	SUBTYPE OF (representation_item);
+	mapping_source : representation_map;
+	mapping_target : representation_item;
+WHERE
+	WR1 : acyclic_mapped_representation(SELF);
+END_ENTITY;
+
+
+ENTITY mass_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MASS_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY mass_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 1.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY material_designation;
+	name : label;
+	definitions : SET [1:?] OF characterized_definition;
+END_ENTITY;
+
+
+ENTITY material_designation_characterization;
+	name : label;
+	description : text;
+	designation : material_designation;
+	property : characterized_material_property;
+END_ENTITY;
+
+
+ENTITY material_property
+	SUBTYPE OF (property_definition);
+UNIQUE
+  UR1: SELF\property_definition.name, SELF\property_definition.definition;
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTERIZED_OBJECT' IN
+          TYPEOF(SELF\property_definition.definition)) OR
+       (SIZEOF(bag_to_set(USEDIN(SELF ,
+                     'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                     'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')) -
+              QUERY(temp <* bag_to_set(USEDIN(SELF ,
+                       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                       'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION')) |
+                       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                      'MATERIAL_PROPERTY_REPRESENTATION' IN
+                      TYPEOF(temp)))) = 0);
+END_ENTITY;
+
+
+ENTITY material_property_representation
+	SUBTYPE OF (property_definition_representation);
+	dependent_environment : data_environment;
+END_ENTITY;
+
+
+ENTITY measure_qualification;
+	name : label;
+	description : text;
+	qualified_measure : measure_with_unit;
+	qualifiers : SET [1:?] OF value_qualifier;
+WHERE
+	WR1 : SIZEOF(QUERY(temp <* qualifiers |
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRECISION_QUALIFIER'
+             IN TYPEOF(temp))) < 2;
+	WR2 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM'
+           IN TYPEOF(SELF\measure_qualification.qualified_measure));
+END_ENTITY;
+
+
+ENTITY measure_representation_item
+	SUBTYPE OF (representation_item, measure_with_unit);
+END_ENTITY;
+
+
+ENTITY measure_with_unit
+	SUPERTYPE OF (ONEOF (length_measure_with_unit, mass_measure_with_unit, time_measure_with_unit, electric_current_measure_with_unit, thermodynamic_temperature_measure_with_unit, celsius_temperature_measure_with_unit, amount_of_substance_measure_with_unit, luminous_intensity_measure_with_unit, plane_angle_measure_with_unit, solid_angle_measure_with_unit, area_measure_with_unit, volume_measure_with_unit, ratio_measure_with_unit, acceleration_measure_with_unit, capacitance_measure_with_unit, electric_charge_measure_with_unit, conductance_measure_with_unit, electric_potential_measure_with_unit, energy_measure_with_unit, magnetic_flux_density_measure_with_unit, force_measure_with_unit, frequency_measure_with_unit, illuminance_measure_with_unit, inductance_measure_with_unit, luminous_flux_measure_with_unit, magnetic_flux_measure_with_unit, power_measure_with_unit, pressure_measure_with_unit, resistance_measure_with_unit, velocity_measure_with_unit, absorbed_dose_measure_with_unit, radioactivity_measure_with_unit, dose_equivalent_measure_with_unit));
+	value_component : measure_value;
+	unit_component : unit;
+WHERE
+	WR1 : valid_units(SELF);
+END_ENTITY;
+
+
+ENTITY mechanical_context
+	SUBTYPE OF (product_context);
+WHERE
+	WR1 : SELF.discipline_type = 'mechanical';
+END_ENTITY;
+
+
+ENTITY mechanical_design_and_draughting_relationship
+	SUBTYPE OF (definitional_representation_relationship_with_same_context);
+	SELF\representation_relationship.rep_1 : mechanical_design_and_draughting_relationship_select;
+	SELF\representation_relationship.rep_2 : mechanical_design_and_draughting_relationship_select;
+WHERE
+	WR1 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'DRAUGHTING_MODEL' IN TYPEOF(rep_2)) OR 
+       (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'DRAUGHTING_MODEL' IN TYPEOF(rep_1)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'SHAPE_REPRESENTATION' IN TYPEOF(rep_1)));
+	WR2 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_2)) OR 
+       (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_1)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'SHAPE_REPRESENTATION' IN TYPEOF(rep_1)));
+	WR3 : NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_2)) OR 
+       (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION' IN TYPEOF(rep_1)) OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'SHAPE_REPRESENTATION' IN TYPEOF(rep_1)));
+END_ENTITY;
+
+
+ENTITY mechanical_design_geometric_presentation_area
+	SUBTYPE OF (presentation_area);
+	SELF\representation.items : SET [1:?] OF mechanical_design_geometric_presentation_area_items;
+WHERE
+	WR1 : SIZEOF(QUERY(it1 <* SELF.items |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it1))
+        OR
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it1\mapped_item.mapping_source.mapped_representation)))) = 0;
+	WR2 : SIZEOF(QUERY(pv <* QUERY(mi1 <* QUERY(it1 <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it1)) |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (mi1\mapped_item.mapping_source.mapped_representation)) |
+        -- search in all presentation_views for axis2_placements and
+        -- mapped_items and for the subtype of mapped_item
+        -- camera_image_3d_with_scale; the latter shall reference
+        -- a mechanical_design_geometric_presentation_representation;
+        -- the supertype mapped_item shall reference presentation_view.
+        NOT (SIZEOF(QUERY(it2 <* pv\mapped_item.mapping_source.
+        mapped_representation\representation.items |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT'
+        IN TYPEOF(it2))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it2)) AND NOT
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))) AND NOT (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it2\mapped_item.mapping_source.mapped_representation)))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))
+        AND NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION'
+        IN TYPEOF (it2\mapped_item.mapping_source.mapped_representation) ))
+        ))) = 0))) = 0;
+	WR3 : (SIZEOF(QUERY(ps <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') | ((ps.size\planar_extent.size_in_x <= 0)
+        OR
+        (ps.size\planar_extent.size_in_y <= 0)))) = 0)
+        AND
+        (SIZEOF(QUERY(ais <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA') |
+        (SIZEOF(QUERY(ps <* USEDIN (ais, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') |
+        ((ps.size\planar_extent.size_in_x <= 0)
+        OR
+        (ps.size\planar_extent.size_in_y <= 0)))) > 0))) = 0);
+	WR4 : (SIZEOF(QUERY(ps <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') | 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_2D' IN TYPEOF (ps.size.placement)))) = 1)
+        AND
+        (SIZEOF(QUERY(ps <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') | 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_3D' IN TYPEOF (ps.size.placement)))) = 0)
+        OR
+        ((SIZEOF(QUERY(ais <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA') |
+        (SIZEOF(QUERY(ps <* USEDIN (ais, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_2D' IN TYPEOF (ps.size.placement)))) = 1))) = 1)
+        AND
+        (SIZEOF(QUERY(ais <* USEDIN (SELF,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA') |
+        (SIZEOF(QUERY(ps <* USEDIN (ais, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SIZE.UNIT') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_3D' IN TYPEOF (ps.size.placement)))) = 0))) = 1));
+END_ENTITY;
+
+
+ENTITY mechanical_design_geometric_presentation_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF mechanical_design_geometric_presentation_representation_items;
+WHERE
+	WR1 : SIZEOF(QUERY(mi <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it))) | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION']
+        * TYPEOF(mi\mapped_item.mapping_source.mapped_representation))
+        = 1))) = 0;
+	WR2 : SIZEOF(QUERY(smi <* QUERY(si <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it))) |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(si\styled_item.item))) | NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION' IN TYPEOF (smi\styled_item.
+        item\mapped_item.mapping_source.mapped_representation))) )) = 0;
+	WR3 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(pss <* psa.styles | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE']
+        * TYPEOF(pss)) = 1))) = 0))) = 0))) = 0;
+	WR4 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) |
+        NOT (SIZEOF(QUERY(psbc <* QUERY(psa <* si\styled_item.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_STYLE_BY_CONTEXT' IN TYPEOF(psa)) | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'REPRESENTATION_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION']
+        * TYPEOF(psbc\presentation_style_by_context.style_context))
+        = 1))) = 0))) = 0;
+	WR5 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ps <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE'
+        IN TYPEOF(pss)) | NOT
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF (ps\point_style.marker_size))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(ps\point_style.marker_colour))
+        = 1)))) = 0))) = 0))) = 0;
+	WR6 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(cs <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF(pss)) | NOT((SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(cs\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF (cs\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(cs\curve_style.curve_font)) = 1)))) = 0))) = 0))) = 0;
+	WR7 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_SIDE_STYLE' IN TYPEOF
+        (ssu\surface_style_usage.style)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_PARAMETER_LINE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_CONTROL_GRID',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SILHOUETTE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SEGMENTATION_CURVE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_FILL_AREA',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_BOUNDARY']
+        * TYPEOF(sses)) = 1))) = 0))) = 0))) = 0))) = 0;
+	WR9 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sspl <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_PARAMETER_LINE' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_colour)) = 1)
+        AND (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR10 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sscg <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_CONTROL_GRID' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sscg\surface_style_control_grid.style_of_control_grid))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF 
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR11 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) |
+        NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sssh <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SILHOUETTE' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sssh\surface_style_silhouette.style_of_silhouette))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssh\surface_style_silhouette.style_of_silhouette\curve_style.
+        curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(sssc <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_SEGMENTATION_CURVE' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF
+        (sssc\surface_style_segmentation_curve.style_of_segmentation_curve))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_font)) = 1))))
+        = 0))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF(QUERY(si <* QUERY(it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it)) | NOT (SIZEOF(QUERY(psa <* si\styled_item.styles |
+        NOT (SIZEOF(QUERY(ssu <* QUERY(pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF(pss)) | NOT (SIZEOF(QUERY(ssbd <* QUERY(sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SURFACE_STYLE_BOUNDARY' IN TYPEOF(sses)) |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (ssbd\surface_style_boundary.style_of_boundary))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_COLOUR']
+        * TYPEOF(ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'POSITIVE_LENGTH_MEASURE' IN TYPEOF (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_width))
+        AND (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_FONT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT']
+        * TYPEOF(ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_font)) = 1)))) = 0)))
+        = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY mechanical_design_presentation_representation_with_draughting
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF camera_model_d3;
+END_ENTITY;
+
+
+ENTITY mechanical_design_shaded_presentation_area
+	SUBTYPE OF (presentation_area);
+WHERE
+	WR1 : SIZEOF (QUERY (it1 <* SELF.items |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT'
+        IN TYPEOF (it1))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF (it1)) AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it1\mapped_item.mapping_source.mapped_representation)))))) = 0;
+	WR2 : SIZEOF (QUERY (pv <* QUERY (mi1 <* QUERY (it1 <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF (it1)) |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (mi1\mapped_item.mapping_source.mapped_representation)) |
+        (* search in all presentation_views for axis2_placements and
+           mapped_items and for the subtype of mapped_item,
+           camera_image_3d_with_scale; the latter shall reference
+           a mechanical_design_geometric_presentation_representation;
+           the supertype mapped_item shall reference presentation_view. *)
+        NOT (SIZEOF(QUERY(it2 <* pv\mapped_item.mapping_source.
+        mapped_representation\representation.items |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT'
+        IN TYPEOF(it2))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it2)) AND NOT
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))) AND NOT (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW'
+        IN TYPEOF
+        (it2\mapped_item.mapping_source.mapped_representation)))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(it2))
+        AND NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION'
+        IN TYPEOF (it2\mapped_item.mapping_source.mapped_representation) ))
+        ))) = 0))) = 0;
+	WR3 : (SIZEOF (QUERY(ps <* USEDIN (SELF, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT') |
+        NOT ((ps.size\planar_extent.size_in_x > 0) 
+        AND (ps.size\planar_extent.size_in_y > 0)) )) = 0)
+        AND
+        (* check secondly for presentation_set, via area_in_set *)
+        (SIZEOF (QUERY(pset <* QUERY(ais <* 
+        USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'AREA_IN_SET.AREA') 
+        | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SET' IN TYPEOF (ais.in_set)) |
+        (* after having collected all presentation_set, check their sizes *)
+        SIZEOF (QUERY(psize <* USEDIN(pset, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT')
+        | NOT ((psize.size\planar_extent.size_in_x > 0) 
+        AND (psize.size\planar_extent.size_in_y > 0)) )) = 0)) = 0);
+	WR4 : (SIZEOF(QUERY( psize <* USEDIN (SELF, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT') 
+        | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AXIS2_PLACEMENT_2D' 
+        IN TYPEOF (psize.size.placement))) = 1)
+        AND
+        (* check secondly for presentation_set, via area_in_set *)
+        (SIZEOF (QUERY(pset <* QUERY(ais <* 
+        USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'AREA_IN_SET.AREA')
+        | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRESENTATION_SET' IN TYPEOF (ais.in_set)) |
+        (* after having collected all presentation_set, check their 
+           dimension *)
+        SIZEOF (QUERY(psize <* USEDIN(pset, 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'PRESENTATION_SIZE.UNIT')
+        | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+        'AXIS2_PLACEMENT_2D' 
+        IN TYPEOF (psize.size.placement)) )) = 0)) = 0);
+	WR5 : SIZEOF (QUERY (pv <* QUERY (mi1 <* QUERY (it1 <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' 
+        IN TYPEOF (it1)) |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_VIEW' 
+        IN TYPEOF 
+        (mi1\mapped_item.mapping_source.mapped_representation)) |
+        (* search in all presentation_views for 
+           mapped_items and for the subtype of mapped_item,
+           camera_image_3d_with_scale; the latter shall reference
+           a camera_usage that shall have as its mapping_origin either
+           camera_model_d3, camera_model_d3_with_hlhsr, or
+           camera_model_with_light_sources. *)
+        NOT (SIZEOF(QUERY(ci <* pv\mapped_item.mapping_source.
+        mapped_representation\representation.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+         'CAMERA_IMAGE_3D_WITH_SCALE' IN TYPEOF(ci))
+        AND
+        (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CAMERA_MODEL_D3',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CAMERA_MODEL_D3_WITH_HLHSR',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CAMERA_MODEL_WITH_LIGHT_SOURCES'] * TYPEOF
+        (ci\mapped_item.mapping_source.mapping_origin))
+        = 1))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY mechanical_design_shaded_presentation_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF(QUERY(it <* SELF.items |
+        NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAMERA_MODEL_D3']
+        * TYPEOF(it)) = 1))) = 0;
+	WR2 : SIZEOF(QUERY(mi <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(it))) | NOT (SIZEOF(
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION']
+        * TYPEOF(mi\mapped_item.mapping_source.mapped_representation))
+        = 1))) = 0;
+	WR3 : SIZEOF(QUERY(smi <* QUERY(si <* QUERY(it <* SELF.items |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF(it))) |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'
+        IN TYPEOF(si\styled_item.item))) | NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'SHAPE_REPRESENTATION' IN TYPEOF (smi\styled_item.
+        item\mapped_item.mapping_source.mapped_representation))) )) = 0;
+	WR4 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (pss <* psa.styles |
+        NOT (SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE']
+        *  TYPEOF (pss)) = 1))) = 0))) = 0))) = 0;
+	WR5 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psbc <* QUERY (psa <* si\styled_item.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'PRESENTATION_STYLE_BY_CONTEXT' IN TYPEOF (psa))  |
+        NOT (SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION']
+        * TYPEOF (psbc\presentation_style_by_context.style_context)) = 1)))
+        = 0))) = 0;
+	WR6 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ps <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_STYLE'
+        IN TYPEOF (pss)) |
+        NOT (
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MARKER_TYPE'
+        IN TYPEOF (ps\point_style.marker))
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (ps\point_style.marker_size))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ps\point_style.marker_colour)) = 1)))) = 0))) = 0))) = 0;
+	WR7 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (cs <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (pss)) |
+        NOT (
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (cs\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (cs\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (cs\curve_style.curve_font)) = 1)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_SIDE_STYLE'
+        IN TYPEOF (ssu\surface_style_usage.style)) )) = 0))) = 0 ))) = 0;
+	WR9 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        NOT (SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_PARAMETER_LINE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_CONTROL_GRID',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SILHOUETTE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SEGMENTATION_CURVE',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_BOUNDARY',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_FILL_AREA',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_RENDERING'] * TYPEOF (sses)) = 1))) = 0))) = 0)))
+        = 0))) = 0;
+	WR10 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (ssfa <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_FILL_AREA'
+        IN TYPEOF (sses)) |
+        NOT (SIZEOF (QUERY (fss <*
+        ssfa\surface_style_fill_area.fill_area.fill_styles |
+        NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'FILL_AREA_STYLE_COLOUR' IN TYPEOF (fss))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (fss\fill_area_style_colour.fill_colour)) = 1)))) = 0))) = 0)))
+        = 0))) = 0))) = 0;
+	WR11 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sspl <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_PARAMETER_LINE' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sspl\surface_style_parameter_line.
+        style_of_parameter_lines\curve_style.curve_font)) = 1))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sspl\surface_style_parameter_line.style_of_parameter_lines\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sscg <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_CONTROL_GRID' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sscg\surface_style_control_grid.style_of_control_grid))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sscg\surface_style_control_grid.
+        style_of_control_grid\curve_style.curve_font)) = 1))
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (sscg\surface_style_control_grid.style_of_control_grid))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sscg\surface_style_control_grid.style_of_control_grid\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sssh <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SILHOUETTE' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (sssh\surface_style_silhouette.style_of_silhouette))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sssh\surface_style_silhouette.
+        style_of_silhouette\curve_style.curve_font)) = 1)) 
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (sssh\surface_style_silhouette.style_of_silhouette))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssh\surface_style_silhouette.style_of_silhouette\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR14 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (sssc <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_SEGMENTATION_CURVE' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF
+        (sssc\surface_style_segmentation_curve.style_of_segmentation_curve))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve\curve_style.curve_font)) = 1)) 
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (sssc\surface_style_segmentation_curve.
+        style_of_segmentation_curve))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (sssc\surface_style_segmentation_curve.style_of_segmentation_curve\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR15 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (ssbd <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_BOUNDARY' IN TYPEOF (sses)) |
+        NOT ((
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE'
+        IN TYPEOF (ssbd\surface_style_boundary.style_of_boundary))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_colour)) = 1)
+        AND
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF
+        (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_width))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'CURVE_STYLE_FONT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_CURVE_FONT'] * TYPEOF
+        (ssbd\surface_style_boundary.
+        style_of_boundary\curve_style.curve_font)) = 1)) 
+        OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE_RENDERING'
+        IN TYPEOF (ssbd\surface_style_boundary.style_of_boundary))
+        AND
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ssbd\surface_style_boundary.style_of_boundary\
+        curve_style_rendering.rendering_properties.rendered_colour))
+        = 1))) )) = 0))) = 0))) = 0))) = 0;
+	WR16 : SIZEOF (QUERY (si <* QUERY (it <* SELF.items |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM'
+        IN TYPEOF (it)) |
+        NOT (SIZEOF (QUERY (psa <* si\styled_item.styles |
+        NOT (SIZEOF (QUERY (ssu <* QUERY (pss <* psa.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE'
+        IN TYPEOF (pss)) |
+        NOT (SIZEOF (QUERY (ssre <* QUERY (sses <*
+        ssu\surface_style_usage.style\surface_side_style.styles |
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'SURFACE_STYLE_RENDERING' IN TYPEOF (sses)) |
+        NOT
+        (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COLOUR_RGB',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DRAUGHTING_PRE_DEFINED_COLOUR'] * TYPEOF
+        (ssre\surface_style_rendering.surface_colour)) = 1)))
+        = 0))) = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY min_and_major_ply_orientation_basis
+	SUBTYPE OF (representation_item_relationship, geometric_representation_item);
+	SELF\representation_item_relationship.related_representation_item : axis2_placement_3d;
+	SELF\representation_item_relationship.relating_representation_item : axis2_placement_3d;
+DERIVE
+	major_orientation_basis : axis2_placement_3d := SELF\representation_item_relationship.related_representation_item;
+	minor_orientation_basis : axis2_placement_3d := SELF\representation_item_relationship.relating_representation_item;
+END_ENTITY;
+
+
+ENTITY modified_geometric_tolerance
+	SUBTYPE OF (geometric_tolerance);
+	modifier : limit_condition;
+END_ENTITY;
+
+
+ENTITY modified_solid
+	ABSTRACT SUPERTYPE OF (ONEOF (edge_blended_solid, sculptured_solid, shelled_solid, modified_solid_with_placed_configuration))
+	SUBTYPE OF (solid_model);
+	rationale : text;
+	base_solid : base_solid_select;
+END_ENTITY;
+
+
+ENTITY modified_solid_with_placed_configuration
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_depression, solid_with_protrusion, solid_with_shape_element_pattern))
+	SUBTYPE OF (modified_solid);
+	placing : axis2_placement_3d;
+END_ENTITY;
+
+
+ENTITY moments_of_inertia_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : (SIZEOF(SELF.items) = 1) AND 
+ (SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'COMPOUND_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i.name = 'moments of inertia matrix') )) = 1);
+	WR2 : SIZEOF( QUERY( i <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'COMPOUND_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'LIST_REPRESENTATION_ITEM' IN TYPEOF(i\compound_representation_item.item_element)) AND 
+  value_range_aggregate_rep_item (i\compound_representation_item.item_element) )) = 1;
+END_ENTITY;
+
+
+ENTITY multi_language_attribute_assignment
+	SUBTYPE OF (attribute_value_assignment);
+	items : SET [1:?] OF multi_language_attribute_item;
+DERIVE
+	translation_language : language := language_indication[1]\attribute_classification_assignment.assigned_class;
+INVERSE
+	language_indication: SET [1:1] OF attribute_language_assignment FOR items;
+WHERE
+	WR1 : (SELF\attribute_value_assignment.role.name = 'alternate language');
+	WR2 : SIZEOF( QUERY( ala <* language_indication |  
+   (ala\attribute_classification_assignment.attribute_name = 'attribute_value') AND 
+   (ala\attribute_classification_assignment.role.name='translated') )) = 1;
+	WR3 : SELF\attribute_value_assignment.attribute_name <> '';
+	WR4 : SIZEOF(QUERY(ci <* items |
+SIZEOF(QUERY(ata <* USEDIN(ci, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULTI_LANGUAGE_ATTRIBUTE_ASSIGNMENT.ITEMS') |
+(ata\attribute_value_assignment.attribute_name = SELF\attribute_value_assignment.attribute_name) AND 
+(ata.translation_language :=: translation_language) ))>1 )) =0;
+	WR5 : SIZEOF(QUERY(ci <* items |
+SIZEOF(QUERY(ata <* USEDIN(ci, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS') |
+ (ata\attribute_classification_assignment.role.name='primary') AND
+ (ata\attribute_classification_assignment.attribute_name= SELF\attribute_value_assignment.attribute_name) AND 
+ (ata\attribute_classification_assignment.assigned_class :=: translation_language) ))>0 )) =0;
+END_ENTITY;
+
+
+ENTITY multiple_arity_boolean_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (boolean_expression, multiple_arity_generic_expression);
+	SELF\multiple_arity_generic_expression.operands : LIST [2:?] OF boolean_expression;
+END_ENTITY;
+
+
+ENTITY multiple_arity_generic_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (generic_expression);
+	operands : LIST [2:?] OF generic_expression;
+END_ENTITY;
+
+
+ENTITY multiple_arity_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, multiple_arity_generic_expression);
+	SELF\multiple_arity_generic_expression.operands : LIST [2:?] OF numeric_expression;
+END_ENTITY;
+
+
+ENTITY name_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_name : label;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY name_attribute;
+	attribute_value : label;
+	named_item : name_attribute_select;
+END_ENTITY;
+
+
+ENTITY named_unit
+	SUPERTYPE OF ((ONEOF (si_unit, conversion_based_unit, context_dependent_unit) ANDOR ONEOF (length_unit, mass_unit, time_unit, electric_current_unit, thermodynamic_temperature_unit, amount_of_substance_unit, luminous_flux_unit, luminous_intensity_unit, plane_angle_unit, solid_angle_unit, ratio_unit)));
+	dimensions : dimensional_exponents;
+END_ENTITY;
+
+
+ENTITY next_assembly_usage_occurrence
+	SUBTYPE OF (assembly_component_usage);
+END_ENTITY;
+
+
+ENTITY non_manifold_surface_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (it <* SELF.items |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D'] * TYPEOF (it)) = 1)))
+       = 0;
+	WR2 : SIZEOF (QUERY (it <* SELF.items |
+       SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM'] * TYPEOF (it)) = 1)) > 0;
+	WR3 : SIZEOF (QUERY (mi <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+       'NON_MANIFOLD_SURFACE_SHAPE_REPRESENTATION'
+       IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation))
+       AND
+       (SIZEOF(QUERY (mr_it <*
+       mi\mapped_item.mapping_source.mapped_representation.items |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL'
+       IN TYPEOF (mr_it)))) > 0 )))) = 0;
+	WR4 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE'] * TYPEOF (fa)) = 1)))
+       = 0))) = 0))) = 0;
+	WR5 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (f_sf <* QUERY (fa <* cfs.cfs_faces |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF (fa))) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (f_sf))
+       OR
+       (nmsf_surface_check(f_sf\face_surface.face_geometry))))) = 0))) 
+       = 0))) = 0;
+	WR6 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (o_fa <* QUERY (fa <* cfs.cfs_faces |
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE' IN TYPEOF (fa))) |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF 
+       (o_fa\oriented_face.face_element))
+       OR
+       (nmsf_surface_check
+       (o_fa\oriented_face.face_element\face_surface.face_geometry)))))
+       = 0))) = 0))) = 0;
+	WR7 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (bnds <* fa.bounds |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP']
+       * TYPEOF (bnds.bound)) = 1))) = 0)))) = 0))) = 0))) = 0;
+	WR8 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items|
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF 
+       (oe.edge_element)))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR9 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe_cv <* QUERY (oe <* 
+       elp_fbnds\path.edge_list |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (oe.edge_element)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE'] * 
+       TYPEOF (oe_cv.edge_element\edge_curve.edge_geometry)) 
+       = 1))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR10 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT (nmsf_curve_check (oe.edge_element\edge_curve.edge_geometry)))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR11 : SIZEOF (QUERY(fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list|
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (oe.edge_element.edge_start))
+       AND
+       ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN
+       TYPEOF (oe.edge_element.edge_end))))) 
+       = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR12 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <*
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (elp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (QUERY (oe <* elp_fbnds\path.edge_list |
+       NOT ((SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_start\vertex_point.vertex_geometry)) = 1)
+       AND
+       (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (oe.edge_element.edge_end\vertex_point.vertex_geometry)) = 1
+       )))) = 0))) = 0)))) = 0))) = 0))) = 0;
+	WR13 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex)))) = 0)))) = 0))) 
+       = 0))) = 0;
+	WR14 : SIZEOF (QUERY (fbsm <* QUERY (it <* SELF.items |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BASED_SURFACE_MODEL' IN TYPEOF (it)) |
+       NOT (SIZEOF (QUERY (cfs <* 
+       fbsm\face_based_surface_model.fbsm_faces |
+       NOT (SIZEOF (QUERY (fa <* cfs.cfs_faces |
+       NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF (fa))
+       OR
+       (SIZEOF (QUERY (vlp_fbnds <* QUERY (bnds <* fa.bounds |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (bnds.bound)) |
+       NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'] * TYPEOF
+       (vlp_fbnds\vertex_loop.loop_vertex\vertex_point.vertex_geometry)) 
+       = 1))) = 0)))) = 0))) = 0))) = 0;
+END_ENTITY;
+
+
+ENTITY null_representation_item
+	SUBTYPE OF (representation_item);
+END_ENTITY;
+
+
+ENTITY numeric_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (simple_numeric_expression, unary_numeric_expression, binary_numeric_expression, multiple_arity_numeric_expression))
+	SUBTYPE OF (expression);
+DERIVE
+	is_int : LOGICAL := is_int_expr (SELF);
+	sql_mappable : LOGICAL := is_SQL_mappable (SELF);
+END_ENTITY;
+
+
+ENTITY object_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY offset_curve_2d
+	SUBTYPE OF (curve);
+	basis_curve : curve;
+	distance : length_measure;
+	self_intersect : LOGICAL;
+WHERE
+	WR1 : basis_curve.dim = 2;
+END_ENTITY;
+
+
+ENTITY offset_curve_3d
+	SUBTYPE OF (curve);
+	basis_curve : curve;
+	distance : length_measure;
+	self_intersect : LOGICAL;
+	ref_direction : direction;
+WHERE
+	WR1 : (basis_curve.dim = 3) AND (ref_direction.dim = 3);
+END_ENTITY;
+
+
+ENTITY offset_surface
+	SUBTYPE OF (surface);
+	basis_surface : surface;
+	distance : length_measure;
+	self_intersect : LOGICAL;
+END_ENTITY;
+
+
+ENTITY one_direction_repeat_factor
+	SUBTYPE OF (geometric_representation_item);
+	repeat_factor : vector;
+END_ENTITY;
+
+
+ENTITY open_shell
+	SUBTYPE OF (connected_face_set);
+END_ENTITY;
+
+
+ENTITY ordinal_date
+	SUBTYPE OF (date);
+	day_component : day_in_year_number;
+WHERE
+	WR1 : (NOT leap_year(SELF.year_component) AND { 1 <= day_component <= 365 }) OR (leap_year(SELF.year_component) AND { 1 <= day_component <= 366 });
+END_ENTITY;
+
+
+ENTITY ordinate_dimension
+	SUBTYPE OF (projection_directed_callout);
+END_ENTITY;
+
+
+ENTITY organization;
+	id : OPTIONAL identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY organization_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_organization : organization;
+	role : organization_role;
+END_ENTITY;
+
+
+ENTITY organization_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_organization : organization;
+	related_organization : organization;
+END_ENTITY;
+
+
+ENTITY organization_role;
+	name : label;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY organizational_address
+	SUBTYPE OF (address);
+	organizations : SET [1:?] OF organization;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY organizational_project;
+	name : label;
+	description : OPTIONAL text;
+	responsible_organizations : SET [1:?] OF organization;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY organizational_project_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_organizational_project : organizational_project;
+	role : organizational_project_role;
+END_ENTITY;
+
+
+ENTITY organizational_project_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_organizational_project : organizational_project;
+	related_organizational_project : organizational_project;
+END_ENTITY;
+
+
+ENTITY organizational_project_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY oriented_closed_shell
+	SUBTYPE OF (closed_shell);
+	closed_shell_element : closed_shell;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\connected_face_set.cfs_faces : SET [1:?] OF face := conditional_reverse(SELF.orientation,
+                                   SELF.closed_shell_element.cfs_faces);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' 
+                IN TYPEOF (SELF.closed_shell_element));
+END_ENTITY;
+
+
+ENTITY oriented_edge
+	SUBTYPE OF (edge);
+	edge_element : edge;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\edge.edge_end : vertex := boolean_choose (SELF.orientation,
+                                            SELF.edge_element.edge_end,
+                                            SELF.edge_element.edge_start);
+	SELF\edge.edge_start : vertex := boolean_choose (SELF.orientation,
+                                            SELF.edge_element.edge_start,
+                                            SELF.edge_element.edge_end);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_EDGE' IN TYPEOF (SELF.edge_element));
+END_ENTITY;
+
+
+ENTITY oriented_face
+	SUBTYPE OF (face);
+	face_element : face;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\face.bounds : SET [1:?] OF face_bound := conditional_reverse(SELF.orientation,SELF.face_element.bounds);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE' IN TYPEOF (SELF.face_element));
+END_ENTITY;
+
+
+ENTITY oriented_open_shell
+	SUBTYPE OF (open_shell);
+	open_shell_element : open_shell;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\connected_face_set.cfs_faces : SET [1:?] OF face := conditional_reverse(SELF.orientation,
+                                      SELF.open_shell_element.cfs_faces);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_OPEN_SHELL' 
+                IN TYPEOF (SELF.open_shell_element));
+END_ENTITY;
+
+
+ENTITY oriented_path
+	SUBTYPE OF (path);
+	path_element : path;
+	orientation : BOOLEAN;
+DERIVE
+	SELF\path.edge_list : LIST [1:?] OF  UNIQUE oriented_edge := conditional_reverse(SELF.orientation,
+                                         SELF.path_element.edge_list);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_PATH' IN TYPEOF (SELF.path_element));
+END_ENTITY;
+
+
+ENTITY oriented_surface
+	SUBTYPE OF (surface);
+	orientation : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY outer_boundary_curve
+	SUBTYPE OF (boundary_curve);
+END_ENTITY;
+
+
+ENTITY over_riding_styled_item
+	SUBTYPE OF (styled_item);
+	over_ridden_style : styled_item;
+END_ENTITY;
+
+
+ENTITY package_product_concept_feature
+	SUBTYPE OF (product_concept_feature);
+WHERE
+	WR1 : NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE' IN TYPEOF ( SELF ) );
+	WR2 : SIZEOF ( QUERY 
+									( 
+										cfr <* USEDIN ( SELF , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP.' +'RELATING_PRODUCT_CONCEPT_FEATURE' ) 
+										| 
+										('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION' IN TYPEOF (cfr ) ) 
+										AND 
+										( SIZEOF ( QUERY 
+																( 
+																	ipcf <* USEDIN ( cfr , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE.' +	'CONDITION' ) 
+																	| 
+																	'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( ipcf ) 
+																)
+															)= 1 
+										)
+									)
+							)>0;
+END_ENTITY;
+
+
+ENTITY parabola
+	SUBTYPE OF (conic);
+	focal_dist : length_measure;
+WHERE
+	WR1 : focal_dist <> 0.0;
+END_ENTITY;
+
+
+ENTITY parallel_offset
+	SUBTYPE OF (derived_shape_aspect);
+	offset : measure_with_unit;
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY parallelism_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) < 3;
+END_ENTITY;
+
+
+ENTITY parametric_representation_context
+	SUBTYPE OF (representation_context);
+END_ENTITY;
+
+
+ENTITY part_laminate_table
+	SUPERTYPE OF (ONEOF (composite_assembly_table, ply_laminate_table))
+	SUBTYPE OF (laminate_table);
+END_ENTITY;
+
+
+ENTITY partial_document_with_structured_text_representation_assignment
+	SUBTYPE OF (applied_document_usage_constraint_assignment, characterized_object);
+END_ENTITY;
+
+
+ENTITY path
+	SUPERTYPE OF (ONEOF (edge_loop, oriented_path))
+	SUBTYPE OF (topological_representation_item);
+	edge_list : LIST [1:?] OF  UNIQUE oriented_edge;
+WHERE
+	WR1 : path_head_to_tail(SELF);
+END_ENTITY;
+
+
+ENTITY pcurve
+	SUBTYPE OF (curve);
+	basis_surface : surface;
+	reference_to_curve : definitional_representation;
+WHERE
+	WR1 : SIZEOF(reference_to_curve\representation.items) = 1;
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF
+                    (reference_to_curve\representation.items[1]);
+	WR3 : reference_to_curve\representation.items[1]\
+                               geometric_representation_item.dim =2;
+END_ENTITY;
+
+
+ENTITY percentage_laminate_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) > 0;
+END_ENTITY;
+
+
+ENTITY percentage_laminate_table
+	SUBTYPE OF (zone_structural_makeup);
+END_ENTITY;
+
+
+ENTITY percentage_ply_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+        'PRODUCT_DEFINITION_RELATIONSHIP.RELATING_PRODUCT_DEFINITION') |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERCENTAGE_LAMINATE_DEFINITION' 
+        IN TYPEOF (pdr.related_product_definition)) AND
+        (pdr.name = 'makeup and properties'))) = 0;
+END_ENTITY;
+
+
+ENTITY perpendicular_to
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY perpendicularity_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3;
+END_ENTITY;
+
+
+ENTITY person;
+	id : identifier;
+	last_name : OPTIONAL label;
+	first_name : OPTIONAL label;
+	middle_names : OPTIONAL LIST [1:?] OF label;
+	prefix_titles : OPTIONAL LIST [1:?] OF label;
+	suffix_titles : OPTIONAL LIST [1:?] OF label;
+WHERE
+	WR1 : EXISTS(last_name) OR EXISTS(first_name);
+END_ENTITY;
+
+
+ENTITY person_and_organization;
+	the_person : person;
+	the_organization : organization;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY person_and_organization_address
+	SUBTYPE OF (organizational_address, personal_address);
+	SELF\organizational_address.organizations : SET [1:1] OF organization;
+	SELF\personal_address.people : SET [1:1] OF person;
+WHERE
+	WR1 : SIZEOF(QUERY(pao <* USEDIN (SELF\personal_address.people[1], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERSON_AND_ORGANIZATION.THE_PERSON') | pao.the_organization :=: SELF\organizational_address.organizations[1])) = 1;
+END_ENTITY;
+
+
+ENTITY person_and_organization_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_person_and_organization : person_and_organization;
+	role : person_and_organization_role;
+END_ENTITY;
+
+
+ENTITY person_and_organization_role;
+	name : label;
+DERIVE
+	description : text := get_description_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY personal_address
+	SUBTYPE OF (address);
+	people : SET [1:?] OF person;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY physical_breakdown_context
+	SUBTYPE OF (breakdown_context);
+END_ENTITY;
+
+
+ENTITY physical_element_usage
+	SUBTYPE OF (breakdown_element_usage);
+END_ENTITY;
+
+
+ENTITY picture_representation
+	SUBTYPE OF (presentation_view);
+	SELF\representation.items : SET [2:?] OF picture_representation_item_select;
+INVERSE
+	size: presentation_size FOR unit;
+WHERE
+    WR1: SIZEOF(QUERY(item <* items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM' IN TYPEOF(item))) = 1;
+    WR2: SIZEOF (QUERY (se <* QUERY (item <* SELF.items | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STYLED_ITEM' IN TYPEOF (item))) 
+         | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PICTURE_REPRESENTATION_ITEM' 
+                IN TYPEOF (se\styled_item.item)) )) = 0;
+END_ENTITY;
+
+
+ENTITY picture_representation_item
+	ABSTRACT SUPERTYPE OF (ONEOF (externally_defined_picture_representation_item, predefined_picture_representation_item))
+	SUBTYPE OF (bytes_representation_item);
+END_ENTITY;
+
+
+ENTITY placed_datum_target_feature
+	SUBTYPE OF (datum_target);
+DERIVE
+	representation_associations : SET [0:?] OF property_definition_representation := get_shape_aspect_property_definition_representations(SELF);
+WHERE
+	WR1 : SELF.description IN ['point','line','rectangle','circle', 'circular line'];
+	WR2 : SIZEOF (QUERY (pdr <* representation_associations | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_WITH_PARAMETERS' IN TYPEOF (pdr.used_representation) )) = 1;
+	WR3 : valid_datum_target_parameters(SELF);
+END_ENTITY;
+
+
+ENTITY placed_feature
+	SUBTYPE OF (shape_aspect);
+END_ENTITY;
+
+
+ENTITY placement
+	SUPERTYPE OF (ONEOF (axis1_placement, axis2_placement_2d, axis2_placement_3d))
+	SUBTYPE OF (geometric_representation_item);
+	location : cartesian_point;
+END_ENTITY;
+
+
+ENTITY planar_box
+	SUBTYPE OF (planar_extent);
+	placement : axis2_placement;
+END_ENTITY;
+
+
+ENTITY planar_extent
+	SUBTYPE OF (geometric_representation_item);
+	size_in_x : length_measure;
+	size_in_y : length_measure;
+END_ENTITY;
+
+
+ENTITY plane
+	SUBTYPE OF (elementary_surface);
+END_ENTITY;
+
+
+ENTITY plane_angle_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY plane_angle_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY plus_minus_tolerance;
+	range : tolerance_method_definition;
+	toleranced_dimension : dimensional_characteristic;
+UNIQUE
+	UR1 : toleranced_dimension;
+END_ENTITY;
+
+
+ENTITY ply_laminate_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) = 1;
+END_ENTITY;
+
+
+ENTITY ply_laminate_sequence_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) > 0;
+END_ENTITY;
+
+
+ENTITY ply_laminate_table
+	SUBTYPE OF (part_laminate_table);
+END_ENTITY;
+
+
+ENTITY point
+	SUPERTYPE OF (ONEOF (cartesian_point, point_on_curve, point_on_surface, point_replica, degenerate_pcurve))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY point_and_vector
+	SUBTYPE OF (compound_representation_item, geometric_representation_item);
+	SELF\compound_representation_item.item_element : point_and_vector_members;
+END_ENTITY;
+
+
+ENTITY point_on_curve
+	SUBTYPE OF (point);
+	basis_curve : curve;
+	point_parameter : parameter_value;
+END_ENTITY;
+
+
+ENTITY point_on_surface
+	SUBTYPE OF (point);
+	basis_surface : surface;
+	point_parameter_u : parameter_value;
+	point_parameter_v : parameter_value;
+END_ENTITY;
+
+
+ENTITY point_path
+	SUBTYPE OF (compound_representation_item, geometric_representation_item);
+	SELF\compound_representation_item.item_element : point_path_members;
+END_ENTITY;
+
+
+ENTITY point_replica
+	SUBTYPE OF (point);
+	parent_pt : point;
+	transformation : cartesian_transformation_operator;
+WHERE
+	WR1 : transformation.dim = parent_pt.dim;
+	WR2 : acyclic_point_replica (SELF,parent_pt);
+END_ENTITY;
+
+
+ENTITY point_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	marker : marker_select;
+	marker_size : size_select;
+	marker_colour : colour;
+END_ENTITY;
+
+
+ENTITY polar_complex_number_literal
+	SUBTYPE OF (generic_literal);
+	radius : REAL;
+	angle : REAL;
+WHERE
+	WR1 : radius >= 0;
+	WR2 : { 0 <= angle < 2*PI };
+END_ENTITY;
+
+
+ENTITY poly_loop
+	SUBTYPE OF (loop, geometric_representation_item);
+	polygon : LIST [3:?] OF  UNIQUE cartesian_point;
+END_ENTITY;
+
+
+ENTITY polyline
+	SUBTYPE OF (bounded_curve);
+	points : LIST [2:?] OF cartesian_point;
+END_ENTITY;
+
+
+ENTITY position_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF)) OR ( SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3);
+END_ENTITY;
+
+
+ENTITY positioned_sketch
+	SUBTYPE OF (geometric_representation_item);
+	sketch_basis : sketch_basis_select;
+	auxiliary_elements : SET [0:?] OF auxiliary_geometric_representation_item;
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE' IN 
+    TYPEOF(sketch_basis)) AND NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN
+    TYPEOF(sketch_basis\curve_bounded_surface.basis_surface)));
+	WR2 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF(sketch_basis)) AND
+    NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(sketch_basis\face_surface.face_geometry)));
+	WR3 : SIZEOF(QUERY(q <* auxiliary_elements | (SIZEOF(TYPEOF(q) * 
+    ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT','AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE']) = 0))) = 0;
+	WR4 : SIZEOF(QUERY(q <* auxiliary_elements | 
+    q\geometric_representation_item.dim <> 3)) = 0;
+END_ENTITY;
+
+
+ENTITY power_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY power_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.watt);
+END_ENTITY;
+
+
+ENTITY pre_defined_colour
+	SUBTYPE OF (pre_defined_item, colour);
+END_ENTITY;
+
+
+ENTITY pre_defined_curve_font
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_dimension_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN [ 'arc length' , 'conical taper' , 'counterbore' , 'countersink' , 'depth' , 'diameter' , 'plus minus' , 'radius' , 'slope' , 'spherical diameter' , 'spherical radius' , 'square'];
+END_ENTITY;
+
+
+ENTITY pre_defined_geometrical_tolerance_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['angularity' , 'basic dimension' , 'blanked datum reference' , 'circular runout' , 'circularity' , 'concentricity' , 'cylindricity' , 'datum target identification' , 'diameter' , 'filled datum reference' , 'flatness' , 'least material condition' , 'maximum material condition' , 'parallelism' , 'perpendicularity' , 'position' , 'profile of a line' , 'profile of a surface' , 'projected tolerance zone' , 'regardless of feature size' , 'straightness' , 'symmetry' , 'total runout' ];
+END_ENTITY;
+
+
+ENTITY pre_defined_item;
+	name : label;
+END_ENTITY;
+
+
+ENTITY pre_defined_marker
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_point_marker_symbol
+	SUBTYPE OF (pre_defined_marker, pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['asterisk','circle','dot','plus','square','triangle','x'];
+END_ENTITY;
+
+
+ENTITY pre_defined_surface_condition_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['000' , '010' , '020' , '030' , '040' , '050' , '060' , '070' , '001' , '011' , '021' , '031' , '041' , '051' , '061' , '071' , '100' , '110' , '120' , '130' , '140' , '150' , '160' , '170' , '101' , '111' , '121' , '131' , '141' , '151' , '161' , '171' , '200' , '210' , '220' , '230' , '240' , '250' , '260' , '270' , '201' , '211' , '221' , '231' , '241' , '251' , '261' , '271'];
+END_ENTITY;
+
+
+ENTITY pre_defined_surface_side_style
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_symbol
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_terminator_symbol
+	SUBTYPE OF (pre_defined_symbol);
+WHERE
+	WR1 : SELF.name IN ['blanked arrow', 'blanked box', 'blanked dot', 'blanked triangle', 'dimension origin', 'filled arrow', 'filled box', 'filled dot', 'integral symbol', 'open arrow', 'slash', 'unfilled arrow', 'unfilled triangle', 'filled triangle'];
+END_ENTITY;
+
+
+ENTITY pre_defined_text_font
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY pre_defined_tile
+	SUBTYPE OF (pre_defined_item);
+END_ENTITY;
+
+
+ENTITY precision_qualifier;
+	precision_value : INTEGER;
+END_ENTITY;
+
+
+ENTITY predefined_picture_representation_item
+	SUBTYPE OF (picture_representation_item);
+WHERE
+	WR1 : SELF\representation_item.name IN pre_defined_picture_representation_types;
+END_ENTITY;
+
+
+ENTITY presentation_area
+	SUBTYPE OF (presentation_representation);
+WHERE
+	WR1 : ((SIZEOF (QUERY (ais <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                                 'AREA_IN_SET.AREA') | 
+             SIZEOF (USEDIN (ais, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                  'PRESENTATION_SIZE.UNIT')) =1)) > 0) OR
+            (SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                   'PRESENTATION_SIZE.UNIT')) =1));
+END_ENTITY;
+
+
+ENTITY presentation_layer_assignment;
+	name : label;
+	description : text;
+	assigned_items : SET [1:?] OF layered_item;
+END_ENTITY;
+
+
+ENTITY presentation_representation
+	SUPERTYPE OF (ONEOF (presentation_area, presentation_view))
+	SUBTYPE OF (representation);
+	SELF\representation.context_of_items : geometric_representation_context;
+WHERE
+	WR1 : SELF\representation.
+           context_of_items\geometric_representation_context.
+           coordinate_space_dimension = 2;
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_AREA' IN TYPEOF (SELF))
+           OR
+           (SIZEOF (QUERY (prr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                                'REPRESENTATION_RELATIONSHIP.REP_2') | 
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_REPRESENTATION' IN
+           TYPEOF (prr\representation_relationship.rep_1))) > 0)
+           OR 
+           (SIZEOF(QUERY( rm <* USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 
+                                             'REPRESENTATION_MAP.'+ 
+                                             'MAPPED_REPRESENTATION') | 
+           SIZEOF(QUERY( mi <* USEDIN(rm, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                                          'MAPPED_ITEM.'+
+                                          'MAPPING_SOURCE') |   
+           SIZEOF(QUERY( rep <* using_representations (mi) |                              
+                                        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                                        'PRESENTATION_REPRESENTATION' IN 
+                                        TYPEOF (rep))) > 0
+           )) > 0))  
+           > 0);
+END_ENTITY;
+
+
+ENTITY presentation_set;
+INVERSE
+	areas: SET [1:?] OF area_in_set FOR in_set;
+END_ENTITY;
+
+
+ENTITY presentation_size;
+	unit : presentation_size_assignment_select;
+	size : planar_box;
+UNIQUE
+	UR1 : unit;
+WHERE
+	WR1 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESENTATION_REPRESENTATION'
+           IN TYPEOF (SELF.unit)) AND
+           item_in_context (SELF.size, 
+                            SELF.unit\representation.context_of_items)
+           )
+           OR
+           (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AREA_IN_SET'
+           IN TYPEOF (SELF.unit)) AND
+           (SIZEOF (QUERY ( ais <* SELF.unit\area_in_set.in_set.areas |
+                NOT item_in_context (SELF.size, ais.area\representation.
+                                                context_of_items) )) = 0));
+END_ENTITY;
+
+
+ENTITY presentation_style_assignment
+	SUBTYPE OF (founded_item);
+	styles : SET [1:?] OF presentation_style_select;
+WHERE
+	WR1 : SIZEOF (QUERY (style1 <* SELF.styles |
+           NOT (SIZEOF (QUERY (style2 <* (SELF.styles - style1) |
+           NOT ((TYPEOF (style1) <> TYPEOF (style2)) OR
+             (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                       'SURFACE_STYLE_USAGE',
+                       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+                       'EXTERNALLY_DEFINED_STYLE'] *
+                     TYPEOF (style1)) = 1)
+           ))) = 0
+         ))) = 0;
+	WR2 : SIZEOF (QUERY (style1 <* SELF.styles |
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE' IN
+         TYPEOF(style1)
+         )) <= 2;
+	WR3 : SIZEOF (QUERY (style1 <* SELF.styles |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE' IN TYPEOF (style1)) AND 
+         (SIZEOF (QUERY (style2 <* (SELF.styles - style1) |
+           ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_STYLE_USAGE' IN TYPEOF (style2)) AND 
+           ((style1\surface_style_usage.side = both) OR 
+           (style2\surface_style_usage.side = both) OR 
+           (style1\surface_style_usage.side = style2\surface_style_usage.side)) )) > 0))) = 0;
+END_ENTITY;
+
+
+ENTITY presentation_style_by_context
+	SUBTYPE OF (presentation_style_assignment);
+	style_context : style_context_select;
+END_ENTITY;
+
+
+ENTITY presentation_view
+	SUBTYPE OF (presentation_representation);
+END_ENTITY;
+
+
+ENTITY presented_item
+	ABSTRACT SUPERTYPE;
+END_ENTITY;
+
+
+ENTITY presented_item_representation;
+	presentation : presentation_representation_select;
+	item : presented_item;
+END_ENTITY;
+
+
+ENTITY pressure_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESSURE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY pressure_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.pascal);
+END_ENTITY;
+
+
+ENTITY procedural_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF procedural_representation_sequence;
+END_ENTITY;
+
+
+ENTITY procedural_representation_sequence
+	SUBTYPE OF (representation_item);
+	elements : LIST [1:?] OF representation_item;
+	suppressed_items : SET [0:?] OF representation_item;
+	rationale : text;
+WHERE
+	WR1 : SIZEOF(QUERY(q <* suppressed_items | NOT (q IN elements))) = 0;
+END_ENTITY;
+
+
+ENTITY procedural_shape_representation
+	SUBTYPE OF (procedural_representation, shape_representation);
+	SELF\representation.items : SET [1:?] OF procedural_shape_representation_sequence;
+END_ENTITY;
+
+
+ENTITY procedural_shape_representation_sequence
+	SUBTYPE OF (geometric_representation_item, procedural_representation_sequence);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* SELF\procedural_representation_sequence.elements
+    | NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_ITEM'
+    IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY product;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	frame_of_reference : SET [1:?] OF product_context;
+END_ENTITY;
+
+
+ENTITY product_category;
+	name : label;
+	description : OPTIONAL text;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY product_class
+	SUBTYPE OF (product_concept, characterized_object);
+END_ENTITY;
+
+
+ENTITY product_concept;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	market_context : product_concept_context;
+UNIQUE
+	UR1 : id;
+END_ENTITY;
+
+
+ENTITY product_concept_context
+	SUBTYPE OF (application_context_element);
+	market_segment_type : label;
+END_ENTITY;
+
+
+ENTITY product_concept_feature;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY product_concept_feature_association;
+	name : label;
+	description : OPTIONAL text;
+	concept : product_concept;
+	feature : product_concept_feature;
+END_ENTITY;
+
+
+ENTITY product_concept_feature_category
+	SUBTYPE OF (group);
+WHERE
+	WR1 : SIZEOF(QUERY
+									( 
+										aga <* USEDIN( SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GROUP_ASSIGNMENT.ASSIGNED_GROUP' ) 
+										|
+     								('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'APPLIED_GROUP_ASSIGNMENT' IN TYPEOF(aga)) 
+     								AND
+    								(
+    									( aga.role.name <> 'specification category member' ) 
+    									OR 
+    									( SIZEOF(QUERY 
+    															( 
+    																i <* aga.items 
+    																| 
+    																('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( i ) ) 
+    																AND 
+    																NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'CONDITIONAL_CONCEPT_FEATURE' IN TYPEOF (i))
+    															)
+    													) <> SIZEOF (aga.items)
+    									)
+    								) 
+       						) 
+       				) =0;
+END_ENTITY;
+
+
+ENTITY product_concept_feature_category_usage
+	SUBTYPE OF (group_assignment);
+	items : SET [1:?] OF category_usage_item;
+	SELF\group_assignment.assigned_group : product_concept_feature_category;
+WHERE
+	WR1 : SELF.role.name IN [ 'mandatory category usage', 'optional category usage' ];
+END_ENTITY;
+
+
+ENTITY product_concept_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_concept : product_concept;
+	related_product_concept : product_concept;
+END_ENTITY;
+
+
+ENTITY product_context
+	SUBTYPE OF (application_context_element);
+	discipline_type : label;
+END_ENTITY;
+
+
+ENTITY product_definition
+	SUPERTYPE OF (ONEOF (composite_assembly_definition, composite_assembly_sequence_definition, laminate_table, percentage_laminate_definition, percentage_ply_definition, ply_laminate_definition, ply_laminate_sequence_definition, thickness_laminate_definition));
+	id : identifier;
+	description : OPTIONAL text;
+	formation : product_definition_formation;
+	frame_of_reference : product_definition_context;
+DERIVE
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY product_definition_context
+	SUBTYPE OF (application_context_element);
+	life_cycle_stage : label;
+END_ENTITY;
+
+
+ENTITY product_definition_context_association;
+	definition : product_definition;
+	frame_of_reference : product_definition_context;
+	role : product_definition_context_role;
+END_ENTITY;
+
+
+ENTITY product_definition_context_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY product_definition_effectivity
+	SUBTYPE OF (effectivity);
+	usage : product_definition_relationship;
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EFFECTIVITY_ASSIGNMENT.ASSIGNED_EFFECTIVITY')) = 0;
+END_ENTITY;
+
+
+ENTITY product_definition_element_relationship
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY product_definition_formation;
+	id : identifier;
+	description : OPTIONAL text;
+	of_product : product;
+UNIQUE
+	UR1 : id, of_product;
+END_ENTITY;
+
+
+ENTITY product_definition_formation_relationship;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_definition_formation : product_definition_formation;
+	related_product_definition_formation : product_definition_formation;
+END_ENTITY;
+
+
+ENTITY product_definition_formation_with_specified_source
+	SUBTYPE OF (product_definition_formation);
+	make_or_buy : source;
+END_ENTITY;
+
+
+ENTITY product_definition_group_assignment
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition_or_product_definition_relationship;
+	SELF\group_assignment.assigned_group : product_definition_element_relationship;
+END_ENTITY;
+
+
+ENTITY product_definition_occurrence_relationship;
+	name : label;
+	description : OPTIONAL text;
+	occurrence : product_definition;
+	occurrence_usage : assembly_component_usage;
+WHERE
+	WR1 : occurrence_usage.relating_product_definition :<>: 
+       occurrence;
+	WR2 : occurrence_usage.related_product_definition :<>: 
+       occurrence;
+	WR3 : occurrence.formation :=:
+       occurrence_usage.related_product_definition.formation;
+END_ENTITY;
+
+
+ENTITY product_definition_relationship;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+	relating_product_definition : product_definition;
+	related_product_definition : product_definition;
+END_ENTITY;
+
+
+ENTITY product_definition_shape
+	SUBTYPE OF (property_definition);
+UNIQUE
+  UR1: SELF\property_definition.definition;
+WHERE
+	WR1 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTERIZED_PRODUCT_DEFINITION', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CHARACTERIZED_OBJECT'] * TYPEOF(SELF\property_definition.definition)) > 0;
+END_ENTITY;
+
+
+ENTITY product_definition_substitute;
+	description : OPTIONAL text;
+	context_relationship : product_definition_relationship;
+	substitute_definition : product_definition;
+DERIVE
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : context_relationship.related_product_definition :<>: substitute_definition;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY product_definition_usage
+	SUPERTYPE OF (ONEOF (make_from_usage_option, assembly_component_usage))
+	SUBTYPE OF (product_definition_relationship);
+UNIQUE
+ UR1: SELF\product_definition_relationship.id, 
+      SELF\product_definition_relationship.relating_product_definition, 
+      SELF\product_definition_relationship.related_product_definition;
+ WHERE
+	WR1 : acyclic_product_definition_relationship
+         (SELF,
+         [SELF\product_definition_relationship.related_product_definition],
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_USAGE');
+END_ENTITY;
+
+
+ENTITY product_definition_with_associated_documents
+	SUBTYPE OF (product_definition);
+	documentation_ids : SET [1:?] OF document;
+END_ENTITY;
+
+
+ENTITY product_identification
+	SUBTYPE OF (configuration_item, characterized_object);
+	SELF\configuration_item.item_concept : product_class;
+WHERE
+	WR1 : SIZEOF(QUERY 
+		( cd <* USEDIN ( SELF ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONFIGURATION_DESIGN.CONFIGURATION' ) 
+		|
+     	( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_DEFINITION_FORMATION' IN TYPEOF ( cd. design ) ) 
+     	AND 
+    	( SIZEOF ( QUERY 
+    	( 
+    	prpc <* USEDIN ( cd. design\product_definition_formation.of_product , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') 
+    	| 
+        prpc. name IN ['part' , 'raw material' , 'tool'] ) ) >0
+     	) 
+     	) 
+     	) <=1;
+	WR2 : NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'CONFIGURABLE_ITEM' IN TYPEOF( SELF ) ) 
+			XOR ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_SPECIFICATION' IN TYPEOF ( SELF ) );
+END_ENTITY;
+
+
+ENTITY product_material_composition_relationship
+	SUBTYPE OF (product_definition_relationship);
+	class : label;
+	constituent_amount : SET [1:?] OF characterized_product_composition_value;
+	composition_basis : label;
+	determination_method : text;
+END_ENTITY;
+
+
+ENTITY product_related_product_category
+	SUBTYPE OF (product_category);
+	products : SET [1:?] OF product;
+END_ENTITY;
+
+
+ENTITY product_specification
+	SUBTYPE OF (product_identification, configurable_item);
+END_ENTITY;
+
+
+ENTITY projected_zone_definition
+	SUBTYPE OF (tolerance_zone_definition);
+	projection_end : shape_aspect;
+	projected_length : measure_with_unit;
+WHERE
+	WR1 : ('NUMBER' IN TYPEOF
+       (projected_length\measure_with_unit.value_component)) AND
+       (projected_length\measure_with_unit.value_component > 0.0);
+	WR2 : (derive_dimensional_exponents
+       (projected_length\measure_with_unit.unit_component)=
+        dimensional_exponents(1,0,0,0,0,0,0));
+END_ENTITY;
+
+
+ENTITY projection_curve
+	SUBTYPE OF (annotation_curve_occurrence);
+END_ENTITY;
+
+
+ENTITY projection_directed_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF(QUERY(p_1<*SELF\draughting_callout.contents | 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN (TYPEOF(p_1))))=1;
+	WR2 : SIZEOF(SELF\draughting_callout.contents) >=2;
+END_ENTITY;
+
+
+ENTITY promissory_usage_occurrence
+	SUBTYPE OF (assembly_component_usage);
+END_ENTITY;
+
+
+ENTITY property_definition;
+	name : label;
+	description : OPTIONAL text;
+	definition : characterized_definition;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY property_definition_relationship;
+	name : label;
+	description : text;
+	relating_property_definition : property_definition;
+	related_property_definition : property_definition;
+END_ENTITY;
+
+
+ENTITY property_definition_representation;
+	definition : represented_definition;
+	used_representation : representation;
+DERIVE
+	description : text := get_description_value(SELF);
+	name : label := get_name_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM')) <= 1;
+	WR2 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.NAMED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY qualified_representation_item
+	SUBTYPE OF (representation_item);
+	qualifiers : SET [1:?] OF value_qualifier;
+WHERE
+	WR1 : SIZEOF(QUERY(temp <* qualifiers |
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRECISION_QUALIFIER'
+             IN TYPEOF(temp))) < 2;
+END_ENTITY;
+
+
+ENTITY qualitative_uncertainty
+	SUBTYPE OF (uncertainty_qualifier);
+	uncertainty_value : text;
+END_ENTITY;
+
+
+ENTITY quantified_assembly_component_usage
+	SUBTYPE OF (assembly_component_usage);
+	quantity : measure_with_unit;
+WHERE
+	WR1 : (NOT ('NUMBER' IN TYPEOF(quantity.value_component)))
+       OR (quantity.value_component > 0);
+END_ENTITY;
+
+
+ENTITY quasi_uniform_curve
+	SUBTYPE OF (b_spline_curve);
+END_ENTITY;
+
+
+ENTITY quasi_uniform_surface
+	SUBTYPE OF (b_spline_surface);
+END_ENTITY;
+
+
+ENTITY radioactivity_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIOACTIVITY_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY radioactivity_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.becquerel);
+END_ENTITY;
+
+
+ENTITY radius_dimension
+	SUBTYPE OF (dimension_curve_directed_callout);
+WHERE
+	WR1 : SIZEOF (QUERY (con <* SELF.contents |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_CURVE' IN TYPEOF (con)))<=1;
+END_ENTITY;
+
+
+ENTITY range_characteristic
+	SUBTYPE OF (representation, descriptive_representation_item);
+WHERE
+	WR1 : NOT(SELF\representation.name IN ['tolerance', 'minimum tolerance', 'maximum tolerance', 
+        'nominal tolerance', 'plus minus tolerance', 'symmetrical tolerance', 'statistical tolerance']);
+END_ENTITY;
+
+
+ENTITY ratio_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RATIO_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY ratio_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY rational_b_spline_curve
+	SUBTYPE OF (b_spline_curve);
+	weights_data : LIST [2:?] OF REAL;
+DERIVE
+	weights : ARRAY [0:upper_index_on_control_points] OF REAL := list_to_array(weights_data,0,
+                                      upper_index_on_control_points);
+WHERE
+	WR1 : SIZEOF(weights_data) = SIZEOF(SELF\b_spline_curve.
+                                           control_points_list);
+	WR2 : curve_weights_positive(SELF);
+END_ENTITY;
+
+
+ENTITY rational_b_spline_surface
+	SUBTYPE OF (b_spline_surface);
+	weights_data : LIST [2:?] OF LIST [2:?] OF REAL;
+DERIVE
+	weights : ARRAY [0:u_upper] OF ARRAY [0:v_upper] OF REAL := make_array_of_array(weights_data,0,u_upper,0,v_upper);
+WHERE
+	WR1 : (SIZEOF(weights_data) =
+                     SIZEOF(SELF\b_spline_surface.control_points_list))
+           AND (SIZEOF(weights_data[1]) =
+                  SIZEOF(SELF\b_spline_surface.control_points_list[1]));
+	WR2 : surface_weights_positive(SELF);
+END_ENTITY;
+
+
+ENTITY rational_representation_item
+	SUBTYPE OF (representation_item, slash_expression);
+WHERE
+	WR1 : SIZEOF( QUERY( operand <* SELF\binary_generic_expression.operands | 
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_LITERAL' IN TYPEOF(operand)))) = 0;
+END_ENTITY;
+
+
+ENTITY real_literal
+	SUBTYPE OF (literal_number);
+	SELF\literal_number.the_value : REAL;
+END_ENTITY;
+
+
+ENTITY real_representation_item
+	SUBTYPE OF (representation_item, real_literal);
+END_ENTITY;
+
+
+ENTITY rectangular_composite_surface
+	SUBTYPE OF (bounded_surface);
+	segments : LIST [1:?] OF LIST [1:?] OF surface_patch;
+DERIVE
+	n_u : INTEGER := SIZEOF(segments);
+	n_v : INTEGER := SIZEOF(segments[1]);
+WHERE
+	WR1 : SIZEOF(QUERY (s <* segments | n_v <> SIZEOF (s))) = 0;
+	WR2 : constraints_rectangular_composite_surface(SELF);
+END_ENTITY;
+
+
+ENTITY rectangular_trimmed_surface
+	SUBTYPE OF (bounded_surface);
+	basis_surface : surface;
+	u1 : parameter_value;
+	u2 : parameter_value;
+	v1 : parameter_value;
+	v2 : parameter_value;
+	usense : BOOLEAN;
+	vsense : BOOLEAN;
+WHERE
+	WR1 : u1 <> u2;
+	WR2 : v1 <> v2;
+	WR3 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN TYPEOF(basis_surface))
+       AND  (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(basis_surface)))) OR
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_OF_REVOLUTION' IN TYPEOF(basis_surface))
+          OR (usense = (u2 > u1));
+	WR4 : (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SPHERICAL_SURFACE' IN TYPEOF(basis_surface))
+          OR
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOROIDAL_SURFACE' IN TYPEOF(basis_surface)))
+          OR (vsense = (v2 > v1));
+END_ENTITY;
+
+
+ENTITY referenced_modified_datum
+	SUBTYPE OF (datum_reference);
+	modifier : limit_condition;
+END_ENTITY;
+
+
+ENTITY relative_event_occurrence
+	SUBTYPE OF (event_occurrence);
+	base_event : event_occurrence;
+	offset : time_measure_with_unit;
+END_ENTITY;
+
+
+ENTITY rep_item_group
+	SUBTYPE OF (group, representation_item);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRESENTATION_LAYER_ASSIGNMENT.' + 'ASSIGNED_ITEMS')) > 0;
+	WR2 : SIZEOF(QUERY(r <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION.' + 'ITEMS') | r.name = 'group representation')) > 0;
+	WR3 : SIZEOF(QUERY(ga <* USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GROUP_ASSIGNMENT.' + 'ASSIGNED_GROUP') | ga.role.name <> 'group membership')) = 0;
+	WR4 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_REPRESENTATION_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'TOPOLOGICAL_REPRESENTATION_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'MAPPED_ITEM','AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'STYLED_ITEM'] * TYPEOF(SELF)) = 1;
+END_ENTITY;
+
+
+ENTITY reparametrised_composite_curve_segment
+	SUBTYPE OF (composite_curve_segment);
+	param_length : parameter_value;
+WHERE
+	WR1 : param_length > 0.0;
+END_ENTITY;
+
+
+ENTITY representation;
+	name : label;
+	items : SET [1:?] OF representation_item;
+	context_of_items : representation_context;
+DERIVE
+	description : text := get_description_value (SELF);
+	id : identifier := get_id_value (SELF);
+WHERE
+	WR1 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'ID_ATTRIBUTE.IDENTIFIED_ITEM'))
+         <= 1;
+	WR2 : SIZEOF (USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'DESCRIPTION_ATTRIBUTE.DESCRIBED_ITEM'))
+         <= 1;
+END_ENTITY;
+
+
+ENTITY representation_context;
+	context_identifier : identifier;
+	context_type : text;
+INVERSE
+	representations_in_context: SET [1:?] OF representation FOR context_of_items;
+END_ENTITY;
+
+
+ENTITY representation_item
+	SUPERTYPE OF (ONEOF (binary_representation_item, compound_representation_item, mapped_item, value_representation_item, mapped_item, styled_item, boolean_representation_item, date_representation_item, date_time_representation_item, integer_representation_item, logical_representation_item, rational_representation_item, real_representation_item));
+	name : label;
+WHERE
+	WR1 : SIZEOF(using_representations(SELF)) > 0;
+END_ENTITY;
+
+
+ENTITY representation_item_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_representation_item : representation_item;
+	related_representation_item : representation_item;
+END_ENTITY;
+
+
+ENTITY representation_map;
+	mapping_origin : representation_item;
+	mapped_representation : representation;
+INVERSE
+	map_usage: SET [1:?] OF mapped_item FOR mapping_source;
+WHERE
+	WR1 : item_in_context(SELF.mapping_origin,
+        SELF.mapped_representation.context_of_items);
+END_ENTITY;
+
+
+ENTITY representation_relationship;
+	name : label;
+	description : OPTIONAL text;
+	rep_1 : representation;
+	rep_2 : representation;
+END_ENTITY;
+
+
+ENTITY representation_relationship_with_transformation
+	SUBTYPE OF (representation_relationship);
+	transformation_operator : transformation;
+WHERE
+	WR1 : SELF\representation_relationship.rep_1.context_of_items
+           :<>: SELF\representation_relationship.rep_2.context_of_items;
+END_ENTITY;
+
+
+ENTITY requirement_assigned_object
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF requirement_assigned_item;
+	SELF\group_assignment.assigned_group : requirement_assignment;
+END_ENTITY;
+
+
+ENTITY requirement_assignment
+	SUBTYPE OF (characterized_object, group);
+END_ENTITY;
+
+
+ENTITY requirement_source
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY requirement_view_definition_relationship
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY resistance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RESISTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY resistance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = dimensions_for_si_unit (si_unit_name.ohm);
+END_ENTITY;
+
+
+ENTITY revolved_area_solid
+	SUBTYPE OF (swept_area_solid);
+	axis : axis1_placement;
+	angle : plane_angle_measure;
+DERIVE
+	axis_line : line := representation_item('')||
+                    geometric_representation_item()|| curve()||
+                    line(axis.location, representation_item('')||
+                    geometric_representation_item()||
+                    vector(axis.z, 1.0));
+END_ENTITY;
+
+
+ENTITY revolved_face_solid
+	SUBTYPE OF (swept_face_solid);
+	axis : axis1_placement;
+	angle : plane_angle_measure;
+DERIVE
+	axis_line : line := representation_item('')||
+                    geometric_representation_item()|| curve()||
+                    line(axis.location, representation_item('')||
+                    geometric_representation_item()||
+                    vector(axis.z, 1.0));
+END_ENTITY;
+
+
+ENTITY revolved_face_solid_with_trim_conditions
+	SUBTYPE OF (revolved_face_solid);
+	first_trim_condition : trim_condition_select;
+	second_trim_condition : trim_condition_select;
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(first_trim_condition)) 
+         OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' 
+         IN TYPEOF(second_trim_condition)));
+	WR2 : NOT((('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(first_trim_condition)) AND
+            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' 
+         IN TYPEOF(second_trim_condition))) AND
+         (first_trim_condition = second_trim_condition));
+END_ENTITY;
+
+
+ENTITY right_angular_wedge
+	SUBTYPE OF (geometric_representation_item);
+	position : axis2_placement_3d;
+	x : positive_length_measure;
+	y : positive_length_measure;
+	z : positive_length_measure;
+	ltx : length_measure;
+WHERE
+	WR1 : ((0.0 <= ltx) AND (ltx < x));
+END_ENTITY;
+
+
+ENTITY right_circular_cone
+	SUBTYPE OF (geometric_representation_item);
+	position : axis1_placement;
+	height : positive_length_measure;
+	radius : length_measure;
+	semi_angle : plane_angle_measure;
+WHERE
+	WR1 : radius >= 0.0;
+END_ENTITY;
+
+
+ENTITY right_circular_cylinder
+	SUBTYPE OF (geometric_representation_item);
+	position : axis1_placement;
+	height : positive_length_measure;
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY right_to_usage_association
+	SUBTYPE OF (action_method_relationship);
+	SELF\action_method_relationship.related_method : information_right;
+	SELF\action_method_relationship.relating_method : information_usage_right;
+DERIVE
+	right_applied : information_right := SELF\action_method_relationship.related_method;
+	right_usage : information_usage_right := SELF\action_method_relationship.relating_method;
+END_ENTITY;
+
+
+ENTITY role_association;
+	role : object_role;
+	item_with_role : role_select;
+END_ENTITY;
+
+
+ENTITY roundness_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY row_representation_item
+	SUBTYPE OF (compound_representation_item);
+	SELF\compound_representation_item.item_element : list_representation_item;
+END_ENTITY;
+
+
+ENTITY row_value
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY row_variable
+	SUBTYPE OF (abstract_variable);
+END_ENTITY;
+
+
+ENTITY rule_action
+	SUBTYPE OF (action);
+END_ENTITY;
+
+
+ENTITY rule_condition
+	SUBTYPE OF (atomic_formula);
+END_ENTITY;
+
+
+ENTITY rule_definition
+	SUBTYPE OF (rule_software_definition);
+END_ENTITY;
+
+
+ENTITY rule_set
+	SUBTYPE OF (rule_software_definition);
+END_ENTITY;
+
+
+ENTITY rule_set_group
+	SUBTYPE OF (rule_software_definition);
+END_ENTITY;
+
+
+ENTITY rule_software_definition
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY rule_superseded_assignment
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF rule_superseded_item;
+END_ENTITY;
+
+
+ENTITY rule_supersedence
+	SUBTYPE OF (rule_action);
+END_ENTITY;
+
+
+ENTITY ruled_surface_swept_area_solid
+	SUBTYPE OF (surface_curve_swept_area_solid);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(SELF.reference_surface)) AND
+         (SELF.reference_surface\b_spline_surface.u_degree = 1);
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(SELF.directrix)) OR
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF(SELF.directrix\surface_curve.curve_3d))
+         AND
+         (SELF.directrix\surface_curve.curve_3d\b_spline_curve.degree =
+         SELF.reference_surface\b_spline_surface.v_degree));
+END_ENTITY;
+
+
+ENTITY runout_zone_definition
+	SUBTYPE OF (tolerance_zone_definition);
+	orientation : runout_zone_orientation;
+END_ENTITY;
+
+
+ENTITY runout_zone_orientation;
+	angle : measure_with_unit;
+END_ENTITY;
+
+
+ENTITY runout_zone_orientation_reference_direction
+	SUBTYPE OF (runout_zone_orientation);
+	orientation_defining_relationship : shape_aspect_relationship;
+END_ENTITY;
+
+
+ENTITY satisfied_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition;
+	SELF\group_assignment.assigned_group : satisfies_requirement;
+END_ENTITY;
+
+
+ENTITY satisfies_requirement
+	SUBTYPE OF (group);
+END_ENTITY;
+
+
+ENTITY satisfying_item
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF requirement_satisfaction_item;
+	SELF\group_assignment.assigned_group : satisfies_requirement;
+END_ENTITY;
+
+
+ENTITY scalar_variable
+	SUBTYPE OF (abstract_variable);
+END_ENTITY;
+
+
+ENTITY scattering_parameter
+	SUBTYPE OF (polar_complex_number_literal);
+WHERE
+	WR1 : SIZEOF(TYPEOF(SELF) - (TYPEOF(SELF\polar_complex_number_literal ||
+       SELF\scattering_parameter))) = 0;
+END_ENTITY;
+
+
+ENTITY sculptured_solid
+	SUBTYPE OF (modified_solid);
+	sculpturing_element : generalized_surface_select;
+	positive_side : BOOLEAN;
+END_ENTITY;
+
+
+ENTITY seam_curve
+	SUBTYPE OF (surface_curve);
+WHERE
+	WR1 : SIZEOF(SELF\surface_curve.associated_geometry) = 2;
+	WR2 : associated_surface(SELF\surface_curve.associated_geometry[1]) =
+           associated_surface(SELF\surface_curve.associated_geometry[2]);
+	WR3 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+           TYPEOF(SELF\surface_curve.associated_geometry[1]);
+	WR4 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN
+            TYPEOF(SELF\surface_curve.associated_geometry[2]);
+END_ENTITY;
+
+
+ENTITY security_classification;
+	name : label;
+	purpose : text;
+	security_level : security_classification_level;
+END_ENTITY;
+
+
+ENTITY security_classification_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_security_classification : security_classification;
+DERIVE
+	role : object_role := get_role(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.ITEM_WITH_ROLE')) <= 1;
+END_ENTITY;
+
+
+ENTITY security_classification_level;
+	name : label;
+END_ENTITY;
+
+
+ENTITY serial_numbered_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_start_id : identifier;
+	effectivity_end_id : OPTIONAL identifier;
+END_ENTITY;
+
+
+ENTITY shape_aspect;
+	name : label;
+	description : OPTIONAL text;
+	of_shape : product_definition_shape;
+	product_definitional : LOGICAL;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY shape_aspect_associativity
+	SUBTYPE OF (shape_aspect_relationship);
+WHERE
+	WR1 : SELF.relating_shape_aspect.product_definitional;
+	WR2 : NOT (SELF.related_shape_aspect.product_definitional);
+END_ENTITY;
+
+
+ENTITY shape_aspect_deriving_relationship
+	SUBTYPE OF (shape_aspect_relationship);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DERIVED_SHAPE_ASPECT' IN
+TYPEOF
+            (SELF\SHAPE_ASPECT_RELATIONSHIP.RELATING_SHAPE_ASPECT);
+END_ENTITY;
+
+
+ENTITY shape_aspect_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_shape_aspect : shape_aspect;
+	related_shape_aspect : shape_aspect;
+DERIVE
+	id : identifier := get_id_value(SELF);
+WHERE
+	WR1 : SIZEOF(USEDIN(SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.IDENTIFIED_ITEM')) <= 1;
+END_ENTITY;
+
+
+ENTITY shape_definition_representation
+	SUBTYPE OF (property_definition_representation);
+WHERE
+	WR1 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_SHAPE' IN TYPEOF(SELF.definition)) OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_DEFINITION' IN TYPEOF(SELF.definition.definition));
+	WR2 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN TYPEOF(SELF.used_representation);
+END_ENTITY;
+
+
+ENTITY shape_dimension_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF (QUERY (temp <* SELF\representation.items | 
+    NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' 
+        IN TYPEOF (temp)))) = 0;
+	WR2 : SIZEOF (SELF\representation.items) <= 3;
+	WR3 : SIZEOF (QUERY (pos_mri <* QUERY (real_mri <*
+        SELF\representation.items | 'REAL' IN TYPEOF
+        (real_mri\measure_with_unit.value_component) ) |        
+     NOT  (pos_mri\measure_with_unit.value_component > 0.0 ))) = 0;
+END_ENTITY;
+
+
+ENTITY shape_feature_definition
+	SUBTYPE OF (characterized_object);
+END_ENTITY;
+
+
+ENTITY shape_representation
+	SUBTYPE OF (representation);
+END_ENTITY;
+
+
+ENTITY shape_representation_relationship
+	SUBTYPE OF (representation_relationship);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION' IN (TYPEOF(SELF\representation_relationship.rep_1) + TYPEOF(SELF\representation_relationship.rep_2));
+END_ENTITY;
+
+
+ENTITY shape_representation_with_parameters
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF( QUERY( i <* SELF.items | SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLACEMENT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM'] * TYPEOF(i)) = 1 )) = SIZEOF(SELF.items);
+END_ENTITY;
+
+
+ENTITY shell_based_surface_model
+	SUBTYPE OF (geometric_representation_item);
+	sbsm_boundary : SET [1:?] OF shell;
+WHERE
+	WR1 : constraints_geometry_shell_based_surface_model(SELF);
+END_ENTITY;
+
+
+ENTITY shell_based_wireframe_model
+	SUBTYPE OF (geometric_representation_item);
+	sbwm_boundary : SET [1:?] OF shell;
+WHERE
+	WR1 : constraints_geometry_shell_based_wireframe_model(SELF);
+END_ENTITY;
+
+
+ENTITY shell_based_wireframe_shape_representation
+	SUBTYPE OF (shape_representation);
+WHERE
+	WR1 : SIZEOF ( 
+QUERY ( it <* SELF.items| NOT ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT_3D' ] * TYPEOF (it)) = 1) )) = 0;
+	WR2 : SIZEOF ( 
+QUERY ( it <* SELF.items| ( SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' ] * TYPEOF (it)) = 1) )) >= 1;
+	WR3 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_CURVE' IN TYPEOF (el.edge_element)) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR4 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( pline_el <* 
+QUERY ( el <* eloop\path.edge_list| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF (el.edge_element\edge_curve.edge_geometry)) )| NOT ( SIZEOF (pline_el.edge_element\edge_curve.edge_geometry\polyline.points) > 2) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR5 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT valid_wireframe_edge_curve(el.edge_element\edge_curve.edge_geometry) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR6 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (el.edge_element.edge_start)) AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (el.edge_element.edge_end))) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR7 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( eloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE_LOOP' IN TYPEOF (wsb)) )| NOT ( SIZEOF ( 
+QUERY ( el <* eloop\path.edge_list| NOT (valid_wireframe_vertex_point(el.edge_element.edge_start\vertex_point.vertex_geometry) AND valid_wireframe_vertex_point(el.edge_element.edge_end\vertex_point.vertex_geometry)) )) = 0) )) = 0) )) = 0) )) = 0;
+	WR8 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( vloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (wsb)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (vloop\vertex_loop.loop_vertex)) )) = 0) )) = 0) )) = 0;
+	WR9 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( ws <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN TYPEOF (sb)) )| NOT ( SIZEOF ( 
+QUERY ( vloop <* 
+QUERY ( wsb <* ws\wire_shell.wire_shell_extent| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_LOOP' IN TYPEOF (wsb)) )| NOT valid_wireframe_vertex_point(vloop\vertex_loop.loop_vertex\vertex_point.vertex_geometry) )) = 0) )) = 0) )) = 0;
+	WR10 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( vs <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_SHELL' IN TYPEOF (sb)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_POINT' IN TYPEOF (vs\vertex_shell.vertex_shell_extent.loop_vertex)) )) = 0) )) = 0;
+	WR11 : SIZEOF ( 
+QUERY ( sbwm <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL_BASED_WIREFRAME_MODEL' IN TYPEOF (it)) )| NOT ( SIZEOF ( 
+QUERY ( vs <* 
+QUERY ( sb <* sbwm\shell_based_wireframe_model.sbwm_boundary| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_SHELL' IN TYPEOF (sb)) )| NOT valid_wireframe_vertex_point(vs\vertex_shell.vertex_shell_extent.loop_vertex\vertex_point.vertex_geometry) )) = 0) )) = 0;
+	WR12 : SIZEOF ( 
+QUERY ( mi <* 
+QUERY ( it <* SELF.items| ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (it)) )| NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION' IN TYPEOF (mi\mapped_item.mapping_source.mapped_representation)) )) = 0;
+	WR13 : SELF.context_of_items\geometric_representation_context.coordinate_space_dimension = 3;
+END_ENTITY;
+
+
+ENTITY shelled_solid
+	SUPERTYPE OF (ONEOF (double_offset_shelled_solid, complex_shelled_solid))
+	SUBTYPE OF (modified_solid);
+	deleted_face_set : SET [1:?] OF face_surface;
+	thickness : length_measure;
+WHERE
+	WR1 : thickness <> 0;
+END_ENTITY;
+
+
+ENTITY si_absorbed_dose_unit
+	SUBTYPE OF (absorbed_dose_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.gray;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_capacitance_unit
+	SUBTYPE OF (capacitance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.farad;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_conductance_unit
+	SUBTYPE OF (conductance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.siemens;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_dose_equivalent_unit
+	SUBTYPE OF (dose_equivalent_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.sievert;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_electric_charge_unit
+	SUBTYPE OF (electric_charge_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.coulomb;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_electric_potential_unit
+	SUBTYPE OF (electric_potential_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.volt;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_energy_unit
+	SUBTYPE OF (energy_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.joule;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_force_unit
+	SUBTYPE OF (force_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.newton;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_frequency_unit
+	SUBTYPE OF (frequency_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.hertz;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_illuminance_unit
+	SUBTYPE OF (illuminance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.lux;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_inductance_unit
+	SUBTYPE OF (inductance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.henry;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_magnetic_flux_density_unit
+	SUBTYPE OF (magnetic_flux_density_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.tesla;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_magnetic_flux_unit
+	SUBTYPE OF (magnetic_flux_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.weber;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_power_unit
+	SUBTYPE OF (power_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.watt;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_pressure_unit
+	SUBTYPE OF (pressure_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.pascal;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_radioactivity_unit
+	SUBTYPE OF (radioactivity_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.becquerel;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_resistance_unit
+	SUBTYPE OF (resistance_unit, si_unit);
+WHERE
+	WR1 : SELF\si_unit.name = si_unit_name.ohm;
+	WR2 : NOT EXISTS(SELF\derived_unit.name);
+END_ENTITY;
+
+
+ENTITY si_unit
+	SUBTYPE OF (named_unit);
+	prefix : OPTIONAL si_prefix;
+	name : si_unit_name;
+DERIVE
+	SELF\named_unit.dimensions : dimensional_exponents := dimensions_for_si_unit(name);
+WHERE
+	WR1 : NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MASS_UNIT' IN TYPEOF(SELF)) AND
+             (SIZEOF(USEDIN(SELF,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DERIVED_UNIT_ELEMENT.UNIT')) > 0)) OR
+            (prefix = si_prefix.kilo);
+END_ENTITY;
+
+
+ENTITY simple_boolean_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (boolean_expression, simple_generic_expression);
+END_ENTITY;
+
+
+ENTITY simple_clause
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY simple_generic_expression
+	ABSTRACT SUPERTYPE OF (ONEOF (generic_literal, generic_variable))
+	SUBTYPE OF (generic_expression);
+END_ENTITY;
+
+
+ENTITY simple_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, simple_generic_expression);
+END_ENTITY;
+
+
+ENTITY slash_expression
+	SUBTYPE OF (binary_numeric_expression);
+END_ENTITY;
+
+
+ENTITY smeared_material_definition
+	SUBTYPE OF (zone_structural_makeup);
+END_ENTITY;
+
+
+ENTITY solid_angle_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_ANGLE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY solid_angle_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY solid_curve_font
+	SUBTYPE OF (pre_defined_curve_font);
+END_ENTITY;
+
+
+ENTITY solid_model
+	SUPERTYPE OF (ONEOF (csg_solid, manifold_solid_brep, swept_face_solid, swept_area_solid, swept_disk_solid, solid_replica))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY solid_replica
+	SUBTYPE OF (solid_model);
+	parent_solid : solid_model;
+	transformation : cartesian_transformation_operator_3d;
+WHERE
+	WR1 : acyclic_solid_replica(SELF, parent_solid);
+	WR2 : parent_solid\geometric_representation_item.dim = 3;
+END_ENTITY;
+
+
+ENTITY solid_with_angle_based_chamfer
+	SUBTYPE OF (solid_with_chamfered_edges);
+	offset_distance : positive_length_measure;
+	left_offset : BOOLEAN;
+	offset_angle : positive_plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_chamfered_edges
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_single_offset_chamfer, solid_with_double_offset_chamfer, solid_with_angle_based_chamfer))
+	SUBTYPE OF (edge_blended_solid);
+END_ENTITY;
+
+
+ENTITY solid_with_circular_pattern
+	SUPERTYPE OF (solid_with_incomplete_circular_pattern)
+	SUBTYPE OF (solid_with_shape_element_pattern);
+	replicate_count : positive_integer;
+	angular_spacing : plane_angle_measure;
+	radial_alignment : BOOLEAN;
+	reference_point : point;
+END_ENTITY;
+
+
+ENTITY solid_with_circular_pocket
+	SUBTYPE OF (solid_with_pocket);
+	pocket_radius : positive_length_measure;
+WHERE
+	WR1 : SELF\solid_with_pocket.floor_blend_radius <= pocket_radius;
+END_ENTITY;
+
+
+ENTITY solid_with_circular_protrusion
+	SUBTYPE OF (solid_with_protrusion);
+	protrusion_radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_conical_bottom_round_hole
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	semi_apex_angle : positive_plane_angle_measure;
+	tip_radius : non_negative_length_measure;
+WHERE
+	WR1 : tip_radius < 
+          SELF\solid_with_stepped_round_hole.segment_radii[segments];
+END_ENTITY;
+
+
+ENTITY solid_with_constant_radius_edge_blend
+	SUBTYPE OF (edge_blended_solid);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_curved_slot
+	SUBTYPE OF (solid_with_slot);
+	slot_centreline : bounded_curve;
+END_ENTITY;
+
+
+ENTITY solid_with_depression
+	ABSTRACT SUPERTYPE OF ((solid_with_through_depression ANDOR ONEOF (solid_with_hole, solid_with_pocket, solid_with_slot, solid_with_groove)))
+	SUBTYPE OF (modified_solid_with_placed_configuration);
+	depth : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_double_offset_chamfer
+	SUBTYPE OF (solid_with_chamfered_edges);
+	left_offset_distance : positive_length_measure;
+	right_offset_distance : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_flat_bottom_round_hole
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	fillet_radius : non_negative_length_measure;
+WHERE
+	WR1 : fillet_radius < 
+          SELF\solid_with_stepped_round_hole.segment_radii[segments];
+END_ENTITY;
+
+
+ENTITY solid_with_general_pocket
+	SUBTYPE OF (solid_with_pocket);
+	profile : positioned_sketch;
+	reference_point : point;
+WHERE
+	WR1 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE',
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE'] * TYPEOF(profile.sketch_basis)) = 1;
+	WR2 : profile IN using_items(reference_point,[]);
+END_ENTITY;
+
+
+ENTITY solid_with_general_protrusion
+	SUBTYPE OF (solid_with_protrusion);
+	profile : positioned_sketch;
+	reference_point : point;
+WHERE
+	WR1 : SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE',
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE'] * TYPEOF(profile.sketch_basis)) = 1;
+	WR2 : profile IN using_items(reference_point,[]);
+END_ENTITY;
+
+
+ENTITY solid_with_groove
+	SUBTYPE OF (solid_with_depression);
+	groove_radius : positive_length_measure;
+	groove_width : positive_length_measure;
+	draft_angle : plane_angle_measure;
+	floor_fillet_radius : non_negative_length_measure;
+	external_groove : BOOLEAN;
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION'
+         IN TYPEOF(SELF));
+END_ENTITY;
+
+
+ENTITY solid_with_hole
+	ABSTRACT SUPERTYPE OF (solid_with_stepped_round_hole)
+	SUBTYPE OF (solid_with_depression);
+END_ENTITY;
+
+
+ENTITY solid_with_incomplete_circular_pattern
+	SUBTYPE OF (solid_with_circular_pattern);
+	omitted_instances : SET [1:?] OF positive_integer;
+WHERE
+	WR1 : SIZEOF(omitted_instances) <
+         SELF\solid_with_circular_pattern.replicate_count;
+	WR2 : SIZEOF(QUERY(q <* omitted_instances | q > 
+         SELF\solid_with_circular_pattern.replicate_count)) = 0;
+END_ENTITY;
+
+
+ENTITY solid_with_incomplete_rectangular_pattern
+	SUBTYPE OF (solid_with_rectangular_pattern);
+	omitted_instances : SET [1:?] OF LIST [2:2] OF positive_integer;
+WHERE
+	WR1 : NOT([1,1] IN omitted_instances);
+	WR2 : SIZEOF(omitted_instances) <
+         ((SELF\solid_with_rectangular_pattern.row_count *
+           SELF\solid_with_rectangular_pattern.column_count) - 1);
+	WR3 : SIZEOF(QUERY(q <* omitted_instances |
+         ((q[1] > SELF\solid_with_rectangular_pattern.row_count) OR
+          (q[2] > SELF\solid_with_rectangular_pattern.column_count)))) = 0;
+END_ENTITY;
+
+
+ENTITY solid_with_pocket
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_rectangular_pocket, solid_with_circular_pocket, solid_with_general_pocket))
+	SUBTYPE OF (solid_with_depression);
+	floor_blend_radius : non_negative_length_measure;
+	draft_angle : plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_protrusion
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_circular_protrusion, solid_with_rectangular_protrusion, solid_with_general_protrusion))
+	SUBTYPE OF (modified_solid_with_placed_configuration);
+	protrusion_height : positive_length_measure;
+	protrusion_draft_angle : plane_angle_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_rectangular_pattern
+	SUPERTYPE OF (solid_with_incomplete_rectangular_pattern)
+	SUBTYPE OF (solid_with_shape_element_pattern);
+	row_count : positive_integer;
+	column_count : positive_integer;
+	row_spacing : length_measure;
+	column_spacing : length_measure;
+WHERE
+	WR1 : (row_count * column_count) > 1;
+END_ENTITY;
+
+
+ENTITY solid_with_rectangular_pocket
+	SUBTYPE OF (solid_with_pocket);
+	pocket_length : positive_length_measure;
+	pocket_width : positive_length_measure;
+	corner_radius : non_negative_length_measure;
+WHERE
+	WR1 : (corner_radius < pocket_width/2) 
+         AND (corner_radius < pocket_length/2);
+END_ENTITY;
+
+
+ENTITY solid_with_rectangular_protrusion
+	SUBTYPE OF (solid_with_protrusion);
+	protrusion_length : positive_length_measure;
+	protrusion_width : positive_length_measure;
+	protrusion_corner_radius : non_negative_length_measure;
+WHERE
+	WR1 : (protrusion_corner_radius <= protrusion_width/2) 
+         AND (protrusion_corner_radius <= protrusion_length/2);
+END_ENTITY;
+
+
+ENTITY solid_with_shape_element_pattern
+	ABSTRACT SUPERTYPE OF (ONEOF (solid_with_circular_pattern, solid_with_rectangular_pattern))
+	SUBTYPE OF (modified_solid_with_placed_configuration);
+	replicated_element : modified_solid_with_placed_configuration;
+END_ENTITY;
+
+
+ENTITY solid_with_single_offset_chamfer
+	SUBTYPE OF (solid_with_chamfered_edges);
+	offset_distance : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_slot
+	ABSTRACT SUPERTYPE OF ((ONEOF (solid_with_trapezoidal_section_slot, solid_with_tee_section_slot) AND ONEOF (solid_with_straight_slot, solid_with_curved_slot)))
+	SUBTYPE OF (solid_with_depression);
+	slot_width : positive_length_measure;
+	closed_ends : LIST [2:2] OF LOGICAL;
+	end_exit_faces : LIST [2:2] OF SET [0:?] OF face_surface;
+WHERE
+	WR1 : NOT(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION' IN
+         TYPEOF(SELF)) AND (closed_ends = [FALSE,FALSE]));
+	WR2 : NOT(((closed_ends[1] = TRUE) AND (SIZEOF(end_exit_faces[1]) <> 0))
+         OR ((closed_ends[2] = TRUE) AND (SIZEOF(end_exit_faces[2]) <> 0)));
+END_ENTITY;
+
+
+ENTITY solid_with_spherical_bottom_round_hole
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	sphere_radius : positive_length_measure;
+WHERE
+	WR1 : sphere_radius >= 
+          SELF\solid_with_stepped_round_hole.segment_radii[segments];
+END_ENTITY;
+
+
+ENTITY solid_with_stepped_round_hole
+	SUPERTYPE OF ((solid_with_stepped_round_hole_and_conical_transitions ANDOR ONEOF (solid_with_flat_bottom_round_hole, solid_with_conical_bottom_round_hole, solid_with_spherical_bottom_round_hole)))
+	SUBTYPE OF (solid_with_hole);
+	segments : positive_integer;
+	segment_radii : LIST [1:segments] OF positive_length_measure;
+	segment_depths : LIST [1:segments] OF positive_length_measure;
+DERIVE
+	SELF\solid_with_depression.depth : positive_length_measure := compute_total_depth(SELF);
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION'
+       IN TYPEOF(SELF)) AND (SIZEOF(TYPEOF(SELF) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_FLAT_BOTTOM_ROUND_HOLE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_SPHERICAL_BOTTOM_ROUND_HOLE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_FLAT_BOTTOM_ROUND_HOLE']) 
+       <> 0));
+END_ENTITY;
+
+
+ENTITY solid_with_stepped_round_hole_and_conical_transitions
+	SUBTYPE OF (solid_with_stepped_round_hole);
+	conical_transitions : SET [1:?] OF conical_stepped_hole_transition;
+WHERE
+	WR1 : SIZEOF (conical_transitions) <= 
+         (SELF\solid_with_stepped_round_hole.segments + 1);
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_THROUGH_DEPRESSION'
+         IN TYPEOF(SELF)) XOR (SIZEOF(conical_transitions) <= 
+         SELF\solid_with_stepped_round_hole.segments);
+	WR3 : validate_countersink_radii(SELF);
+END_ENTITY;
+
+
+ENTITY solid_with_straight_slot
+	SUBTYPE OF (solid_with_slot);
+	slot_length : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_tee_section_slot
+	SUBTYPE OF (solid_with_slot);
+	tee_section_width : positive_length_measure;
+	collar_depth : positive_length_measure;
+WHERE
+	WR1 : collar_depth < SELF\solid_with_depression.depth;
+	WR2 : tee_section_width > SELF\solid_with_slot.slot_width;
+END_ENTITY;
+
+
+ENTITY solid_with_through_depression
+	SUBTYPE OF (solid_with_depression);
+	exit_faces : SET [1:?] OF face_surface;
+WHERE
+	WR1 : SIZEOF(TYPEOF(SELF) *
+         ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_HOLE',
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_POCKET',
+          'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_SLOT']) = 1;
+END_ENTITY;
+
+
+ENTITY solid_with_trapezoidal_section_slot
+	SUBTYPE OF (solid_with_slot);
+	draft_angle : plane_angle_measure;
+	floor_fillet_radius : non_negative_length_measure;
+END_ENTITY;
+
+
+ENTITY solid_with_variable_radius_edge_blend
+	SUBTYPE OF (edge_blended_solid, track_blended_solid);
+	point_list : LIST [2:?] OF point;
+	radius_list : LIST [2:?] OF positive_length_measure;
+	edge_function_list : LIST [1:?] OF blend_radius_variation_type;
+WHERE
+	WR1 : SIZEOF(point_list) = SIZEOF(radius_list);
+	WR2 : SIZEOF(edge_function_list) = SIZEOF(radius_list) - 1;
+	WR3 : NOT((point_list[1] = point_list[HIINDEX(point_list)]) AND NOT 
+         (radius_list[1] = radius_list[HIINDEX(radius_list)]));
+END_ENTITY;
+
+
+ENTITY source_for_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF requirement_source_item;
+	SELF\group_assignment.assigned_group : requirement_source;
+END_ENTITY;
+
+
+ENTITY sourced_requirement
+	SUBTYPE OF (group_assignment);
+	items : SET [1:1] OF product_definition;
+	SELF\group_assignment.assigned_group : requirement_source;
+END_ENTITY;
+
+
+ENTITY specification_definition
+	SUBTYPE OF (product_definition);
+END_ENTITY;
+
+
+ENTITY specified_higher_usage_occurrence
+	SUBTYPE OF (assembly_component_usage);
+	upper_usage : assembly_component_usage;
+	next_usage : next_assembly_usage_occurrence;
+UNIQUE
+	UR1 : upper_usage, next_usage;
+WHERE
+	WR1 : SELF :<>: upper_usage;
+	WR2 : SELF\product_definition_relationship.relating_product_definition
+       :=: upper_usage.relating_product_definition;
+	WR3 : SELF\product_definition_relationship.related_product_definition
+       :=: next_usage.related_product_definition;
+	WR4 : (upper_usage.related_product_definition :=:
+       next_usage.relating_product_definition) OR
+       (SIZEOF (QUERY (pdr <* USEDIN (upper_usage.related_product_definition,
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_RELATIONSHIP.' +
+       'RELATED_PRODUCT_DEFINITION') |
+        pdr.relating_product_definition :=: 
+        next_usage.relating_product_definition)) = 1);
+	WR5 : SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NEXT_ASSEMBLY_USAGE_OCCURRENCE',
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SPECIFIED_HIGHER_USAGE_OCCURRENCE']
+       * TYPEOF(upper_usage)) = 1;
+END_ENTITY;
+
+
+ENTITY sphere
+	SUBTYPE OF (geometric_representation_item);
+	radius : positive_length_measure;
+	centre : point;
+END_ENTITY;
+
+
+ENTITY spherical_surface
+	SUBTYPE OF (elementary_surface);
+	radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY standard_uncertainty
+	SUPERTYPE OF (expanded_uncertainty)
+	SUBTYPE OF (uncertainty_qualifier);
+	uncertainty_value : REAL;
+END_ENTITY;
+
+
+ENTITY start_request
+	SUBTYPE OF (action_request_assignment);
+	items : SET [1:?] OF start_request_item;
+END_ENTITY;
+
+
+ENTITY start_work
+	SUBTYPE OF (action_assignment);
+	items : SET [1:?] OF work_item;
+END_ENTITY;
+
+
+ENTITY straightness_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF));
+END_ENTITY;
+
+
+ENTITY structured_dimension_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF (TYPEOF (SELF) *
+       ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_FEATURE_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DATUM_TARGET_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GEOMETRICAL_TOLERANCE_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LEADER_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROJECTION_DIRECTED_CALLOUT',
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIMENSION_CURVE_DIRECTED_CALLOUT']) = 0;
+	WR2 : SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (con))) |
+         NOT (ato.name IN
+             ['dimension value', 'tolerance value', 'unit text',
+              'prefix text', 'suffix text']))) = 0;
+	WR3 : SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF (con))) |
+         (ato.name = 'dimension value')
+       )) >= 1;
+	WR4 : SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+         'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+         'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND 
+         (dcr.name = 'prefix') )) <= 1;
+	WR5 : SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+         'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+         'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND 
+         (dcr.name = 'suffix') )) <= 1;
+	WR6 : NOT((SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con)) ) |
+         (ato.name = 'prefix text')
+       )) > 0)) OR
+       (SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                               'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+                               'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND  
+         (dcr.name = 'prefix') )) = 1);
+	WR7 : NOT(SIZEOF (QUERY (ato <* QUERY (con <* SELF.contents |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_OCCURRENCE'
+             IN TYPEOF(con))) |
+         (ato.name = 'suffix text')
+       )) > 0) OR
+       (SIZEOF (QUERY (dcr <* USEDIN (SELF, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                               'DRAUGHTING_CALLOUT_RELATIONSHIP.' +
+                               'RELATING_DRAUGHTING_CALLOUT') |
+         ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+          'DIMENSION_CALLOUT_COMPONENT_RELATIONSHIP' IN TYPEOF (dcr)) AND    
+            (dcr.name = 'suffix') )) = 1);
+END_ENTITY;
+
+
+ENTITY structured_text_composition
+	SUBTYPE OF (compound_representation_item);
+END_ENTITY;
+
+
+ENTITY structured_text_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF string_representation_item_select;
+END_ENTITY;
+
+
+ENTITY styled_item
+	SUBTYPE OF (representation_item);
+	styles : SET [1:?] OF presentation_style_assignment;
+	item : representation_item;
+WHERE
+	WR1 : (SIZEOF(SELF.styles) = 1)
+               XOR
+         (SIZEOF(QUERY(pres_style <* SELF.styles |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+              'PRESENTATION_STYLE_BY_CONTEXT' IN
+         TYPEOF(pres_style))
+         )) = 0);
+END_ENTITY;
+
+
+ENTITY subedge
+	SUBTYPE OF (edge);
+	parent_edge : edge;
+END_ENTITY;
+
+
+ENTITY subface
+	SUBTYPE OF (face);
+	parent_face : face;
+WHERE
+	WR1 : NOT (mixed_loop_type_set(list_to_set(list_face_loops(SELF)) +
+              list_to_set(list_face_loops(parent_face))));
+END_ENTITY;
+
+
+ENTITY supplied_part_relationship
+	SUBTYPE OF (product_definition_relationship);
+END_ENTITY;
+
+
+ENTITY surface
+	SUPERTYPE OF (ONEOF (elementary_surface, swept_surface, bounded_surface, offset_surface, surface_replica))
+	SUBTYPE OF (geometric_representation_item);
+END_ENTITY;
+
+
+ENTITY surface_condition_callout
+	SUBTYPE OF (draughting_callout);
+WHERE
+	WR1 : SIZEOF ( QUERY ( c <* SELF.contents | SIZEOF (
+         ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'ANNOTATION_CURVE_OCCURRENCE' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'ANNOTATION_SYMBOL_OCCURRENCE' ,
+         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'ANNOTATION_TEXT_OCCURRENCE']* TYPEOF
+         ( c ) ) <>1 ) ) =0;
+END_ENTITY;
+
+
+ENTITY surface_curve
+	SUPERTYPE OF ((ONEOF (intersection_curve, seam_curve) ANDOR bounded_surface_curve))
+	SUBTYPE OF (curve);
+	curve_3d : curve;
+	associated_geometry : LIST [1:2] OF pcurve_or_surface;
+	master_representation : preferred_surface_curve_representation;
+DERIVE
+	basis_surface : SET [1:2] OF surface := get_basis_surface(SELF);
+WHERE
+	WR1 : curve_3d.dim = 3;
+	WR2 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(associated_geometry[1])) OR
+                        (master_representation <> pcurve_s1);
+	WR3 : ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(associated_geometry[2])) OR
+                        (master_representation <> pcurve_s2);
+	WR4 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(curve_3d));
+END_ENTITY;
+
+
+ENTITY surface_curve_swept_area_solid
+	SUBTYPE OF (swept_area_solid);
+	directrix : curve;
+	start_param : REAL;
+	end_param : REAL;
+	reference_surface : surface;
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(directrix))) OR
+          (reference_surface IN (directrix\surface_curve.basis_surface));
+END_ENTITY;
+
+
+ENTITY surface_of_linear_extrusion
+	SUBTYPE OF (swept_surface);
+	extrusion_axis : vector;
+END_ENTITY;
+
+
+ENTITY surface_of_revolution
+	SUBTYPE OF (swept_surface);
+	axis_position : axis1_placement;
+DERIVE
+	axis_line : line := representation_item('')||
+                     geometric_representation_item()|| curve()||
+                     line(axis_position.location, representation_item('')||
+                     geometric_representation_item()||
+                     vector(axis_position.z, 1.0));
+END_ENTITY;
+
+
+ENTITY surface_patch
+	SUBTYPE OF (founded_item);
+	parent_surface : bounded_surface;
+	u_transition : transition_code;
+	v_transition : transition_code;
+	u_sense : BOOLEAN;
+	v_sense : BOOLEAN;
+INVERSE
+	using_surfaces: BAG [1:?] OF rectangular_composite_surface FOR segments;
+WHERE
+	WR1 : (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE' 
+                 IN TYPEOF(parent_surface)));
+END_ENTITY;
+
+
+ENTITY surface_profile_tolerance
+	SUBTYPE OF (geometric_tolerance);
+WHERE
+	WR1 : NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE' IN TYPEOF (SELF)) OR ( SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3);
+END_ENTITY;
+
+
+ENTITY surface_rendering_properties;
+	rendered_colour : colour;
+END_ENTITY;
+
+
+ENTITY surface_replica
+	SUBTYPE OF (surface);
+	parent_surface : surface;
+	transformation : cartesian_transformation_operator_3d;
+WHERE
+	WR1 : acyclic_surface_replica(SELF, parent_surface);
+END_ENTITY;
+
+
+ENTITY surface_side_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	styles : SET [1:7] OF surface_style_element_select;
+WHERE
+	WR1 : SIZEOF(QUERY( style1 <* SELF.styles |
+           SIZEOF(QUERY( style2 <* SELF.styles - style1 |
+           TYPEOF(style1) = TYPEOF(style2)
+           )) > 0
+           )) = 0;
+END_ENTITY;
+
+
+ENTITY surface_style_boundary
+	SUBTYPE OF (founded_item);
+	style_of_boundary : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_control_grid
+	SUBTYPE OF (founded_item);
+	style_of_control_grid : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_fill_area
+	SUBTYPE OF (founded_item);
+	fill_area : fill_area_style;
+END_ENTITY;
+
+
+ENTITY surface_style_parameter_line
+	SUBTYPE OF (founded_item);
+	style_of_parameter_lines : curve_or_render;
+	direction_counts : SET [1:2] OF direction_count_select;
+WHERE
+	WR1 : (HIINDEX(SELF.direction_counts) = 1)
+                        XOR
+         (TYPEOF(SELF.direction_counts[1]) <>
+          TYPEOF(SELF.direction_counts[2]));
+END_ENTITY;
+
+
+ENTITY surface_style_reflectance_ambient;
+	ambient_reflectance : REAL;
+END_ENTITY;
+
+
+ENTITY surface_style_reflectance_ambient_diffuse
+	SUBTYPE OF (surface_style_reflectance_ambient);
+	diffuse_reflectance : REAL;
+END_ENTITY;
+
+
+ENTITY surface_style_reflectance_ambient_diffuse_specular
+	SUBTYPE OF (surface_style_reflectance_ambient_diffuse);
+	specular_reflectance : REAL;
+	specular_exponent : REAL;
+	specular_colour : colour;
+END_ENTITY;
+
+
+ENTITY surface_style_rendering;
+	rendering_method : shading_surface_method;
+	surface_colour : colour;
+END_ENTITY;
+
+
+ENTITY surface_style_rendering_with_properties
+	SUBTYPE OF (surface_style_rendering);
+	properties : SET [1:2] OF rendering_properties_select;
+WHERE
+	WR1 : (HIINDEX(SELF.properties) = 1)
+                   XOR
+         (TYPEOF(SELF.properties[1]) <> TYPEOF(SELF.properties[2]));
+END_ENTITY;
+
+
+ENTITY surface_style_segmentation_curve
+	SUBTYPE OF (founded_item);
+	style_of_segmentation_curve : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_silhouette
+	SUBTYPE OF (founded_item);
+	style_of_silhouette : curve_or_render;
+END_ENTITY;
+
+
+ENTITY surface_style_transparent;
+	transparency : REAL;
+WHERE
+	WR1 : {0.0 <= transparency <= 1.0};
+END_ENTITY;
+
+
+ENTITY surface_style_usage
+	SUBTYPE OF (founded_item);
+	side : surface_side;
+	style : surface_side_style_select;
+END_ENTITY;
+
+
+ENTITY surface_texture_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF ( QUERY ( i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE' , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM']* TYPEOF ( i ) ) <>1 ) )
+        =0;
+	WR2 : ( SIZEOF ( QUERY ( i <* SELF.items | 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) ) =1 )
+        AND ( SIZEOF ( QUERY ( i <* SELF.items | (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'DESCRIPTIVE_REPRESENTATION_ITEM' IN
+        TYPEOF ( i ) ) AND ( i.name = 'measuring method' ) ) ) =1 );
+	WR3 : SIZEOF ( QUERY ( i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) =1 ) )
+        >0;
+	WR4 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_1' ) ) <=1 ) AND ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_2' ) ) =0 ) AND ( SIZEOF ( QUERY ( rr <* USEDIN ( SELF
+        , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_1' ) | rr. rep_2.name = 'measuring direction' ) ) =
+        SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'REPRESENTATION_RELATIONSHIP.'+
+        'REP_1' ) ) );
+	WR5 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )
+        ) =1 );
+END_ENTITY;
+
+
+ENTITY surfaced_open_shell
+	SUBTYPE OF (open_shell);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* SELF\connected_face_set.cfs_faces |
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_SURFACE' IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY swept_area_solid
+	SUPERTYPE OF (ONEOF (revolved_area_solid, extruded_area_solid, surface_curve_swept_area_solid))
+	SUBTYPE OF (solid_model);
+	swept_area : curve_bounded_surface;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(swept_area.basis_surface);
+END_ENTITY;
+
+
+ENTITY swept_disk_solid
+	SUBTYPE OF (solid_model);
+	directrix : curve;
+	radius : positive_length_measure;
+	inner_radius : OPTIONAL positive_length_measure;
+	start_param : REAL;
+	end_param : REAL;
+WHERE
+	WR1 : directrix.dim = 3;
+	WR2 : (NOT EXISTS(inner_radius)) OR (radius > inner_radius);
+END_ENTITY;
+
+
+ENTITY swept_face_solid
+	SUPERTYPE OF (ONEOF (extruded_face_solid, revolved_face_solid))
+	SUBTYPE OF (solid_model);
+	swept_face : face_surface;
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE' IN TYPEOF(swept_face.face_geometry);
+END_ENTITY;
+
+
+ENTITY swept_surface
+	SUPERTYPE OF (ONEOF (surface_of_linear_extrusion, surface_of_revolution))
+	SUBTYPE OF (surface);
+	swept_curve : curve;
+END_ENTITY;
+
+
+ENTITY symbol
+	SUBTYPE OF (representation_item);
+END_ENTITY;
+
+
+ENTITY symbol_colour;
+	colour_of_symbol : colour;
+END_ENTITY;
+
+
+ENTITY symbol_representation
+	SUBTYPE OF (representation);
+END_ENTITY;
+
+
+ENTITY symbol_representation_map
+	SUBTYPE OF (representation_map);
+	SELF\representation_map.mapped_representation : symbol_representation;
+	SELF\representation_map.mapping_origin : axis2_placement;
+END_ENTITY;
+
+
+ENTITY symbol_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	style_of_symbol : symbol_style_select;
+END_ENTITY;
+
+
+ENTITY symbol_target
+	SUBTYPE OF (geometric_representation_item);
+	placement : axis2_placement;
+	x_scale : positive_ratio_measure;
+	y_scale : positive_ratio_measure;
+END_ENTITY;
+
+
+ENTITY symmetric_shape_aspect
+	SUBTYPE OF (shape_aspect);
+INVERSE
+	basis_relationships: SET [1:?] OF shape_aspect_relationship FOR relating_shape_aspect;
+WHERE
+	WR1 : SIZEOF (QUERY (x<*SELF\symmetric_shape_aspect.basis_relationships |
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CENTRE_OF_SYMMETRY' IN TYPEOF 
+       (x\shape_aspect_relationship.related_shape_aspect)))>=1;
+END_ENTITY;
+
+
+ENTITY symmetry_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 3;
+END_ENTITY;
+
+
+ENTITY table_representation_item
+	SUBTYPE OF (compound_representation_item);
+WHERE
+	WR1 : SIZEOF(QUERY(itet <* SELF\compound_representation_item.item_element |
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ROW_REPRESENTATION_ITEM' IN TYPEOF(itet))
+            )) = 0;
+END_ENTITY;
+
+
+ENTITY tactile_appearance_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : SIZEOF ( QUERY ( i <* SELF.items | SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) <>1 )) =0;
+	WR2 : SIZEOF ( QUERY ( i <* SELF.items | name ='depth' ) ) <=1;
+	WR3 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )) =1 );
+END_ENTITY;
+
+
+ENTITY tagged_text_format
+	SUBTYPE OF (representation_context);
+END_ENTITY;
+
+
+ENTITY tagged_text_item
+	SUBTYPE OF (descriptive_representation_item);
+END_ENTITY;
+
+
+ENTITY tangent
+	SUBTYPE OF (derived_shape_aspect);
+WHERE
+	WR1 : SIZEOF (SELF\derived_shape_aspect.deriving_relationships)= 1;
+END_ENTITY;
+
+
+ENTITY terminator_symbol
+	SUBTYPE OF (annotation_symbol_occurrence);
+	annotated_curve : annotation_curve_occurrence;
+END_ENTITY;
+
+
+ENTITY text_font;
+	id : identifier;
+	name : label;
+	description : text;
+INVERSE
+	glyphs: SET [1:?] OF character_glyph_font_usage FOR font;
+END_ENTITY;
+
+
+ENTITY text_font_family;
+	id : identifier;
+	name : label;
+	description : text;
+INVERSE
+	fonts: SET [1:?] OF text_font_in_family FOR family;
+END_ENTITY;
+
+
+ENTITY text_font_in_family;
+	font : text_font;
+	family : text_font_family;
+END_ENTITY;
+
+
+ENTITY text_literal
+	SUBTYPE OF (geometric_representation_item);
+	literal : presentable_text;
+	placement : axis2_placement;
+	alignment : text_alignment;
+	path : text_path;
+	font : font_select;
+END_ENTITY;
+
+
+ENTITY text_literal_with_associated_curves
+	SUBTYPE OF (text_literal);
+	associated_curves : SET [1:?] OF curve;
+END_ENTITY;
+
+
+ENTITY text_literal_with_blanking_box
+	SUBTYPE OF (text_literal);
+	blanking : planar_box;
+END_ENTITY;
+
+
+ENTITY text_literal_with_delineation
+	SUBTYPE OF (text_literal);
+	delineation : text_delineation;
+END_ENTITY;
+
+
+ENTITY text_literal_with_extent
+	SUBTYPE OF (text_literal);
+	extent : planar_extent;
+END_ENTITY;
+
+
+ENTITY text_string_representation
+	SUBTYPE OF (representation);
+	SELF\representation.items : SET [1:?] OF text_string_representation_item;
+WHERE
+	WR1 : SIZEOF (
+         QUERY (item <* SELF\representation.items |
+           NOT (SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT_CHARACTER',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEFINED_CHARACTER_GLYPH',
+                         'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'] *
+                 TYPEOF (item)) = 0)
+         )) >= 1;
+	WR2 : SIZEOF (
+         QUERY (a2p <* 
+           QUERY (item <* SELF\representation.items | 
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AXIS2_PLACEMENT' IN TYPEOF (item)) |
+           NOT ((SIZEOF (
+             QUERY (at <* 
+               QUERY (item <* SELF\representation.items | 
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                  'ANNOTATION_TEXT' IN TYPEOF (item)) | 
+               (at\mapped_item.mapping_target :=: a2p))) >= 1) OR
+           (SIZEOF (
+             QUERY (atc <* 
+               QUERY (item <* SELF\representation.items |
+                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 
+                 'ANNOTATION_TEXT_CHARACTER' IN TYPEOF (item)) | 
+               (atc\mapped_item.mapping_target :=: a2p))) >= 1)
+          ))) = 0;
+END_ENTITY;
+
+
+ENTITY text_style
+	SUBTYPE OF (founded_item);
+	name : label;
+	character_appearance : character_style_select;
+END_ENTITY;
+
+
+ENTITY text_style_for_defined_font;
+	text_colour : colour;
+END_ENTITY;
+
+
+ENTITY text_style_with_box_characteristics
+	SUBTYPE OF (text_style);
+	characteristics : SET [1:4] OF box_characteristic_select;
+WHERE
+	WR1 : SIZEOF( QUERY( c1 <* SELF.characteristics |
+           SIZEOF( QUERY( c2 <* SELF.characteristics - c1 |
+           TYPEOF (c1) = TYPEOF (c2)
+           )) > 0
+           )) = 0;
+END_ENTITY;
+
+
+ENTITY text_style_with_mirror
+	SUBTYPE OF (text_style);
+	mirror_placement : axis2_placement;
+END_ENTITY;
+
+
+ENTITY text_style_with_spacing
+	SUBTYPE OF (text_style);
+	character_spacing : character_spacing_select;
+END_ENTITY;
+
+
+ENTITY thermal_resistance_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMAL_RESISTANCE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY thermal_resistance_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+        dimensional_exponents ( -1.0, -1.0, -3.0, 0.0, 1.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY thermodynamic_temperature_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMODYNAMIC_TEMPERATURE_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY thermodynamic_temperature_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 0.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 1.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY thickened_face_solid
+	SUBTYPE OF (solid_model);
+	base_element : generalized_surface_select;
+	offset1 : length_measure;
+	offset2 : length_measure;
+WHERE
+	WR1 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(base_element)) AND
+    (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_SURFACE' IN TYPEOF(base_element))));
+	WR2 : offset1 <> offset2;
+END_ENTITY;
+
+
+ENTITY thickness_laminate_definition
+	SUBTYPE OF (product_definition);
+WHERE
+	WR1 : SIZEOF (QUERY (pdr <* USEDIN (SELF, 
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'PRODUCT_DEFINITION_RELATIONSHIP.' +
+                             'RELATING_PRODUCT_DEFINITION') |
+                             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                             'NEXT_ASSEMBLY_USAGE_OCCURRENCE' IN
+                             TYPEOF (pdr))) = 1;
+END_ENTITY;
+
+
+ENTITY thickness_laminate_table
+	SUBTYPE OF (zone_structural_makeup);
+END_ENTITY;
+
+
+ENTITY time_interval;
+	id : identifier;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY time_interval_assignment
+	ABSTRACT SUPERTYPE;
+	assigned_time_interval : time_interval;
+	role : time_interval_role;
+END_ENTITY;
+
+
+ENTITY time_interval_based_effectivity
+	SUBTYPE OF (effectivity);
+	effectivity_period : time_interval;
+END_ENTITY;
+
+
+ENTITY time_interval_relationship;
+	name : label;
+	description : OPTIONAL text;
+	relating_time_interval : time_interval;
+	related_time_interval : time_interval;
+END_ENTITY;
+
+
+ENTITY time_interval_role;
+	name : label;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY time_interval_with_bounds
+	SUBTYPE OF (time_interval);
+	primary_bound : OPTIONAL date_time_or_event_occurrence;
+	secondary_bound : OPTIONAL date_time_or_event_occurrence;
+	duration : OPTIONAL time_measure_with_unit;
+WHERE
+	WR1 : NOT (EXISTS(secondary_bound) AND EXISTS(duration));
+	WR2 : EXISTS(primary_bound) OR EXISTS(secondary_bound);
+END_ENTITY;
+
+
+ENTITY time_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TIME_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY time_unit
+	SUBTYPE OF (named_unit);
+WHERE
+	WR1 : (SELF\named_unit.dimensions.length_exponent = 0.0) AND (SELF\named_unit.dimensions.mass_exponent = 0.0) AND (SELF\named_unit.dimensions.time_exponent = 1.0) AND (SELF\named_unit.dimensions.electric_current_exponent = 0.0) AND (SELF\named_unit.dimensions.thermodynamic_temperature_exponent = 0.0) AND (SELF\named_unit.dimensions.amount_of_substance_exponent = 0.0) AND (SELF\named_unit.dimensions.luminous_intensity_exponent = 0.0);
+END_ENTITY;
+
+
+ENTITY tolerance_value;
+	lower_bound : measure_with_unit;
+	upper_bound : measure_with_unit;
+DERIVE
+	lbvc : REAL := lower_bound\measure_with_unit.value_component;
+	ubvc : REAL := upper_bound\measure_with_unit.value_component;
+WHERE
+	WR1 : ubvc > lbvc;
+	WR2 : upper_bound\measure_with_unit.unit_component =
+        lower_bound\measure_with_unit.unit_component;
+END_ENTITY;
+
+
+ENTITY tolerance_zone
+	SUBTYPE OF (shape_aspect);
+	defining_tolerance : SET [1:?] OF geometric_tolerance;
+	form : tolerance_zone_form;
+END_ENTITY;
+
+
+ENTITY tolerance_zone_definition
+	SUPERTYPE OF (ONEOF (projected_zone_definition, runout_zone_definition));
+	zone : tolerance_zone;
+	boundaries : SET [1:?] OF shape_aspect;
+END_ENTITY;
+
+
+ENTITY tolerance_zone_form;
+	name : label;
+END_ENTITY;
+
+
+ENTITY topological_representation_item
+	SUPERTYPE OF (ONEOF (vertex, edge, face_bound, face, vertex_shell, wire_shell, connected_edge_set, connected_face_set, (loop ANDOR path)))
+	SUBTYPE OF (representation_item);
+END_ENTITY;
+
+
+ENTITY toroidal_surface
+	SUBTYPE OF (elementary_surface);
+	major_radius : positive_length_measure;
+	minor_radius : positive_length_measure;
+END_ENTITY;
+
+
+ENTITY torus
+	SUBTYPE OF (geometric_representation_item);
+	position : axis1_placement;
+	major_radius : positive_length_measure;
+	minor_radius : positive_length_measure;
+WHERE
+	WR1 : major_radius > minor_radius;
+END_ENTITY;
+
+
+ENTITY total_runout_tolerance
+	SUBTYPE OF (geometric_tolerance_with_datum_reference);
+WHERE
+	WR1 : SIZEOF (SELF\geometric_tolerance_with_datum_reference.datum_system) <= 2;
+END_ENTITY;
+
+
+ENTITY track_blended_solid
+	ABSTRACT SUPERTYPE OF (track_blended_solid_with_end_conditions)
+	SUBTYPE OF (edge_blended_solid);
+WHERE
+	WR1 : check_continuous_edges(SELF\edge_blended_solid.blended_edges);
+END_ENTITY;
+
+
+ENTITY track_blended_solid_with_end_conditions
+	SUBTYPE OF (track_blended_solid);
+	end_conditions : LIST [2:2] OF blend_end_condition_select;
+WHERE
+	WR1 : SIZEOF(TYPEOF(SELF) *
+    ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_CONSTANT_RADIUS_EDGE_BLEND',
+     'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_VARIABLE_RADIUS_EDGE_BLEND',
+     'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_WITH_CHAMFERED_EDGES']) = 1;
+	WR2 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[1]))
+       AND ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[2])));
+	WR3 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[1]))
+       AND (NOT ((end_conditions[1] 
+            :=: SELF\edge_blended_solid.blended_edges[1].edge_start)
+            XOR (end_conditions[1] 
+            :=: SELF\edge_blended_solid.blended_edges[1].edge_end))));
+	WR4 : NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX' IN TYPEOF(end_conditions[2]))
+       AND (NOT ((end_conditions[2] 
+            :=: SELF\edge_blended_solid.blended_edges[HIINDEX(
+                SELF\edge_blended_solid.blended_edges)].edge_start)
+            XOR (end_conditions[2] 
+            :=: SELF\edge_blended_solid.blended_edges[HIINDEX(
+                SELF\edge_blended_solid.blended_edges)].edge_end))));
+END_ENTITY;
+
+
+ENTITY transformation_with_derived_angle
+	SUPERTYPE OF (ONEOF (draped_defined_transformation, laid_defined_transformation))
+	SUBTYPE OF (item_defined_transformation);
+	SELF\item_defined_transformation.transform_item_1 : angle_direction_reference_with_a2p3d_select;
+	SELF\item_defined_transformation.transform_item_2 : axis2_placement_3d;
+DERIVE
+	orientation_angle : plane_angle_measure := derive_angle (
+        SELF\item_defined_transformation.transform_item_1,
+        SELF\item_defined_transformation.transform_item_2);
+WHERE
+	WR1 : (SELF\item_defined_transformation.transform_item_1\
+            axis2_placement_3d.p[3].direction_ratios[1] =
+            SELF\item_defined_transformation.transform_item_2\
+            axis2_placement_3d.p[3].direction_ratios[1])
+          AND
+           (SELF\item_defined_transformation.transform_item_1\
+            axis2_placement_3d.p[3].direction_ratios[2] =
+            SELF\item_defined_transformation.transform_item_2\
+            axis2_placement_3d.p[3].direction_ratios[2])
+          AND
+           (SELF\item_defined_transformation.transform_item_1\
+            axis2_placement_3d.p[3].direction_ratios[3] =
+            SELF\item_defined_transformation.transform_item_2\
+            axis2_placement_3d.p[3].direction_ratios[3]);
+END_ENTITY;
+
+
+ENTITY trimmed_curve
+	SUBTYPE OF (bounded_curve);
+	basis_curve : curve;
+	trim_1 : SET [1:2] OF trimming_select;
+	trim_2 : SET [1:2] OF trimming_select;
+	sense_agreement : BOOLEAN;
+	master_representation : trimming_preference;
+WHERE
+	WR1 : (HIINDEX(trim_1) = 1) OR (TYPEOF(trim_1[1]) <> TYPEOF(trim_1[2]));
+	WR2 : (HIINDEX(trim_2) = 1) OR (TYPEOF(trim_2[1]) <> TYPEOF(trim_2[2]));
+END_ENTITY;
+
+
+ENTITY two_direction_repeat_factor
+	SUBTYPE OF (one_direction_repeat_factor);
+	second_repeat_factor : vector;
+END_ENTITY;
+
+
+ENTITY type_qualifier;
+	name : label;
+END_ENTITY;
+
+
+ENTITY unary_generic_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (generic_expression);
+	operand : generic_expression;
+END_ENTITY;
+
+
+ENTITY unary_numeric_expression
+	ABSTRACT SUPERTYPE
+	SUBTYPE OF (numeric_expression, unary_generic_expression);
+	SELF\unary_generic_expression.operand : numeric_expression;
+END_ENTITY;
+
+
+ENTITY uncertainty_assigned_representation
+	SUBTYPE OF (representation);
+	uncertainty : SET [1:?] OF uncertainty_measure_with_unit;
+END_ENTITY;
+
+
+ENTITY uncertainty_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+	name : label;
+	description : OPTIONAL text;
+WHERE
+	WR1 : valid_measure_value (SELF\measure_with_unit.value_component);
+END_ENTITY;
+
+
+ENTITY uncertainty_qualifier
+	SUPERTYPE OF (ONEOF (standard_uncertainty, qualitative_uncertainty));
+	measure_name : label;
+	description : text;
+END_ENTITY;
+
+
+ENTITY uniform_curve
+	SUBTYPE OF (b_spline_curve);
+END_ENTITY;
+
+
+ENTITY uniform_resource_identifier
+	SUBTYPE OF (descriptive_representation_item);
+END_ENTITY;
+
+
+ENTITY uniform_surface
+	SUBTYPE OF (b_spline_surface);
+END_ENTITY;
+
+
+ENTITY usage_association
+	SUBTYPE OF (action_method_relationship);
+	SELF\action_method_relationship.related_method : information_usage_right;
+	SELF\action_method_relationship.relating_method : information_usage_right;
+DERIVE
+	related : information_usage_right := SELF\action_method_relationship.related_method;
+	relating : information_usage_right := SELF\action_method_relationship.relating_method;
+END_ENTITY;
+
+
+ENTITY user_defined_curve_font
+	SUBTYPE OF (curve_style_font, mapped_item);
+END_ENTITY;
+
+
+ENTITY user_defined_marker
+	SUBTYPE OF (mapped_item, pre_defined_marker);
+END_ENTITY;
+
+
+ENTITY user_defined_terminator_symbol
+	SUBTYPE OF (mapped_item, pre_defined_symbol);
+END_ENTITY;
+
+
+ENTITY user_selected_elements
+	SUBTYPE OF (representation_item);
+	picked_items : SET [1:?] OF representation_item;
+END_ENTITY;
+
+
+ENTITY user_selected_shape_elements
+	SUBTYPE OF (user_selected_elements);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* 
+    SELF\user_selected_elements.picked_items | NOT
+    ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_ITEM'
+    IN TYPEOF(q)))) = 0;
+END_ENTITY;
+
+
+ENTITY value_range
+	SUBTYPE OF (compound_representation_item);
+WHERE
+	WR1 : ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'SET_REPRESENTATION_ITEM' IN TYPEOF ( item_element ) ) AND value_range_wr1 ( item_element );
+	WR2 : value_range_wr2 ( item_element );
+	WR3 : value_range_wr3 ( item_element );
+END_ENTITY;
+
+
+ENTITY value_representation_item
+	SUBTYPE OF (representation_item);
+	value_component : measure_value;
+WHERE
+	WR1 : SIZEOF (QUERY (rep <* using_representations (SELF) |
+        NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.GLOBAL_UNIT_ASSIGNED_CONTEXT'
+        IN TYPEOF (rep.context_of_items)
+        ))) = 0;
+END_ENTITY;
+
+
+ENTITY variable_semantics
+	ABSTRACT SUPERTYPE;
+END_ENTITY;
+
+
+ENTITY variational_representation_item
+	ABSTRACT SUPERTYPE OF (auxiliary_geometric_representation_item)
+	SUBTYPE OF (representation_item);
+WHERE
+	WR1 : SIZEOF(QUERY(q <* using_representations(SELF) |
+    NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VARIATIONAL_REPRESENTATION'  
+    IN TYPEOF(q)))) = 0;
+	WR2 : SIZEOF(QUERY(q <* using_representations(SELF) |
+    NOT (SELF IN q.items))) = 0;
+END_ENTITY;
+
+
+ENTITY vector
+	SUBTYPE OF (geometric_representation_item);
+	orientation : direction;
+	magnitude : length_measure;
+WHERE
+	WR1 : magnitude >= 0.0;
+END_ENTITY;
+
+
+ENTITY vector_style
+	SUBTYPE OF (curve_style, pre_defined_terminator_symbol);
+END_ENTITY;
+
+
+ENTITY velocity_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VELOCITY_UNIT' IN TYPEOF (SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY velocity_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+       dimensional_exponents ( 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY versioned_action_request;
+	id : identifier;
+	version : label;
+	purpose : text;
+	description : OPTIONAL text;
+END_ENTITY;
+
+
+ENTITY vertex
+	SUBTYPE OF (topological_representation_item);
+END_ENTITY;
+
+
+ENTITY vertex_loop
+	SUBTYPE OF (loop);
+	loop_vertex : vertex;
+END_ENTITY;
+
+
+ENTITY vertex_point
+	SUBTYPE OF (vertex, geometric_representation_item);
+	vertex_geometry : point;
+END_ENTITY;
+
+
+ENTITY vertex_shell
+	SUBTYPE OF (topological_representation_item);
+	vertex_shell_extent : vertex_loop;
+END_ENTITY;
+
+
+ENTITY view_volume
+	SUBTYPE OF (founded_item);
+	projection_type : central_or_parallel;
+	projection_point : cartesian_point;
+	view_plane_distance : length_measure;
+	front_plane_distance : length_measure;
+	front_plane_clipping : BOOLEAN;
+	back_plane_distance : length_measure;
+	back_plane_clipping : BOOLEAN;
+	view_volume_sides_clipping : BOOLEAN;
+	view_window : planar_box;
+END_ENTITY;
+
+
+ENTITY visual_appearance_representation
+	SUBTYPE OF (representation);
+WHERE
+	WR1 : ( {3<= SIZEOF ( SELF.items ) <=9} ) AND ( SIZEOF ( QUERY (
+        i <* items | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND (
+        i.name IN [ 'colour id' , 'colour name' , 'lustre' , 'pattern' , 'transparency', 'orientation'] ) ) 
+        ) + SIZEOF ( QUERY ( i <* items | ( SIZEOF (
+        ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'MEASURE_REPRESENTATION_ITEM' ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'VALUE_RANGE']* TYPEOF ( i ) ) =1 )							
+        AND ( i.name IN ['refraction index' , 'opacity'] ) ) 
+        ) + SIZEOF ( QUERY ( i <* items | ( 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'DOCUMENT_FILE' IN TYPEOF ( i ) ) 
+        AND ( i.name IN [ 'texture map' ] ) )	)
+        = SIZEOF ( SELF.items ) );
+	WR2 : SIZEOF ( QUERY ( i <* SELF.items | i.name = 'colour id' )) =1;
+	WR3 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='lustre' ) )=1;
+	WR4 : SIZEOF ( QUERY ( i <* SELF.items | i.name = 'colour name') ) <=1;
+	WR5 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='pattern' ) )<=1;
+	WR6 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='transparency') ) <=1;
+	WR7 : SIZEOF ( QUERY ( i <* SELF.items | i.name = 'texture map') ) <=1;
+	WR8 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='refraction index' ) )<=1;
+	WR9 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='opacity') ) <=1;
+	WR10 : SIZEOF ( QUERY ( i <* SELF.items | i.name ='orientation') ) <=1;
+	WR11 : ( SIZEOF ( USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) ) =1 ) AND ( SIZEOF ( QUERY ( pdr
+        <* USEDIN ( SELF ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'PROPERTY_DEFINITION_REPRESENTATION.'+
+        'USED_REPRESENTATION' ) | SIZEOF ( QUERY ( gpa <* USEDIN (
+        pdr. definition ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+'GENERAL_PROPERTY_ASSOCIATION.'+
+        'DERIVED_DEFINITION' ) | ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+
+        'GENERAL_PROPERTY' IN TYPEOF ( gpa. base_definition ) ) AND
+        ( gpa. base_definition.name ='surface_condition' ) ) ) =1 )) =1 );
+END_ENTITY;
+
+
+ENTITY volume_measure_with_unit
+	SUBTYPE OF (measure_with_unit);
+WHERE
+	WR1 : 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VOLUME_UNIT' IN TYPEOF(SELF\measure_with_unit.unit_component);
+END_ENTITY;
+
+
+ENTITY volume_unit
+	SUBTYPE OF (derived_unit);
+WHERE
+	WR1 : derive_dimensional_exponents(SELF) = 
+          dimensional_exponents ( 3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );
+END_ENTITY;
+
+
+ENTITY week_of_year_and_day_date
+	SUBTYPE OF (date);
+	week_component : week_in_year_number;
+	day_component : OPTIONAL day_in_week_number;
+END_ENTITY;
+
+
+ENTITY wire_shell
+	SUBTYPE OF (topological_representation_item);
+	wire_shell_extent : SET [1:?] OF loop;
+WHERE
+	WR1 : NOT mixed_loop_type_set(wire_shell_extent);
+END_ENTITY;
+
+
+ENTITY year_month
+	SUBTYPE OF (date);
+	month_component : month_in_year_number;
+END_ENTITY;
+
+
+ENTITY zone_structural_makeup
+	SUPERTYPE OF (ONEOF ((smeared_material_definition AND thickness_laminate_table), (smeared_material_definition AND percentage_laminate_table), thickness_laminate_table, percentage_laminate_table, smeared_material_definition))
+	SUBTYPE OF (laminate_table);
+END_ENTITY;
+
+
+RULE alternative_solution_requires_solution_definition FOR (product_definition_formation);
+    LOCAL
+      solution_versions: SET OF product_definition_formation := [];
+    END_LOCAL;
+    solution_versions :=  QUERY( pdf <* product_definition_formation |
+	  SIZEOF( QUERY( prpc <* USEDIN(pdf.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | 
+      prpc.name = 'alternative solution')) = 1);
+WHERE
+	WR1 : SIZEOF( QUERY( pdf <* solution_versions |
+        SIZEOF( QUERY( pd <* USEDIN(pdf, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION.FORMATION') | 
+        pd.frame_of_reference.name = 'alternative definition')) <> 1))= 0;
+END_RULE;
+
+RULE application_protocol_definition_required FOR (application_context);
+
+WHERE
+	WR1 : SIZEOF( QUERY( ac <* application_context | 
+              (SIZEOF (QUERY (apd <* USEDIN(ac,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLICATION_PROTOCOL_DEFINITION.APPLICATION') | 
+                apd.application_interpreted_model_schema_name = 'ap203_configuration_controlled_3d_design_of_mechanical_parts_and_assemblies' 
+                )) > 0) 
+              )) > 0;
+END_RULE;
+
+RULE breakdown_element_requires_product_definition FOR (product_definition_formation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdf <* product_definition_formation | 
+        ( SIZEOF ( QUERY ( prpc <* USEDIN ( pdf.of_product ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+	    prpc.name =  'functionality' ) ) =  1 ) AND 
+	    ( SIZEOF ( QUERY ( pd <* USEDIN ( pdf ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION.FORMATION') | 
+	    pd.frame_of_reference.name =  'functional definition' ) ) <1 ) ) ) =  0;
+	WR2 : SIZEOF ( QUERY ( pdf <* product_definition_formation | 
+        ( SIZEOF ( QUERY ( prpc <* USEDIN ( pdf.of_product , 
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+        prpc.name =  'conceptual design' ) ) =  1 ) AND 
+        ( SIZEOF (QUERY ( pd <* USEDIN ( pdf , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION.FORMATION' ) | 
+        pd.frame_of_reference.name =  'conceptual definition' ) ) <1) ) ) =  0;
+END_RULE;
+
+RULE compatible_dimension FOR (cartesian_point, direction, representation_context, geometric_representation_context);
+
+WHERE
+	WR1 : SIZEOF(QUERY(x <* cartesian_point| SIZEOF(QUERY
+       (y <* geometric_representation_context | item_in_context(x,y) AND
+       (HIINDEX(x.coordinates) <> y.coordinate_space_dimension))) > 0 )) =0;
+	WR2 : SIZEOF(QUERY(x <* direction | SIZEOF( QUERY
+       (y <* geometric_representation_context | item_in_context(x,y) AND
+       (HIINDEX(x.direction_ratios) <> y.coordinate_space_dimension)))
+       > 0 )) = 0;
+END_RULE;
+
+RULE component_class_for_assembly_select FOR (composite_assembly_sequence_definition, next_assembly_usage_occurrence, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER :=0;
+      dkuhr :  LOGICAL :=TRUE;
+      nnauo :  INTEGER :=0;
+      nprpc :  INTEGER :=0;
+      rp    :  product;
+    END_LOCAL;
+    REPEAT i:= LOINDEX (composite_assembly_sequence_definition) TO
+               HIINDEX (composite_assembly_sequence_definition);
+      nnauo := 0;  
+      REPEAT j:= LOINDEX (next_assembly_usage_occurrence) TO
+                 HIINDEX (next_assembly_usage_occurrence);
+        IF (composite_assembly_sequence_definition[i] = 
+          next_assembly_usage_occurrence[j].relating_product_definition) THEN
+          rp := next_assembly_usage_occurrence[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN ['ply',
+                 'ply laminate', 'filament laminate', 'processed core',
+                 'composite assembly'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nnauo := nnauo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nnauo = 0) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE consistent_uncertainty FOR (global_uncertainty_assigned_context, qualified_representation_item, uncertainty_assigned_representation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( guac <* global_uncertainty_assigned_context | 
+    SIZEOF ( QUERY ( u1 <* guac.uncertainty | 
+	SIZEOF ( QUERY ( u2 <* guac.uncertainty | u2.name =  u1.name ) ) >1 ) ) >0 ) ) =  0;
+	WR2 : SIZEOF ( QUERY ( uar <* uncertainty_assigned_representation | 
+	SIZEOF ( QUERY ( u1<* uar.uncertainty | 
+	SIZEOF ( QUERY ( u2 <* uar.uncertainty | u2.name =  u1.name ) ) >1 ) ) >0 ) ) =  0;
+	WR3 : SIZEOF ( QUERY ( qri <* qualified_representation_item |
+     SIZEOF ( QUERY ( u1 <* qri.qualifiers |
+     ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.UNCERTAINTY_QUALIFIER' IN TYPEOF ( u1 ) ) AND 
+	( SIZEOF ( QUERY ( u2 <* qri.qualifiers |
+     ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.UNCERTAINTY_QUALIFIER' IN TYPEOF ( u2 ) ) AND 
+	( u2\uncertainty_qualifier.measure_name =  u1\uncertainty_qualifier.measure_name ) )
+     ) >1 ) ) ) >0 ) ) =  0;
+END_RULE;
+
+RULE constraint_definition_requires_constraint_category FOR (product_definition);
+    LOCAL
+      constraint_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      constraint_definitions :=  QUERY( pd <* product_definition |
+      (pd.frame_of_reference.name = 'design constraint definition'));
+WHERE
+	WR1 : SIZEOF ( QUERY ( pd <* constraint_definitions | 
+	    ( SIZEOF ( QUERY ( prpc <* USEDIN ( pd.formation.of_product ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+	    prpc. name ='requirement' ) ) =0 ) ) ) =0;
+END_RULE;
+
+RULE design_constraint_requires_product_definition FOR (product_definition_formation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdf <* product_definition_formation | (
+        SIZEOF ( QUERY ( prpc <* USEDIN ( pdf.of_product ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS' ) | 
+	    prpc.name =  'requirement' ) ) >0 ) AND 
+        ( SIZEOF ( QUERY ( pd <* USEDIN ( pdf , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION.FORMATION') | 
+	    pd.frame_of_reference.name = 'design constraint definition' ) ) <1 ) ) ) =  0;
+END_RULE;
+
+RULE draughting_model_items_constraint FOR (draughting_model);
+
+WHERE
+	WR1 : SIZEOF(QUERY(dm <* draughting_model |
+        NOT(SIZEOF(QUERY(it1 <* dm\representation.items |
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_OCCURRENCE' IN TYPEOF(it1))
+        AND
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DRAUGHTING_ANNOTATION_OCCURRENCE' IN TYPEOF(it1)))
+          )) = 0)
+        )) = 0;
+	WR2 : SIZEOF(QUERY(dm <* draughting_model |
+        NOT(SIZEOF(QUERY(it1 <* dm\representation.items |
+        (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_CALLOUT' IN TYPEOF(it1))
+        AND
+        NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DRAUGHTING_ELEMENTS' IN TYPEOF(it1)))
+          )) = 0)
+        )) = 0;
+END_RULE;
+
+RULE external_version_assignments_are_valid FOR (applied_external_identification_assignment);
+
+WHERE
+	WR1 : SIZEOF(QUERY(aia <* applied_external_identification_assignment | 
+        NOT external_version_assignment_is_valid(aia)))=0;
+END_RULE;
+
+RULE material_for_coating_layer FOR (shape_aspect);
+    LOCAL
+      coating_layers: SET OF shape_aspect := [];
+    END_LOCAL;
+    coating_layers:= QUERY( r <* shape_aspect | 
+	  (r.name = 'coating layer') );
+WHERE
+	WR1 : SIZEOF( QUERY( r <* coating_layers |
+	    SIZEOF(USEDIN(r , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MATERIAL_DESIGNATION.DEFINITIONS'))<>1
+        )) = 0;
+END_RULE;
+
+RULE plib_property_reference_requires_name_scope FOR (externally_defined_general_property);
+    LOCAL
+      known_sourced_properties : SET OF externally_defined_general_property;
+    END_LOCAL;
+      known_sourced_properties := QUERY( edc <* externally_defined_general_property | 
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' IN TYPEOF(edc.source) );
+WHERE
+	WR1 : SIZEOF ( QUERY ( edgp <* known_sourced_properties | 
+        ( SIZEOF ( QUERY ( edir <* USEDIN ( edgp, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EXTERNALLY_DEFINED_ITEM_RELATIONSHIP.RELATING_ITEM' )| 
+        ( edir.name =  'name scope' ) AND 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EXTERNALLY_DEFINED_CLASS' IN  TYPEOF ( edir.related_item ) ) AND 
+        ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' IN TYPEOF ( edir.related_item.source ) ) ) ) <>1 ) ) ) =  0;
+END_RULE;
+
+RULE plib_property_reference_requires_version FOR (externally_defined_general_property);
+	LOCAL
+	  plib_properties : SET OF externally_defined_general_property := [];
+	END_LOCAL;
+	  plib_properties := QUERY ( edgp <* externally_defined_general_property | 
+		( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' IN TYPEOF ( edgp.source ) ) AND
+		( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'KNOWN_SOURCE' + '.NAME' = 'ISO 13584 library' ) );
+WHERE
+	WR1 : SIZEOF( QUERY( edgp <* plib_properties | 
+		(SIZEOF( QUERY( edir <* USEDIN(edgp, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT.ITEMS') | 
+		(edir.role.name = 'version') )) <> 1) )) = 0;
+END_RULE;
+
+RULE ply_reference FOR (ply_laminate_sequence_definition, next_assembly_usage_occurrence, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER;
+      dkuhr :  LOGICAL := TRUE;
+      nnauo :  INTEGER;
+      nprpc :  INTEGER := 0;
+      rp    :  product;
+    END_LOCAL;
+    REPEAT i:= LOINDEX (ply_laminate_sequence_definition) TO
+               HIINDEX (ply_laminate_sequence_definition);
+      nnauo := 0;  
+      REPEAT j:= LOINDEX (next_assembly_usage_occurrence) TO 
+                 HIINDEX (next_assembly_usage_occurrence);
+        IF (ply_laminate_sequence_definition[i] = 
+          next_assembly_usage_occurrence[j].relating_product_definition) THEN
+          rp := next_assembly_usage_occurrence[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((product_related_product_category[k].name = 'ply') AND
+                (rp IN product_related_product_category[k].products)) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nnauo := nnauo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nnauo = 0) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE ply_stock_material_select FOR (product_related_product_category, make_from_usage_option);
+  LOCAL
+    i,j,k,kp :  INTEGER;
+    dkuhr    :  LOGICAL;
+    nmfuo    :  INTEGER;
+    nprpc    :  INTEGER := 0;
+    rp       :  product;
+  END_LOCAL;
+
+  dkuhr := TRUE;
+  REPEAT kp:= LOINDEX (product_related_product_category) TO
+              HIINDEX (product_related_product_category);
+ 
+    IF (product_related_product_category[kp].name = 'ply') THEN
+    REPEAT i:= LOINDEX (product_related_product_category[kp].products) TO
+               HIINDEX (product_related_product_category[kp].products);
+
+      nmfuo := 0;  
+      REPEAT j:= LOINDEX (make_from_usage_option) TO 
+                 HIINDEX (make_from_usage_option);
+
+          rp := make_from_usage_option[j].related_product_definition.
+                formation.of_product;
+
+        IF (product_related_product_category[kp].products[i] = rp) THEN
+
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN 
+                 ['isotropic material', 'filament assembly', 
+                  'discontinuous fiber assembly'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+
+          END_REPEAT;
+
+          IF (nprpc = 1) THEN
+            nmfuo := nmfuo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+
+        END_IF;
+
+      END_REPEAT;
+
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nmfuo <> 1) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+
+    END_REPEAT;
+    END_IF;
+
+  END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE product_concept_feature_requires_category FOR (product_concept_feature);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pcf <* product_concept_feature |
+(SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE',
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE'] * TYPEOF(pcf)) = 0) AND 
+(SIZEOF ( QUERY ( aga <* USEDIN ( pcf , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'APPLIED_GROUP_ASSIGNMENT.' + 'ITEMS' ) | 
+( aga.role.name = 'specification category member' ) AND 
+('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_CONCEPT_FEATURE_CATEGORY' IN TYPEOF ( aga.assigned_group )))) <>1 ) ) ) = 0;
+END_RULE;
+
+RULE product_definition_replacement_requires_effectivity_assignment FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF( QUERY( pdr <* product_definition_relationship | 
+        (pdr.name = 'definition replacement') AND 
+        (SIZEOF( USEDIN(pdr,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.APPLIED_EFFECTIVITY_ASSIGNMENT.ITEMS') ) = 0) ))
+        = 0;
+END_RULE;
+
+RULE restrict_alternative_definition FOR (product_definition);
+    LOCAL
+      solution_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      solution_definitions :=  QUERY( pd <* product_definition |
+	 (pd.frame_of_reference.name = 'alternative definition'));
+WHERE
+	WR1 : SIZEOF ( QUERY ( pd <* solution_definitions | 
+	    ( SIZEOF ( QUERY ( pdr <* USEDIN ( pd ,
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION' ) | 
+	    pdr.name = 'solution alternative definition' ) ) <>1 ) ) ) = 0;
+	WR2 : SIZEOF ( QUERY ( pd <* solution_definitions | 
+	    NOT ( pd.name IN ['technical' , 'supplier' , 'technical supplier' , ''] ) ) ) = 0;
+	WR3 : SIZEOF ( QUERY ( pd <* solution_definitions | 
+	    ( pd.name IN ['supplier' , 'technical supplier'] ) AND (
+	    SIZEOF ( QUERY ( aoa <* USEDIN ( pd.formation ,
+	    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.APPLIED_ORGANIZATION_ASSIGNMENT.ITEMS' ) | 
+	    aoa.role.name = 'supplier' )) <>1 ) )) = 0;
+END_RULE;
+
+RULE restrict_assembly_category FOR (product_definition);
+    LOCAL
+      assembly_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      assembly_definitions :=  QUERY( pd <* product_definition | 
+        SIZEOF( QUERY( pdca <* USEDIN( pd, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
+        pdca.frame_of_reference.name= 'assembly definition')) > 0 );
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* assembly_definitions | 
+          NOT ('assembly' IN categories_of_product(pd.formation.of_product)) ))= 0;
+END_RULE;
+
+RULE restrict_centre_of_mass_representation FOR (representation);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( r <* representation | 
+	( r.name ='centre of mass' ) AND 
+	( ( SIZEOF ( r.items ) <>1 ) OR 
+	(SIZEOF ( QUERY ( i <* r.items | 
+	( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'POINT' IN TYPEOF ( i ) ) AND 
+	( i.name = 'centre point' ) )) <>1 ) ) ) ) 
+	=0;
+END_RULE;
+
+RULE restrict_classification_assignments FOR (applied_classification_assignment);
+
+WHERE
+	WR1 : SIZEOF(QUERY(aia <* applied_classification_assignment | 
+		NOT class_assignment_is_valid(aia)))=0;
+END_RULE;
+
+RULE restrict_collection_category FOR (product_definition);
+    LOCAL
+      collection_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      collection_definitions :=  QUERY( pd <* product_definition | 
+        SIZEOF( QUERY( pdca <* USEDIN( pd, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') |
+        pdca.frame_of_reference.name= 'collection definition')) > 0 );
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* collection_definitions | 
+	    NOT ('collection' IN categories_of_product(pd.formation.of_product)) ))= 0;
+END_RULE;
+
+RULE restrict_concept_feature_operator FOR (concept_feature_operator);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( cfo <* concept_feature_operator | NOT
+		( cfo.name IN ['and' , 'or' , 'oneof' , 'not' , 'implication'] ) ) ) = 0;
+	WR2 : SIZEOF ( QUERY ( cfo <* concept_feature_operator | (cfo.name = 'implication' ) AND
+	 ( SIZEOF ( QUERY (cfrwc <* USEDIN ( cfo , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION.' +
+	'CONDITIONAL_OPERATOR' ) | 
+		SIZEOF ( QUERY ( ccf <* USEDIN( cfrwc , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONDITIONAL_CONCEPT_FEATURE.CONDITION' ) | 
+		NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'INCLUSION_PRODUCT_CONCEPT_FEATURE' IN TYPEOF ( ccf )))) >0 )) >0 ))) = 0;
+	WR3 : SIZEOF( QUERY (cfo <* concept_feature_operator | (cfo.name = 'not')
+	AND (SIZEOF(QUERY(cfrwc <* USEDIN(cfo, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONCEPT_FEATURE_RELATIONSHIP_WITH_CONDITION.CONDITIONAL_OPERATOR') | 
+		cfrwc.related_product_concept_feature :<>: cfrwc.relating_product_concept_feature)) >0 ))) = 0;
+END_RULE;
+
+RULE restrict_configuration_design_for_class_breakdown_association FOR (configuration_design);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( cd <* configuration_design | 
+	    ( cd.name ='functionality' ) AND 
+        ( NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF ( cd. design ) ) OR 
+        ( cd.design\product_definition.frame_of_reference.name<> 'functional definition' ) ) 
+        ) ) =0;
+	WR2 : SIZEOF ( QUERY ( cd <* configuration_design | 
+        ( cd.name='realization' ) AND 
+        ( NOT ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF ( cd.design ) ) OR 
+        ( cd.design\product_definition.frame_of_reference.name<> 'conceptual definition' ) ) 
+        ) ) =0;
+	WR3 : SIZEOF ( QUERY ( cd <* configuration_design | 
+        ( cd.name IN ['functionality' , 'realization'] ) AND 
+        ( NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CLASS' IN TYPEOF ( cd.configuration.item_concept ) ) ) 
+        ) ) =0;
+END_RULE;
+
+RULE restrict_configuration_design_for_design_constraint FOR (configuration_design);
+
+WHERE
+	WR1 : SIZEOF ( QUERY (cd <* configuration_design | 
+	    (cd.name = 'design constraint usage') AND 
+        (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION' IN TYPEOF ( cd.design ) ) OR 
+        (cd.design\product_definition.frame_of_reference.name <> 'design constraint definition')))) = 0;
+END_RULE;
+
+RULE restrict_group_relationship_for_classification_hierarchy FOR (group_relationship);
+
+WHERE
+	WR1 : SIZEOF( QUERY( gr <* group_relationship | 
+  (gr\group_relationship.name = 'class hierarchy') AND 
+  (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLASS' IN TYPEOF(gr\group_relationship.related_group)) OR 
+  NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLASS' IN TYPEOF(gr\group_relationship.relating_group))) )) = 0;
+END_RULE;
+
+RULE restrict_group_relationship_for_specification_category FOR (group_relationship);
+
+WHERE
+	WR1 : SIZEOF( QUERY( gr <* group_relationship | 
+  (gr.name = 'specification category hierarchy') AND 
+  (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CONCEPT_FEATURE_CATEGORY' IN TYPEOF(gr.related_group)) 
+  OR NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_CONCEPT_FEATURE_CATEGORY' IN TYPEOF(gr.relating_group))) )) = 0;
+END_RULE;
+
+RULE restrict_language_assignment_per_attribute FOR (attribute_language_assignment);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( ala1 <* attribute_language_assignment |
+	SIZEOF(QUERY( it <* ala1.items |
+	   SIZEOF ( QUERY ( ala2 <* USEDIN ( it ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATTRIBUTE_LANGUAGE_ASSIGNMENT.ITEMS' ) | 
+		( ala1\attribute_classification_assignment.attribute_name = ala2\attribute_classification_assignment.attribute_name ) AND 
+		( ala1\attribute_classification_assignment.assigned_class :=: ala2\attribute_classification_assignment.assigned_class )
+		 )) >1 
+	   )) >0 
+	)) =0;
+END_RULE;
+
+RULE restrict_part_occurrence FOR (product_definition);
+    LOCAL
+      part_occurrences: SET OF product_definition := QUERY(pd <* product_definition | 
+	    ( pd.frame_of_reference.name = 'part occurrence' ));
+    END_LOCAL;
+WHERE
+	WR1 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+	    ( NOT( pd.name IN 
+        ['single instance' , 'selected instance' ,'quantified instance' , 'specified instance' ] ) ) ) ) = 0;
+	WR2 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+ 	    (SIZEOF ( QUERY ( pdr <* USEDIN ( pd ,
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION' ) | 
+	    pdr.name = 'definition usage' ) ) <>1 ) AND 
+        ( SIZEOF ( QUERY ( cd <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CONFIGURATION_DESIGN.DESIGN' ) | 
+        ( cd.name = 'occurrence usage definition' ) AND 
+        ( NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_IDENTIFICATION' IN TYPEOF( cd.configuration ) ) ) ) ) <>1 ) ) ) = 0;
+	WR3 : SIZEOF ( QUERY ( pd <* part_occurrences |  
+        (SIZEOF ( QUERY ( cd <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.'+ 'PRODUCT_DEFINITION_RELATIONSHIP.RELATED_PRODUCT_DEFINITION' ) |
+        ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PRODUCT_DEFINITION_USAGE' IN TYPEOF ( cd ) ) ) ) = 0 )AND
+        ( SIZEOF ( USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE' ) ) = 0 ) ) ) = 0;
+	WR4 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+        ( pd.name = 'selected instance' ) AND 
+        NOT valid_selected_instance_representation(pd) ))=0;
+	WR5 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+        ( pd.name = 'quantified instance' ) AND 
+        ( SIZEOF ( QUERY (ppd <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PROPERTY_DEFINITION.DEFINITION' ) |
+        ( ppd.name ='occurrence quantity' ) AND 
+        ( SIZEOF ( QUERY ( pdr <*USEDIN ( ppd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PROPERTY_DEFINITION_REPRESENTATION.DEFINITION' ) | (
+        pdr.used_representation.name = 'quantity' ) AND 
+        (SIZEOF ( pdr.used_representation.items ) = 1 ) AND 
+        (SIZEOF ( QUERY ( i <* pdr.used_representation.items | 
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'MEASURE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND
+        ( i.name = 'quantity measure' ) ) ) = 1)))= 1 )))= 0 )))= 0;
+	WR6 : SIZEOF ( QUERY ( pd <* part_occurrences | 
+        ( pd.name = 'specified instance' ) AND 
+        ( SIZEOF ( QUERY (
+        pdor <* USEDIN ( pd , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'PRODUCT_DEFINITION_OCCURRENCE_RELATIONSHIP.OCCURRENCE' ) | 
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'SPECIFIED_HIGHER_USAGE_OCCURRENCE' IN TYPEOF ( pdor.occurrence_usage ) ) ) = 0 ) ) ) = 0;
+END_RULE;
+
+RULE restrict_part_occurrence_category FOR (product_definition);
+    LOCAL
+      part_occurrences: SET OF product_definition := QUERY( pd <* product_definition |(
+        pd.frame_of_reference.name = 'part occurrence'));
+    END_LOCAL;
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* part_occurrences | 
+        (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | 
+        prpc.name IN ['part','raw material','tool'] )) = 0 ) )) = 0;
+END_RULE;
+
+RULE restrict_product_definitions_for_base_element FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+       ( pdr. name = 'solution alternative definition' ) AND 
+       ( NOT( pdr. relating_product_definition.frame_of_reference.name
+        IN [ 'alternative definition' , 'functional definition' , 'conceptual definition' ] ) OR 
+       ( pdr.related_product_definition.frame_of_reference.name<>'alternative definition' ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_collection FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+       ( pdr. name = 'collection membership' ) AND 
+       ( ( pdr.relating_product_definition.frame_of_reference.name<>'part definition' ) OR 
+       ( pdr.related_product_definition.frame_of_reference.name<>'part occurrence' ) OR 
+       ( SIZEOF ( QUERY ( pdca <* USEDIN (pdr.relating_product_definition ,
+       'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_DEFINITION_CONTEXT_ASSOCIATION.DEFINITION') | 
+       ( pdca.role.name = 'part definition type' ) AND 
+       ( pdca.frame_of_reference.name = 'collection definition' ) )) =0 ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_definition_usage FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+        ( pdr.name = 'definition usage' ) AND 
+        ( ( pdr.relating_product_definition.frame_of_reference.name<> 'part definition' ) OR 
+        ( pdr.related_product_definition.frame_of_reference.name<>'part occurrence' )))) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_design_constraint_association FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+        ( pdr. name = 'design constraint association' ) AND 
+	    ( (pdr. relating_product_definition.frame_of_reference.name<>'design constraint definition' ) OR 
+	    NOT ( pdr.related_product_definition.frame_of_reference.name IN 
+	    ['alternative definition' , 'functional definition' ,'conceptual definition' ] ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_product_definitions_for_part_definition_relationship FOR (product_definition_relationship);
+
+WHERE
+	WR1 : SIZEOF ( QUERY ( pdr <* product_definition_relationship |
+        ( pdr.name IN [ 'geometrical relationship' , 'definition replacement' ] ) AND 
+	    ( ( pdr.relating_product_definition.frame_of_reference.name <>'part definition' ) OR 
+        ( pdr.related_product_definition.frame_of_reference.name <>'part definition' ) ) ) ) =0;
+END_RULE;
+
+RULE restrict_representation_for_surface_condition FOR (property_definition_representation);
+
+WHERE
+	WR1 : SIZEOF(QUERY(pdr <* property_definition_representation | 
+        NOT surface_condition_correlation(pdr.definition, pdr.used_representation) ))=0;
+END_RULE;
+
+RULE restrict_treatment_result FOR (representation);
+    LOCAL
+      treatment_results: SET OF representation := [];
+    END_LOCAL;
+    treatment_results:= QUERY( r <* representation | 
+	  (r.name = 'treatment result') );
+WHERE
+	WR1 : (SIZEOF( QUERY( r <* treatment_results | (SIZEOF(r.items) > 2) )) = 0) AND
+        (SIZEOF( QUERY( r <* treatment_results |
+        (SIZEOF( QUERY( i <* r.items | 
+         NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) )) > 0) )) = 0);
+	WR2 : SIZEOF( QUERY( r <* treatment_results | 
+        (SIZEOF( QUERY( i <* r.items | i.name = 'result' )) = 0) )) = 0;
+	WR3 : SIZEOF( QUERY( r <* treatment_results | 
+        (SIZEOF( QUERY( i <* r.items | i.name = 'purpose' )) > 1) )) = 0;
+END_RULE;
+
+RULE selected_instance_usage_requires_representation FOR (assembly_component_usage);
+    LOCAL
+      selected_instance_usages: SET OF assembly_component_usage := QUERY( acr <* assembly_component_usage|
+        (acr.name = 'selected instance usage'));
+    END_LOCAL;
+WHERE
+	WR1 : SIZEOF ( QUERY ( acr <* selected_instance_usages | 
+        NOT valid_selected_instance_representation(acr) ))=0;
+END_RULE;
+
+RULE solution_definition_requires_solution_category FOR (product_definition);
+    LOCAL
+      solution_definitions: SET OF product_definition := [];
+    END_LOCAL;
+      solution_definitions :=  QUERY( pd <* product_definition |
+        (pd.frame_of_reference.name = 'alternative definition'));
+WHERE
+	WR1 : SIZEOF( QUERY( pd <* solution_definitions | 
+        (SIZEOF( QUERY( prpc <* USEDIN(pd.formation.of_product, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF' + '.PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS') | 
+	     prpc.name = 'alternative solution')) = 0 ) )) = 0;
+END_RULE;
+
+RULE stock_material_reference FOR (percentage_ply_definition, make_from_usage_option, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER;
+      dkuhr :  LOGICAL;
+      nmfuo :  INTEGER;
+      nprpc :  INTEGER;
+      rp     :  product;
+    END_LOCAL;
+    dkuhr := TRUE;
+    REPEAT i:= LOINDEX (percentage_ply_definition) TO
+               HIINDEX (percentage_ply_definition);
+      nmfuo := 0;  
+      REPEAT j:= LOINDEX (make_from_usage_option) TO 
+                 HIINDEX (make_from_usage_option);
+        IF (percentage_ply_definition[i] = 
+          make_from_usage_option[j].relating_product_definition) THEN
+          rp := make_from_usage_option[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN 
+                ['anisotropic material', 'isotropic material', 'stock core',
+                 'filament assembly', 'discontinuous fiber assembly'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nmfuo := nmfuo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE; 
+      END_IF;
+      IF(nmfuo = 0) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE styled_curve FOR (styled_item);
+
+WHERE
+	WR1 : SIZEOF( QUERY( si <* styled_item | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE' IN TYPEOF (si.item)) AND (SIZEOF (QUERY (psa <* si.styles | (SIZEOF (QUERY (cs <* psa.styles | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_STYLE' IN TYPEOF (cs)) )) > 0) )) <> 1) )) = 0;
+END_RULE;
+
+RULE subtype_exclusiveness_geometric_tolerance FOR (geometric_tolerance);
+
+WHERE
+	WR1 : SIZEOF(QUERY (gt <* geometric_tolerance | NOT (type_check_function(gt, ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCULAR_RUNOUT_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COAXIALITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONCENTRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CYLINDRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FLATNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARALLELISM_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERPENDICULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITION_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ROUNDNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRAIGHTNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMMETRY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOTAL_RUNOUT_TOLERANCE'] , 3)))) = 0;
+END_RULE;
+
+RULE subtype_exclusiveness_representation_item FOR (representation_item);
+
+WHERE
+	WR1 : SIZEOF(QUERY (cri <* representation_item | 
+      NOT (type_check_function(cri,['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+                                    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_REPRESENTATION_ITEM',
+                                    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOUND_REPRESENTATION_ITEM'] , 3)))) = 0;
+END_RULE;
+
+RULE subtype_mandatory_geometric_tolerance FOR (geometric_tolerance);
+
+WHERE
+	WR1 : SIZEOF(QUERY (gt <* geometric_tolerance | NOT (type_check_function(gt, ['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANGULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCULAR_RUNOUT_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COAXIALITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONCENTRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CYLINDRICITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FLATNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARALLELISM_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PERPENDICULARITY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITION_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ROUNDNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRAIGHTNESS_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_PROFILE_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SYMMETRY_TOLERANCE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOTAL_RUNOUT_TOLERANCE'] , 0)))) = 0;
+END_RULE;
+
+RULE text_font_usage FOR (externally_defined_text_font, pre_defined_text_font);
+
+WHERE
+	WR1 : SIZEOF (QUERY (pdtf <* pre_defined_text_font | SIZEOF (USEDIN (pdtf, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL.FONT')) = 0 )) = 0;
+	WR2 : SIZEOF (QUERY (edtf <* externally_defined_text_font | SIZEOF (USEDIN (edtf, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TEXT_LITERAL.FONT')) = 0 )) = 0;
+END_RULE;
+
+RULE thickness_laminate_table_component_select FOR (thickness_laminate_definition, next_assembly_usage_occurrence, product_related_product_category);
+    LOCAL
+      i,j,k :  INTEGER;
+      dkuhr :  LOGICAL;
+      nnauo :  INTEGER;
+      nprpc :  INTEGER;
+      rp    :  product;
+    END_LOCAL;
+    dkuhr := TRUE;
+    REPEAT i:= LOINDEX (thickness_laminate_definition) TO
+               HIINDEX (thickness_laminate_definition);
+      nnauo := 0;  
+      REPEAT j:= LOINDEX (next_assembly_usage_occurrence) TO 
+                 HIINDEX (next_assembly_usage_occurrence);
+        IF (thickness_laminate_definition[i] = 
+          next_assembly_usage_occurrence[j].relating_product_definition) THEN
+          rp := next_assembly_usage_occurrence[j].related_product_definition.
+                formation.of_product;
+          nprpc := 0;
+          REPEAT k:= LOINDEX (product_related_product_category) TO
+                     HIINDEX (product_related_product_category);
+            IF ((rp IN product_related_product_category[k].products) AND
+                (product_related_product_category[k].name IN 
+                 ['ply', 'filament laminate', 'processed core'])) THEN
+                nprpc := nprpc + 1;
+            END_IF;
+          END_REPEAT;
+          IF (nprpc = 1) THEN
+            nnauo := nnauo + 1;
+          ELSE
+            dkuhr := FALSE;
+            ESCAPE;
+          END_IF;
+        END_IF;
+      END_REPEAT;
+      IF (dkuhr = FALSE) THEN
+        ESCAPE;
+      END_IF;
+      IF (nnauo <> 1) THEN
+        dkuhr := FALSE;
+        ESCAPE;
+      END_IF;
+    END_REPEAT;
+WHERE
+	WR1 : dkuhr;
+END_RULE;
+
+RULE validate_dependently_instantiable_entity_data_types FOR (action_method_role, annotation_text, attribute_value_role, auxiliary_geometric_representation_item, binary_numeric_expression, boolean_expression, bounded_curve, bounded_surface, cartesian_transformation_operator, comparison_expression, concept_feature_relationship, concept_feature_relationship_with_condition, connected_edge_set, document_usage_constraint, edge_blended_solid, effectivity_context_role, event_occurrence_role, explicit_procedural_representation_item_relationship, expression, founded_item, generic_expression, generic_variable, indirectly_selected_elements, interval_expression, literal_number, local_time, loop, modified_solid_with_placed_configuration, multiple_arity_boolean_expression, multiple_arity_generic_expression, multiple_arity_numeric_expression, numeric_expression, one_direction_repeat_factor, oriented_open_shell, oriented_path, positioned_sketch, procedural_representation, procedural_representation_sequence, product_definition_context_role, product_definition_effectivity, runout_zone_orientation, simple_boolean_expression, simple_generic_expression, simple_numeric_expression, solid_with_depression, solid_with_hole, solid_with_pocket, solid_with_protrusion, solid_with_shape_element_pattern, solid_with_slot, swept_area_solid, symbol_target, tolerance_zone_form, two_direction_repeat_factor, unary_generic_expression, unary_numeric_expression, user_selected_elements, variational_representation_item, view_volume);
+LOCAL
+  number_of_input_instances : INTEGER;
+  previous_in_chain : LIST OF GENERIC := [];
+  set_of_input_types : SET OF STRING := [];
+  all_instances : SET OF GENERIC := [];
+END_LOCAL;
+
+  all_instances := all_instances + action_method_role + annotation_text + attribute_value_role + auxiliary_geometric_representation_item + binary_numeric_expression + boolean_expression + bounded_curve + bounded_surface + cartesian_transformation_operator + comparison_expression + concept_feature_relationship + concept_feature_relationship_with_condition + connected_edge_set + document_usage_constraint + edge_blended_solid + effectivity_context_role + event_occurrence_role + explicit_procedural_representation_item_relationship + expression + founded_item + generic_expression + generic_variable + indirectly_selected_elements + interval_expression + literal_number + local_time + loop + modified_solid_with_placed_configuration + multiple_arity_boolean_expression + multiple_arity_generic_expression + multiple_arity_numeric_expression + numeric_expression + one_direction_repeat_factor + oriented_open_shell + oriented_path + positioned_sketch + procedural_representation + procedural_representation_sequence + product_definition_context_role + product_definition_effectivity + runout_zone_orientation + simple_boolean_expression + simple_generic_expression + simple_numeric_expression + solid_with_depression + solid_with_hole + solid_with_pocket + solid_with_protrusion + solid_with_shape_element_pattern + solid_with_slot + swept_area_solid + symbol_target + tolerance_zone_form + two_direction_repeat_factor + unary_generic_expression + unary_numeric_expression + user_selected_elements + variational_representation_item + view_volume;--<make a union of all implicit populations of the FOR-clause>
+number_of_input_instances := SIZEOF(all_instances);
+(* Collect all type strings of all FOR instances into one set. *)
+REPEAT i:=1 TO number_of_input_instances;
+  set_of_input_types := set_of_input_types + TYPEOF(all_instances[i]);
+END_REPEAT;
+WHERE
+	WR1 : dependently_instantiated(all_instances, set_of_input_types,
+                                previous_in_chain);
+END_RULE;
+
+FUNCTION acyclic
+	(arg1: generic_expression; arg2: SET [0:?] OF generic_expression) : BOOLEAN;
+LOCAL
+	result: BOOLEAN := TRUE;
+END_LOCAL;
+
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_GENERIC_EXPRESSION'
+	IN TYPEOF (arg1)) 
+THEN
+	RETURN (TRUE);
+END_IF;
+
+IF arg1 IN arg2 
+THEN 
+	RETURN (FALSE);
+END_IF;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.UNARY_GENERIC_EXPRESSION' 
+	IN TYPEOF (arg1) 
+THEN 
+	RETURN 
+	(acyclic(arg1\unary_generic_expression.operand,arg2+[arg1]));
+END_IF;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BINARY_GENERIC_EXPRESSION' 
+	IN TYPEOF (arg1) 
+THEN 
+	RETURN 
+	(acyclic(arg1\binary_generic_expression.operands[1],arg2+[arg1])
+	AND
+	acyclic(arg1\binary_generic_expression.operands[2],arg2+[arg1]));
+END_IF;
+
+IF 
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULTIPLE_ARITY_GENERIC_EXPRESSION' 
+	IN TYPEOF (arg1) 
+THEN 
+	result := TRUE;
+	REPEAT i := 1 TO 
+			SIZEOF (arg1\multiple_arity_generic_expression.operands);
+		result := result AND
+		acyclic(arg1\multiple_arity_generic_expression.operands[i], arg2+[arg1]);
+	END_REPEAT;
+
+	RETURN (result);
+END_IF;
+	RETURN (result);
+END_FUNCTION;
+
+FUNCTION acyclic_composite_text
+	(start_composite: composite_text; child_text: SET [1:?] OF text_or_character) : LOGICAL;
+    LOCAL
+      i : INTEGER;
+      local_composite_text : SET [0:?] OF composite_text;
+      local_annotation_text : SET [0:?] OF annotation_text;
+      local_children : SET [0:?] OF text_or_character;
+    END_LOCAL;
+
+    local_composite_text := QUERY (child <* child_text |
+                          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'
+                           IN TYPEOF (child)));
+
+    IF (SIZEOF (local_composite_text) > 0) 
+      THEN
+        REPEAT i := 1 TO HIINDEX (local_composite_text);
+          IF (start_composite :=: local_composite_text[i]) 
+            THEN
+              RETURN (FALSE);
+          END_IF;
+        END_REPEAT;
+    END_IF;
+
+    local_children := child_text;
+
+    IF (SIZEOF (local_composite_text)) > 0 THEN
+      REPEAT i := 1 TO HIINDEX (local_composite_text);
+        local_children := local_children +
+                          local_composite_text[i].collected_text;
+      END_REPEAT;
+    END_IF;
+
+    local_annotation_text := QUERY (child <* child_text |
+                            ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT'
+                             IN TYPEOF (child)));
+
+    IF (SIZEOF (local_annotation_text) > 0) THEN
+      REPEAT i := 1 TO HIINDEX (local_annotation_text);
+        local_children := local_children +
+        QUERY (item <* local_annotation_text[i]\mapped_item.
+                       mapping_source.mapped_representation.items |
+          SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ANNOTATION_TEXT',
+                  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_TEXT'] *
+                  TYPEOF(item)) > 0);
+      END_REPEAT;
+    END_IF;
+
+    IF (local_children :<>: child_text) THEN
+      RETURN (acyclic_composite_text (start_composite, local_children));
+    ELSE
+      RETURN (TRUE);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_curve_replica
+	(rep: curve_replica; parent: curve) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type curve_replica *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same curve_replica, otherwise,
+   call function again with the parents own parent_curve.     *)
+    ELSE
+    RETURN(acyclic_curve_replica(rep,
+               parent\curve_replica.parent_curve));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_mapped_item_usage
+	(rep: representation) : BOOLEAN;
+  LOCAL
+    items : SET OF representation_item;
+  END_LOCAL;
+
+  items := QUERY (item <* rep.items |
+           'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM' IN TYPEOF (item));
+  IF SIZEOF (items) = 0
+  THEN 
+    RETURN (FALSE);
+  ELSE 
+    REPEAT i := 1 TO HIINDEX (items);
+      IF items[i]\mapped_item.mapping_source.mapped_representation :=: rep
+      THEN 
+        RETURN (TRUE);
+      ELSE 
+        RETURN (acyclic_mapped_item_usage(items[i]\
+                  mapped_item.mapping_source.mapped_representation));
+      END_IF;
+    END_REPEAT;
+  RETURN (FALSE);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_mapped_representation
+	(mi: mapped_item) : BOOLEAN;
+    LOCAL
+      rms : SET OF representation_map;
+      mis : SET OF mapped_item;
+      rs1, rs2 : SET OF representation;
+    END_LOCAL;
+ 
+    rs1 := using_representations(mi);
+    rs2 := [];
+    -- loop as long as there are elements in rs1
+    REPEAT WHILE SIZEOF(rs1) > 0; 
+      REPEAT i := 1 TO HIINDEX(rs1);
+        -- Determine the set of representation_map that reference the parent_set
+        rms := bag_to_set(USEDIN(rs1[i], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_MAP.MAPPED_REPRESENTATION'));
+        IF SIZEOF(rms) > 0 THEN
+          REPEAT j := 1 TO HIINDEX(rms);
+            mis := bag_to_set(USEDIN(rms[i], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAPPED_ITEM.MAPPING_SOURCE'));
+            IF SIZEOF(mis) > 0 THEN
+              REPEAT j := 1 TO HIINDEX(mis);
+                -- check mis members for instance equal with mi. If so then there is a cycle
+                IF mis[i] :=: mi THEN
+                  RETURN (FALSE);
+                END_IF;
+                rs2 := rs2 + using_representations(mis[i]);
+              END_REPEAT;
+            END_IF;
+          END_REPEAT;
+        END_IF;
+      END_REPEAT;
+      rs1 := rs2;
+      rs2 := [];
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION acyclic_point_replica
+	(rep: point_replica; parent: point) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type point_replica *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same point_replica, otherwise,
+   call function again with the parents own parent_pt.     *)
+    ELSE RETURN(acyclic_point_replica(rep, parent\point_replica.parent_pt));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_product_definition_relationship
+	(relation: product_definition_relationship; relatives: SET [1:?] OF product_definition; specific_relation: STRING) : BOOLEAN;
+    LOCAL
+      x : SET OF product_definition_relationship;
+    END_LOCAL;
+
+    IF relation.relating_product_definition IN relatives THEN
+      RETURN (FALSE);
+    END_IF;
+    x := QUERY(pd <* bag_to_set(USEDIN(relation.relating_product_definition, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_DEFINITION_RELATIONSHIP.' + 'RELATED_PRODUCT_DEFINITION')) | specific_relation IN TYPEOF(pd));
+    REPEAT i := 1 TO HIINDEX(x);
+      IF NOT acyclic_product_definition_relationship(x[i], relatives + relation.relating_product_definition, specific_relation) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION acyclic_representation_relationship
+	(relation: representation_relationship; relatives: SET [1:?] OF representation; specific_relation: STRING) : BOOLEAN;
+    LOCAL
+      x : SET OF representation_relationship;
+    END_LOCAL;
+
+    IF relation.rep_1 IN relatives THEN
+      RETURN (FALSE);
+    END_IF;
+    x := QUERY(r <* bag_to_set(USEDIN(relation.rep_1, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'REPRESENTATION_RELATIONSHIP.' + 'REP_2')) | specific_relation IN TYPEOF(r));
+    REPEAT i := 1 TO HIINDEX(x);
+      IF NOT acyclic_representation_relationship(x[i], relatives + relation.rep_1, specific_relation) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION acyclic_solid_replica
+	(rep: solid_replica; parent: solid_model) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type solid_replica. *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same solid_replica, otherwise,
+   call function again with the parents own parent_solid.     *)
+    ELSE RETURN(acyclic_solid_replica(rep,
+                      parent\solid_replica.parent_solid));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION acyclic_surface_replica
+	(rep: surface_replica; parent: surface) : BOOLEAN;
+IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA') IN TYPEOF(parent)) THEN
+      RETURN (TRUE);
+   END_IF;
+ (* Return TRUE if the parent is not of type surface_replica *)
+   IF (parent :=: rep) THEN
+      RETURN (FALSE);
+  (* Return FALSE if the parent is the same surface_replica, otherwise,
+   call function again with the parents own parent_surface.     *)
+    ELSE RETURN(acyclic_surface_replica(rep,
+                   parent\surface_replica.parent_surface));
+    END_IF;
+END_FUNCTION;
+
+FUNCTION advanced_face_properties
+	(testface: face) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ADVANCED_FACE' IN TYPEOF(testface) THEN
+    RETURN (TRUE);
+END_IF;
+(* if testface is a subface recursively test the parent_face,
+return FALSE for all other types of face *)
+IF  ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBFACE' IN TYPEOF(testface)) THEN
+     RETURN(advanced_face_properties(testface\subface.parent_face));
+   ELSE RETURN (FALSE);
+END_IF;
+END_FUNCTION;
+
+FUNCTION aspect_ratio
+	(p: planar_box) : positive_ratio_measure;
+IF (p.size_in_x > 0.) AND (p.size_in_y > 0.) THEN
+      RETURN (p.size_in_x / p.size_in_y);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION associated_surface
+	(arg: pcurve_or_surface) : surface;
+   LOCAL
+     surf : surface;
+   END_LOCAL;
+   
+   IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(arg) THEN
+     surf := arg\pcurve.basis_surface;
+   ELSE
+     surf := arg;
+   END_IF;
+   RETURN(surf);
+END_FUNCTION;
+
+FUNCTION bag_to_set
+	(the_bag: BAG [0:?] OF GENERIC: intype) : SET [0:?] OF GENERIC: intype;
+    LOCAL
+      the_set : SET OF GENERIC:intype := [];
+    END_LOCAL;
+
+    IF SIZEOF(the_bag) > 0 THEN
+      REPEAT i := 1 TO HIINDEX(the_bag);
+        the_set := the_set + the_bag[i];
+      END_REPEAT;
+    END_IF;
+    RETURN (the_set);
+END_FUNCTION;
+
+FUNCTION base_axis
+	(dim: INTEGER; axis1: direction; axis2: direction; axis3: direction) : LIST [2:3] OF direction;
+  LOCAL
+    u      : LIST [2:3] OF direction;
+    factor : REAL;
+    d1, d2 : direction;
+  END_LOCAL;
+  
+  IF (dim = 3) THEN
+    d1 := NVL(normalise(axis3),  dummy_gri || direction([0.0,0.0,1.0]));
+    d2 := first_proj_axis(d1,axis1);
+    u := [d2, second_proj_axis(d1,d2,axis2), d1];
+  ELSE
+     IF EXISTS(axis1) THEN
+      d1 := normalise(axis1);
+      u := [d1, orthogonal_complement(d1)];
+      IF EXISTS(axis2) THEN
+        factor := dot_product(axis2,u[2]);
+        IF (factor < 0.0) THEN
+          u[2].direction_ratios[1] := -u[2].direction_ratios[1];
+          u[2].direction_ratios[2] := -u[2].direction_ratios[2];
+        END_IF;
+      END_IF;
+    ELSE
+      IF EXISTS(axis2) THEN
+        d1 := normalise(axis2);
+        u := [orthogonal_complement(d1), d1]; 
+        u[1].direction_ratios[1] := -u[1].direction_ratios[1];
+        u[1].direction_ratios[2] := -u[1].direction_ratios[2];
+      ELSE
+        u := [dummy_gri || direction([1.0, 0.0]), dummy_gri ||
+                                                direction([0.0, 1.0])];
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN(u);
+END_FUNCTION;
+
+FUNCTION boolean_choose
+	(b: BOOLEAN; choice1: GENERIC: item; choice2: GENERIC: item) : GENERIC: item;
+IF b THEN
+       RETURN (choice1);
+     ELSE
+       RETURN (choice2);
+     END_IF;
+END_FUNCTION;
+
+FUNCTION build_2axes
+	(ref_direction: direction) : LIST [2:2] OF direction;
+   LOCAL
+     d : direction := NVL(normalise(ref_direction),
+                          dummy_gri || direction([1.0,0.0]));
+   END_LOCAL;
+
+   RETURN([d, orthogonal_complement(d)]);
+END_FUNCTION;
+
+FUNCTION build_axes
+	(axis: direction; ref_direction: direction) : LIST [3:3] OF direction;
+     LOCAL
+       d1, d2 : direction;
+     END_LOCAL;
+    d1 := NVL(normalise(axis), dummy_gri || direction([0.0,0.0,1.0]));
+    d2 := first_proj_axis(d1, ref_direction);
+    RETURN([d2, normalise(cross_product(d1,d2))\vector.orientation, d1]);
+END_FUNCTION;
+
+FUNCTION categories_of_product
+	(obj: product) : SET [0:?] OF STRING;
+LOCAL
+  category_assignments: BAG OF product_category;
+  categories: SET OF STRING:=[];
+END_LOCAL;
+category_assignments := USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PRODUCT_RELATED_PRODUCT_CATEGORY.PRODUCTS');
+REPEAT i := LOINDEX(category_assignments) TO HIINDEX(category_assignments) BY 1;
+  categories := categories + category_assignments[i].name;
+END_REPEAT;
+RETURN(categories);
+END_FUNCTION;
+
+FUNCTION cc_design_person_and_organization_correlation
+	(e: cc_design_person_and_organization_assignment) : BOOLEAN;
+    LOCAL
+      po_role : STRING;
+    END_LOCAL;
+      po_role := e\person_and_organization_assignment.role.name;
+    CASE po_role OF
+      'request_recipient'      : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CHANGE_REQUEST',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'START_REQUEST'] *
+                                 TYPEOF (x)) = 1))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'initiator'              : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CHANGE_REQUEST',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'START_REQUEST',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'START_WORK',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CHANGE'] *
+                                 TYPEOF (x)) = 1))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'creator'                : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION_FORMATION',
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION'] *
+                                 TYPEOF (x)) = 1))
+                                 THEN RETURN (FALSE);
+                               END_IF;
+      'part_supplier'          : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION_FORMATION'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'design_supplier'        : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'PRODUCT_DEFINITION_FORMATION'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'design_owner'           : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'configuration_manager'  : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'CONFIGURATION_ITEM'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'contractor'             : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONTRACT'
+                                 IN TYPEOF (x)))
+                                 THEN RETURN(FALSE);
+                               END_IF;
+      'classification_officer' : IF SIZEOF (e.items) <>
+                                 SIZEOF (QUERY (x <* e.items |
+                                 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +
+                                 'SECURITY_CLASSIFICATION'
+                                 IN TYPEOF (x))) THEN
+                                 RETURN(FALSE);
+                               END_IF;
+    OTHERWISE : RETURN(TRUE);
+  END_CASE;
+  RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION check_continuous_edges
+	(edges: LIST [0:?] OF  UNIQUE edge_curve) : BOOLEAN;
+  LOCAL
+    i           : INTEGER;
+    next_vertex : vertex;
+  END_LOCAL;
+
+  -- first check whether there is only one edge in the list: in this
+  -- case there is no connectivity to be checked.
+
+  IF (SIZEOF(edges) = 1)
+  THEN RETURN(TRUE);
+  END_IF;
+
+  -- otherwise, establish the matching vertices of edges 1 and 2 in 
+  -- the list, and determine the vertex of edge 2 to which edge 3, 
+  -- must be connected, if there are more than two edges in the list.
+
+  IF ((edges[2].edge_start :=: edges[1].edge_end)
+    XOR (edges[2].edge_start :=: edges[1].edge_start))
+  THEN next_vertex := edges[2].edge_end;
+  ELSE 
+    IF ((edges[2].edge_end :=: edges[1].edge_end)
+      XOR (edges[2].edge_end :=: edges[1].edge_start))
+    THEN next_vertex := edges[2].edge_start;
+    ELSE RETURN(FALSE); -- no match between any vertices of edges 1 and 2 
+    END_IF;
+  END_IF;
+
+  -- exit if there are only two edges and they are connected
+
+  IF (SIZEOF(edges) = 2)
+  THEN RETURN(TRUE);
+  END_IF;
+
+  -- otherwise, check that any remaining edges are connected in list order.
+
+  REPEAT i := 3 TO HIINDEX(edges);
+    IF (edges[i].edge_start :=: next_vertex)
+    THEN next_vertex := edges[i].edge_end;
+    ELSE
+      IF (edges[i].edge_end :=: next_vertex)
+      THEN next_vertex := edges[i].edge_start;
+      ELSE RETURN(FALSE); -- no match is found.
+      END_IF;
+    END_IF; 
+  END_REPEAT;
+  RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION check_text_alignment
+	(ct: composite_text) : BOOLEAN;
+  LOCAL
+    a : SET OF text_alignment := [];
+  END_LOCAL;
+
+  -- create a set of all the alignments
+  REPEAT i := 1 TO HIINDEX (ct.collected_text);
+    a := a + [ct.collected_text[i]\text_literal.alignment];
+  END_REPEAT;
+
+  -- if there is more than one element in the set
+  -- then not all alignments were the same
+  RETURN (SIZEOF(a) = 1);
+END_FUNCTION;
+
+FUNCTION check_text_font
+	(ct: composite_text) : BOOLEAN;
+  LOCAL
+    f : SET OF font_select := [];
+  END_LOCAL;
+
+  -- build a set of all the fonts
+  REPEAT i := 1 TO HIINDEX (ct.collected_text);
+    f := f + [ct.collected_text[i]\text_literal.font];
+  END_REPEAT;
+
+  -- if there is more than one element in the set
+  -- then not all fonts were the same
+  RETURN (SIZEOF(f) <= 1);
+END_FUNCTION;
+
+FUNCTION class_assignment_is_valid
+	(aia: applied_classification_assignment) : BOOLEAN;
+LOCAL
+  item: classification_item;
+  role: classification_role;
+END_LOCAL;
+
+role:= aia\classification_assignment.role;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'CLASS_SYSTEM' IN TYPEOF(aia\classification_assignment.assigned_class)) THEN
+  IF(role\classification_role.name <> 'class system membership') THEN
+    RETURN(FALSE);
+  END_IF;
+  REPEAT i:=LOINDEX(aia\applied_classification_assignment.items) TO HIINDEX(aia\applied_classification_assignment.items);
+    item:= aia\applied_classification_assignment.items[i];
+
+    IF (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CLASS_SYSTEM_ITEM'] * TYPEOF(item))=0) THEN
+-- item invalid if item does not belong to the types that may have a class_system
+	RETURN(FALSE);
+    END_IF;
+  END_REPEAT;
+END_IF;
+
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' +'CHARACTERIZED_CLASS' IN TYPEOF(aia\classification_assignment.assigned_class)) THEN
+  IF	NOT(role\classification_role.name IN ['definitional','non-definitional','']) THEN
+    RETURN(FALSE); 
+  END_IF;
+
+
+  REPEAT i:=LOINDEX(aia\applied_classification_assignment.items) TO HIINDEX(aia\applied_classification_assignment.items);
+    item:= aia\applied_classification_assignment.items[i];
+
+    IF (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'CLASSIFIED_ITEM'] * TYPEOF(item))=0) THEN
+-- item invalid if item does not belong to the types that may have a characterized_class
+	RETURN(FALSE);
+    END_IF;
+  END_REPEAT;
+END_IF;
+
+  IF
+   (role\classification_role.name = 'definitional')
+   THEN
+     IF NOT
+      (SIZEOF(QUERY(it <* aia\applied_classification_assignment.items | NOT
+             (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION_FORMATION', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRODUCT_DEFINITION'] * TYPEOF(it)) = 1)
+      )) = 0 )
+      THEN
+      RETURN(FALSE); 
+     END_IF;
+  END_IF;
+
+RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION closed_shell_reversed
+	(a_shell: closed_shell) : oriented_closed_shell;
+  LOCAL
+    the_reverse : oriented_closed_shell;
+  END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_CLOSED_SHELL' IN TYPEOF (a_shell) ) THEN
+      the_reverse := dummy_tri ||
+                    connected_face_set (
+                       a_shell\connected_face_set.cfs_faces) ||
+                    closed_shell () || oriented_closed_shell(
+                     a_shell\oriented_closed_shell.closed_shell_element,
+                       NOT(a_shell\oriented_closed_shell.orientation));
+   ELSE
+      the_reverse := dummy_tri ||
+               connected_face_set (
+                 a_shell\connected_face_set.cfs_faces) ||
+               closed_shell () || oriented_closed_shell (a_shell, FALSE);
+   END_IF;
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION compute_total_depth
+	(swsrh: solid_with_stepped_round_hole) : positive_length_measure;
+LOCAL
+i  : positive_integer;
+n  : positive_integer := swsrh.segments;
+td : positive_length_measure := swsrh.segment_depths[1];
+END_LOCAL;
+
+IF n = 1 
+THEN RETURN(td);
+ELSE
+  REPEAT i := 2 TO n;
+    td := td + swsrh.segment_depths[i];
+  END_REPEAT;
+END_IF;
+RETURN(td);
+END_FUNCTION;
+
+FUNCTION conditional_reverse
+	(p: BOOLEAN; an_item: reversible_topology) : reversible_topology;
+IF p THEN
+     RETURN (an_item);
+   ELSE
+     RETURN (topology_reversed (an_item));
+   END_IF;
+END_FUNCTION;
+
+FUNCTION constraints_composite_curve_on_surface
+	(c: composite_curve_on_surface) : BOOLEAN;
+   LOCAL
+     n_segments : INTEGER := SIZEOF(c.segments);
+   END_LOCAL;
+        
+   REPEAT k := 1 TO n_segments;
+     IF (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN 
+           TYPEOF(c\composite_curve.segments[k].parent_curve))) AND
+        (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN 
+           TYPEOF(c\composite_curve.segments[k].parent_curve))) AND
+        (NOT('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE_ON_SURFACE' IN
+           TYPEOF(c\composite_curve.segments[k].parent_curve)))  THEN
+       RETURN (FALSE);
+     END_IF;
+   END_REPEAT;
+   RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION constraints_geometry_shell_based_surface_model
+	(m: shell_based_surface_model) : BOOLEAN;
+   LOCAL
+     result : BOOLEAN := TRUE;
+   END_LOCAL;
+   
+   REPEAT j := 1 TO SIZEOF(m.sbsm_boundary);
+     IF (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL' IN
+                     TYPEOF(m.sbsm_boundary[j])) AND
+        (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLOSED_SHELL' IN
+           TYPEOF(m.sbsm_boundary[j]))))
+     THEN
+       result := FALSE;
+       RETURN(result);
+       (* A surface model is composed of OPEN_ and CLOSED_SHELLs. *)
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION constraints_geometry_shell_based_wireframe_model
+	(m: shell_based_wireframe_model) : BOOLEAN;
+   LOCAL
+     result : BOOLEAN := TRUE;
+   END_LOCAL;
+
+   REPEAT j := 1 TO SIZEOF(m.sbwm_boundary);
+     IF (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.WIRE_SHELL' IN
+                    TYPEOF(m.sbwm_boundary[j])) AND
+        (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VERTEX_SHELL' IN
+                      TYPEOF(m.sbwm_boundary[j]))))
+     THEN
+       result := FALSE;
+       RETURN(result);
+       (* A wireframe model is composed of WIRE_ and VERTEX_SHELLs *)
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION constraints_param_b_spline
+	(degree: INTEGER; up_knots: INTEGER; up_cp: INTEGER; knot_mult: LIST [0:?] OF INTEGER; knots: LIST [0:?] OF parameter_value) : BOOLEAN;
+   LOCAL
+     result  : BOOLEAN := TRUE;
+     k, sum  : INTEGER;
+   END_LOCAL;
+   
+   (* Find sum of knot multiplicities. *)
+   sum := knot_mult[1];
+   
+   REPEAT i := 2 TO up_knots;
+     sum := sum + knot_mult[i];
+   END_REPEAT;
+   
+   (* Check limits holding for all B-spline parametrisations *)
+   IF (degree < 1) OR (up_knots < 2) OR (up_cp < degree) OR
+         (sum <> (degree + up_cp + 2)) THEN
+     result := FALSE;
+     RETURN(result);
+   END_IF;
+   
+   k := knot_mult[1];
+   
+   IF (k < 1) OR (k > degree + 1) THEN
+     result := FALSE;
+     RETURN(result);
+   END_IF;
+      
+   REPEAT i := 2 TO up_knots;
+     IF (knot_mult[i] < 1) OR (knots[i] <= knots[i-1]) THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+        
+     k := knot_mult[i];
+     
+     IF (i < up_knots) AND (k > degree) THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+        
+     IF (i = up_knots) AND (k > degree + 1) THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION constraints_rectangular_composite_surface
+	(s: rectangular_composite_surface) : BOOLEAN;
+REPEAT i := 1 TO s.n_u;
+       REPEAT j := 1 TO s.n_v;
+         IF NOT (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF
+                    (s.segments[i][j].parent_surface)) OR
+                 ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RECTANGULAR_TRIMMED_SURFACE' IN TYPEOF
+                    (s.segments[i][j].parent_surface))) THEN
+           RETURN(FALSE);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+
+   (* Check the transition codes, omitting the last row or column *)
+   REPEAT i := 1 TO s.n_u-1;
+     REPEAT j := 1 TO s.n_v;
+       IF s.segments[i][j].u_transition = discontinuous THEN
+         RETURN(FALSE);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+   
+   REPEAT i := 1 TO s.n_u;
+     REPEAT j := 1 TO s.n_v-1;
+       IF s.segments[i][j].v_transition = discontinuous THEN
+         RETURN(FALSE);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+   RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION control_characters_free
+	(s: STRING) : BOOLEAN;
+    LOCAL
+      ch : STRING;
+    END_LOCAL;
+
+    REPEAT i:=1 TO LENGTH(s);
+      ch := s[i];
+      IF (ch = '\x9') OR (ch = '\xA') OR (ch = '\xD') THEN
+        RETURN(FALSE);
+      END_IF;
+    END_REPEAT;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION cross_product
+	(arg1: direction; arg2: direction) : vector;
+  LOCAL
+    mag    : REAL;
+    res    : direction;
+    v1,v2  : LIST[3:3] OF REAL;
+    result : vector;
+  END_LOCAL;
+  
+  IF ( NOT EXISTS (arg1) OR (arg1.dim = 2)) OR
+     ( NOT EXISTS (arg2) OR (arg2.dim = 2)) THEN
+    RETURN(?);
+  ELSE
+    BEGIN
+      v1  := normalise(arg1).direction_ratios;
+      v2  := normalise(arg2).direction_ratios;
+      res := dummy_gri || direction([(v1[2]*v2[3] - v1[3]*v2[2]),
+            (v1[3]*v2[1] - v1[1]*v2[3]), (v1[1]*v2[2] - v1[2]*v2[1])]);
+      mag := 0.0;
+      REPEAT i := 1 TO 3;
+        mag := mag + res.direction_ratios[i]*res.direction_ratios[i];
+      END_REPEAT;
+      IF (mag > 0.0) THEN
+        result := dummy_gri || vector(res, SQRT(mag));
+      ELSE
+        result := dummy_gri || vector(arg1, 0.0);
+      END_IF;
+      RETURN(result);
+    END;
+  END_IF;
+END_FUNCTION;
+
+FUNCTION curve_weights_positive
+	(b: rational_b_spline_curve) : BOOLEAN;
+   LOCAL
+     result : BOOLEAN := TRUE;
+   END_LOCAL;
+
+   REPEAT i := 0 TO b.upper_index_on_control_points;
+     IF b.weights[i] <= 0.0  THEN
+       result := FALSE;
+       RETURN(result);
+     END_IF;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr2
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF SIZEOF(agg) <= 5 THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr3
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF (SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) 
+  AND (i\representation_item.name = 'significant number of digits')) )) = 1) OR 
+((SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'lower limit')) )) = 1) AND 
+(SIZEOF( QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'upper limit')) )) = 1)) THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr4
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF (SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'plus minus tolerance value')) )) = 1) OR 
+((SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND (
+  i\representation_item.name = 'lower tolerance value')) )) = 1) AND 
+(SIZEOF( QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND (
+  i\representation_item.name = 'upper tolerance value')) )) = 1)) THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION default_tolerance_table_cell_wr5
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN 
+IF (SIZEOF(QUERY ( i <* agg | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) )) <= 1) AND 
+(SIZEOF(QUERY ( i <* agg | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) )) = 
+  SIZEOF(QUERY ( i <* agg | (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF(i)) AND 
+  (i\representation_item.name = 'cell description'))) )) 
+THEN 
+  RETURN(TRUE); 
+ELSE 
+  RETURN(FALSE); 
+END_IF; 
+END;
+END_FUNCTION;
+
+FUNCTION dependently_instantiated
+	(set_of_input_instances: SET [0:?] OF GENERIC: igen; set_of_input_types: SET [0:?] OF STRING; previous_in_chain: LIST [0:?] OF GENERIC: cgen) : BOOLEAN;
+LOCAL
+  number_of_input_instances     : INTEGER;
+  number_of_referring_instances : INTEGER;
+  bag_of_referring_instances    : BAG OF GENERIC:igen := [];
+  dependently_instantiated_flag : BOOLEAN;
+  previous_in_chain_plus        : LIST OF GENERIC:cgen := [];
+  result                        : BOOLEAN := true;
+  set_of_types                  : SET OF STRING := [];
+END_LOCAL;
+
+IF EXISTS(set_of_input_instances) THEN
+  number_of_input_instances := SIZEOF(set_of_input_instances);
+  (* Add the declared type of bag_of_referring_instances to the set of
+     types of the REFERENCEd instances for the subset comparison later.
+   *)
+  set_of_input_types := set_of_input_types + 'GENERIC';
+  REPEAT i:=1 TO number_of_input_instances;
+    (* Determine all references to the current input instance. *)
+    bag_of_referring_instances := USEDIN (set_of_input_instances[i] , '');
+    IF EXISTS(bag_of_referring_instances) THEN
+      number_of_referring_instances := SIZEOF(bag_of_referring_instances);
+      dependently_instantiated_flag := false;
+      REPEAT j:=1 TO number_of_referring_instances;
+        (* Determine the type strings of the current referencing instance.
+         *)
+        set_of_types := TYPEOF(bag_of_referring_instances[j]);
+        (* If the referencing instance is of one of the types of the
+           only dependently instantiable select items, the current input
+           instance may still be invalidly instantiated.
+           Otherwise it is OK, and the next input instance is tested.
+         *)
+        IF set_of_types <= set_of_input_types THEN -- subset operator
+          (* The referring instance is of one of the restricted types.
+             However, it may itself be referred to by a valid instance;
+             then also the current instance would be valid.
+             Thus, call this function recursively with the referring
+             instance as input.
+             To avoid an infinite loop in case a set of instances
+             reference each other in a closed loop, test first whether
+             the current referencing instance is in the list of
+             previously processed chain members.
+           *)
+          IF NOT (bag_of_referring_instances[j] IN previous_in_chain) THEN
+            previous_in_chain_plus := previous_in_chain +
+            set_of_input_instances[i];
+            IF dependently_instantiated([bag_of_referring_instances[j]],
+              set_of_input_types,
+              previous_in_chain_plus) THEN
+              dependently_instantiated_flag := true;
+              ESCAPE; -- dependently instantiated; next input instance
+            ELSE
+              (* Not dependently instantiated: go to next referring
+              instance. *)
+              SKIP;
+            END_IF;
+          END_IF;
+        ELSE
+          dependently_instantiated_flag := true;
+          ESCAPE; -- dependently instantiated; take next input instance
+        END_IF;
+      END_REPEAT;
+      IF NOT dependently_instantiated_flag THEN
+        RETURN(false);
+      END_IF;
+    ELSE
+      RETURN(false); -- not referenced at all => invalidly instantiated
+    END_IF;
+  END_REPEAT;
+ELSE
+  RETURN(false); -- no input
+END_IF;
+
+RETURN(true);
+END_FUNCTION;
+
+FUNCTION derive_angle
+	(placement_1: axis2_placement_3d; placement_2: axis2_placement_3d) : plane_angle_measure;
+    LOCAL
+      v1     : direction;
+      v2     : direction;
+      mag_v1 : REAL;
+      mag_v2 : REAL;
+      theta  : plane_angle_measure;
+    END_LOCAL;
+    v1 := placement_1.p[1];
+    v2 := placement_2.p[1];
+    mag_v1 := SQRT (v1.direction_ratios[1]*v1.direction_ratios[1] +
+                    v1.direction_ratios[2]*v1.direction_ratios[2]);
+    mag_v2 := SQRT (v2.direction_ratios[1]*v2.direction_ratios[1] +
+                    v2.direction_ratios[2]*v2.direction_ratios[2]);
+    IF ((mag_v1 = 0.0) OR (mag_v2 = 0.0)) THEN
+      theta := 0.0;
+      RETURN (theta);
+    END_IF;
+    theta := ACOS ((v1.direction_ratios[1]*v2.direction_ratios[1] +
+                    v1.direction_ratios[2]*v2.direction_ratios[2]) /
+                   (mag_v1*mag_v2));
+    RETURN (theta);
+END_FUNCTION;
+
+FUNCTION derive_dimensional_exponents
+	(x: unit) : dimensional_exponents;
+    LOCAL
+      result : dimensional_exponents := dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+    END_LOCAL;
+
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DERIVED_UNIT' IN TYPEOF(x) THEN
+      REPEAT i := LOINDEX(x\derived_unit.elements) TO HIINDEX(x\derived_unit.elements);
+        result.length_exponent := result.length_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.length_exponent);
+        result.mass_exponent := result.mass_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.mass_exponent);
+        result.time_exponent := result.time_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.time_exponent);
+        result.electric_current_exponent := result.electric_current_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.electric_current_exponent);
+        result.thermodynamic_temperature_exponent := result.thermodynamic_temperature_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.thermodynamic_temperature_exponent);
+        result.amount_of_substance_exponent := result.amount_of_substance_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.amount_of_substance_exponent);
+        result.luminous_intensity_exponent := result.luminous_intensity_exponent + 
+        (x\derived_unit.elements[i]\derived_unit_element.exponent * 
+         x\derived_unit.elements[i]\derived_unit_element.unit\named_unit.dimensions.luminous_intensity_exponent);
+      END_REPEAT;
+    ELSE
+      result := x\named_unit.dimensions;
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+FUNCTION dimension_of
+	(item: geometric_representation_item) : dimension_count;
+  LOCAL
+    x   : SET OF representation;
+    y   : representation_context;
+    dim : dimension_count;
+  END_LOCAL;
+  -- For cartesian_point, direction, or vector dimension is determined by
+  -- counting components.
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF(item) THEN
+       dim := SIZEOF(item\cartesian_point.coordinates);
+       RETURN(dim);
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIRECTION' IN TYPEOF(item) THEN
+       dim := SIZEOF(item\direction.direction_ratios);
+       RETURN(dim);
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(item) THEN
+       dim := SIZEOF(item\vector.orientation\direction.direction_ratios);
+       RETURN(dim);
+    END_IF;
+  -- For all other types of geometric_representation_item dim is obtained
+  -- via context.
+  -- Find the set of representation in which the item is used. 
+
+  x := using_representations(item);
+
+  -- Determines the dimension_count of the 
+  -- geometric_representation_context. Note that the 
+  -- RULE compatible_dimension ensures that the context_of_items
+  -- is of type geometric_representation_context and has
+  -- the same dimension_count for all values of x.
+  -- The SET x is non-empty since this is required by WR1 of
+  -- representation_item.
+    y := x[1].context_of_items;
+    dim := y\geometric_representation_context.coordinate_space_dimension;
+    RETURN (dim);
+END_FUNCTION;
+
+FUNCTION dimensions_for_si_unit
+	(n: si_unit_name) : dimensional_exponents;
+CASE n OF 
+      metre:
+        RETURN (dimensional_exponents(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      gram:
+        RETURN (dimensional_exponents(0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      second:
+        RETURN (dimensional_exponents(0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0));
+      ampere:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0));
+      kelvin:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0));
+      mole:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0));
+      candela:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));
+      radian:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      steradian:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
+      hertz:
+        RETURN (dimensional_exponents(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0));
+      newton:
+        RETURN (dimensional_exponents(1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      pascal:
+        RETURN (dimensional_exponents(-1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      joule:
+        RETURN (dimensional_exponents(2.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      watt:
+        RETURN (dimensional_exponents(2.0, 1.0, -3.0, 0.0, 0.0, 0.0, 0.0));
+      coulomb:
+        RETURN (dimensional_exponents(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0));
+      volt:
+        RETURN (dimensional_exponents(2.0, 1.0, -3.0, -1.0, 0.0, 0.0, 0.0));
+      farad:
+        RETURN (dimensional_exponents(-2.0, -1.0, 4.0, 1.0, 0.0, 0.0, 0.0));
+      ohm:
+        RETURN (dimensional_exponents(2.0, 1.0, -3.0, -2.0, 0.0, 0.0, 0.0));
+      siemens:
+        RETURN (dimensional_exponents(-2.0, -1.0, 3.0, 2.0, 0.0, 0.0, 0.0));
+      weber:
+        RETURN (dimensional_exponents(2.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0));
+      tesla:
+        RETURN (dimensional_exponents(0.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0));
+      henry:
+        RETURN (dimensional_exponents(2.0, 1.0, -2.0, -2.0, 0.0, 0.0, 0.0));
+      degree_Celsius:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0));
+      lumen:
+        RETURN (dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));
+      lux:
+        RETURN (dimensional_exponents(-2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0));
+      becquerel:
+        RETURN (dimensional_exponents(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0));
+      gray:
+        RETURN (dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      sievert:
+        RETURN (dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0));
+      OTHERWISE:
+        RETURN (?);
+    END_CASE;
+END_FUNCTION;
+
+FUNCTION dot_product
+	(arg1: direction; arg2: direction) : REAL;
+   LOCAL
+     scalar : REAL;
+     vec1, vec2: direction;
+     ndim : INTEGER;
+   END_LOCAL;
+   
+   IF NOT EXISTS (arg1) OR NOT EXISTS (arg2) THEN
+     scalar := ?;
+     (* When function is called with invalid data an indeterminate result
+     is returned *)
+   ELSE
+     IF (arg1.dim <> arg2.dim) THEN
+       scalar := ?;
+     (* When function is called with invalid data an indeterminate result
+     is returned *)
+     ELSE
+       BEGIN
+         vec1   := normalise(arg1);
+         vec2   := normalise(arg2);
+         ndim   := arg1.dim;
+         scalar := 0.0;
+         REPEAT  i := 1 TO ndim;
+           scalar := scalar +
+                       vec1.direction_ratios[i]*vec2.direction_ratios[i];
+         END_REPEAT;
+       END;
+     END_IF;
+   END_IF;
+   RETURN (scalar);
+END_FUNCTION;
+
+FUNCTION edge_reversed
+	(an_edge: edge) : oriented_edge;
+   LOCAL
+     the_reverse : oriented_edge;
+   END_LOCAL;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_EDGE' IN TYPEOF (an_edge) ) THEN
+     the_reverse  := dummy_tri ||
+             edge(an_edge.edge_end, an_edge.edge_start) ||
+             oriented_edge(an_edge\oriented_edge.edge_element,
+                        NOT (an_edge\oriented_edge.orientation)) ;
+   ELSE
+     the_reverse := dummy_tri ||
+             edge(an_edge.edge_end, an_edge.edge_start) ||
+             oriented_edge(an_edge, FALSE);
+   END_IF;
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION external_version_assignment_is_valid
+	(aia: applied_external_identification_assignment) : BOOLEAN;
+    LOCAL
+      item: identification_item;
+      role: identification_role;
+    END_LOCAL;
+      role:= aia.role;
+      IF role.name='version' THEN
+        REPEAT i:=LOINDEX(aia.items) TO HIINDEX(aia.items);
+          item:= aia.items[i];
+          IF (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'EXTERNALLY_VERSIONED_ITEM']*TYPEOF(item))=0) THEN
+            -- item invalid if item does not belong to versionable types
+	        RETURN(FALSE);
+          END_IF;
+        END_REPEAT;
+        RETURN(TRUE);
+      ELSE		-- case where aia does not convey a version id
+        RETURN(TRUE);
+      END_IF;
+END_FUNCTION;
+
+FUNCTION face_bound_reversed
+	(a_face_bound: face_bound) : face_bound;
+   LOCAL
+     the_reverse : face_bound ;
+   END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_OUTER_BOUND' IN TYPEOF (a_face_bound) ) THEN
+     the_reverse := dummy_tri ||
+                      face_bound(a_face_bound\face_bound.bound,
+                           NOT (a_face_bound\face_bound.orientation))
+                            || face_outer_bound() ;
+   ELSE
+     the_reverse := dummy_tri ||
+         face_bound(a_face_bound.bound, NOT(a_face_bound.orientation));
+   END_IF;
+  RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION face_reversed
+	(a_face: face) : oriented_face;
+   LOCAL
+     the_reverse : oriented_face ;
+   END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_FACE' IN TYPEOF (a_face) ) THEN
+     the_reverse := dummy_tri ||
+       face(set_of_topology_reversed(a_face.bounds)) ||
+          oriented_face(a_face\oriented_face.face_element,
+                           NOT (a_face\oriented_face.orientation)) ;
+   ELSE
+     the_reverse := dummy_tri ||
+       face(set_of_topology_reversed(a_face.bounds)) ||
+                               oriented_face(a_face, FALSE) ;
+   END_IF;
+      RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION first_proj_axis
+	(z_axis: direction; arg: direction) : direction;
+  LOCAL
+    x_axis : direction;
+    v      : direction;
+    z      : direction;
+    x_vec  : vector;
+  END_LOCAL;
+  
+  IF (NOT EXISTS(z_axis)) THEN
+    RETURN (?) ;
+  ELSE
+    z := normalise(z_axis);
+    IF NOT EXISTS(arg) THEN
+      IF ((z.direction_ratios <> [1.0,0.0,0.0]) AND
+          (z.direction_ratios <> [-1.0,0.0,0.0]))  THEN
+        v :=  dummy_gri || direction([1.0,0.0,0.0]);
+      ELSE
+        v := dummy_gri || direction([0.0,1.0,0.0]);
+      END_IF;
+    ELSE
+      IF  (arg.dim <> 3) THEN
+        RETURN (?) ;
+      END_IF;
+      IF ((cross_product(arg,z).magnitude) = 0.0) THEN
+        RETURN (?);
+      ELSE
+        v := normalise(arg);
+      END_IF;
+    END_IF;
+    x_vec := scalar_times_vector(dot_product(v, z), z);
+    x_axis := vector_difference(v, x_vec).orientation;
+    x_axis := normalise(x_axis);
+  END_IF;
+  RETURN(x_axis);
+END_FUNCTION;
+
+FUNCTION gbsf_check_curve
+	(cv: representation_item) : BOOLEAN;
+IF SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1 THEN
+    RETURN (FALSE);
+  END_IF;
+  IF SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE'] * TYPEOF(cv)) = 1 THEN
+    RETURN (TRUE);
+  ELSE
+    IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF(cv)) AND (cv\b_spline_curve.self_intersect = FALSE) OR (cv\b_spline_curve.self_intersect = UNKNOWN)) THEN
+      RETURN (TRUE);
+    ELSE
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF(cv)) AND (cv\composite_curve.self_intersect = FALSE) OR (cv\composite_curve.self_intersect = UNKNOWN)) THEN
+        RETURN (SIZEOF(QUERY(seg <* cv\composite_curve.segments | NOT (gbsf_check_curve(seg.parent_curve)))) = 0);
+      ELSE
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF(cv) THEN
+          RETURN (gbsf_check_curve(cv\curve_replica.parent_curve));
+        ELSE
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF(cv)) AND ((cv\offset_curve_3d.self_intersect = FALSE) OR (cv\offset_curve_3d.self_intersect = UNKNOWN)) AND (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv\offset_curve_3d.basis_curve)))) THEN
+            RETURN (gbsf_check_curve(cv\offset_curve_3d.basis_curve));
+          ELSE
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv) THEN
+              RETURN ((gbsf_check_curve(cv\pcurve.reference_to_curve\representation.items[1])) AND (gbsf_check_surface(cv\pcurve.basis_surface)));
+            ELSE
+              IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv) THEN
+                IF (SIZEOF(cv\polyline.points) >= 3) THEN
+                  RETURN (TRUE);
+                END_IF;
+              ELSE
+                IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(cv) THEN
+                  IF gbsf_check_curve(cv\surface_curve.curve_3d) THEN
+                    REPEAT i := 1 TO SIZEOF(cv\surface_curve.associated_geometry);
+                      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN TYPEOF(cv\surface_curve.associated_geometry[i]) THEN
+                        IF NOT gbsf_check_surface(cv\surface_curve.associated_geometry[i]) THEN
+                          RETURN (FALSE);
+                        END_IF;
+                      ELSE
+                        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv\surface_curve.associated_geometry[i]) THEN
+                          IF NOT gbsf_check_curve(cv\surface_curve.associated_geometry[i]) THEN
+                            RETURN (FALSE);
+                          END_IF;
+                        END_IF;
+                      END_IF;
+                    END_REPEAT;
+                    RETURN (TRUE);
+                  END_IF;
+                END_IF;
+              END_IF;
+            END_IF;
+          END_IF;
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION gbsf_check_point
+	(pnt: point) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF(pnt) THEN
+    RETURN (TRUE);
+  ELSE
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE' IN TYPEOF(pnt) THEN
+      RETURN (gbsf_check_curve(pnt\point_on_curve.basis_curve));
+    ELSE
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE' IN TYPEOF(pnt) THEN
+        RETURN (gbsf_check_surface(pnt\point_on_surface.basis_surface));
+      ELSE
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE' IN TYPEOF(pnt) THEN
+          RETURN ((gbsf_check_curve(pnt\degenerate_pcurve.reference_to_curve\representation.items[1])) AND (gbsf_check_surface(pnt\degenerate_pcurve.basis_surface)));
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION gbsf_check_surface
+	(sf: surface) : BOOLEAN;
+IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(sf)) AND (sf\b_spline_surface.self_intersect = FALSE) OR (sf\b_spline_surface.self_intersect = UNKNOWN)) THEN
+    RETURN (TRUE);
+  ELSE
+    IF SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SPHERICAL_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TOROIDAL_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_BOUNDED_SURFACE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RECTANGULAR_TRIMMED_SURFACE'] * TYPEOF(sf)) = 1 THEN
+      RETURN (TRUE);
+    ELSE
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_SURFACE' IN TYPEOF(sf)) AND (sf\offset_surface.self_intersect = FALSE) OR (sf\offset_surface.self_intersect = UNKNOWN)) THEN
+        RETURN (gbsf_check_surface(sf\offset_surface.basis_surface));
+      ELSE
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RECTANGULAR_COMPOSITE_SURFACE' IN TYPEOF(sf) THEN
+          REPEAT i := 1 TO SIZEOF(sf\rectangular_composite_surface.segments);
+            REPEAT j := 1 TO SIZEOF(sf\rectangular_composite_surface.segments[i]);
+              IF NOT (gbsf_check_surface(sf\rectangular_composite_surface.segments[i][j].parent_surface)) THEN
+                RETURN (FALSE);
+              END_IF;
+            END_REPEAT;
+          END_REPEAT;
+          RETURN (TRUE);
+        ELSE
+          IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA' IN TYPEOF(sf) THEN
+            RETURN (gbsf_check_surface(sf\surface_replica.parent_surface));
+          ELSE
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_OF_REVOLUTION' IN TYPEOF(sf) THEN
+              RETURN (gbsf_check_curve(sf\swept_surface.swept_curve));
+            END_IF;
+          END_IF;
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION get_basis_surface
+	(c: curve_on_surface) : SET [0:2] OF surface;
+  LOCAL
+    surfs  : SET[0:2] OF surface;
+    n      : INTEGER;
+  END_LOCAL;
+  surfs := [];
+  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF (c) THEN
+    surfs := [c\pcurve.basis_surface];
+  ELSE
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF (c) THEN
+      n := SIZEOF(c\surface_curve.associated_geometry);
+      REPEAT i := 1 TO n;
+      surfs := surfs +
+                associated_surface(c\surface_curve.associated_geometry[i]);
+      END_REPEAT;
+    END_IF;
+  END_IF;
+  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE_ON_SURFACE' IN TYPEOF (c) THEN
+   (* For a composite_curve_on_surface the basis_surface is the intersection
+    of the basis_surfaces of all the segments. *)
+     n := SIZEOF(c\composite_curve.segments);
+     surfs := get_basis_surface(
+                     c\composite_curve.segments[1].parent_curve);
+     IF n > 1 THEN
+       REPEAT i := 2 TO n;
+         surfs := surfs * get_basis_surface(
+                  c\composite_curve.segments[i].parent_curve);
+       END_REPEAT;
+     END_IF;
+
+  END_IF;
+  RETURN(surfs);
+END_FUNCTION;
+
+FUNCTION get_description_value
+	(obj: description_attribute_select) : text;
+    LOCAL
+      description_bag : BAG OF description_attribute := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'DESCRIPTION_ATTRIBUTE.' + 'DESCRIBED_ITEM'));
+    END_LOCAL;
+
+    IF SIZEOF(description_bag) = 1 THEN
+      RETURN (description_bag[1].attribute_value);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_id_value
+	(obj: id_attribute_select) : identifier;
+    LOCAL
+      id_bag : BAG OF id_attribute := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ID_ATTRIBUTE.' + 'IDENTIFIED_ITEM'));
+    END_LOCAL;
+
+    IF SIZEOF(id_bag) = 1 THEN
+      RETURN (id_bag[1].attribute_value);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_name_value
+	(obj: name_attribute_select) : label;
+    LOCAL
+      name_bag : BAG OF name_attribute := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'NAME_ATTRIBUTE.' + 'NAMED_ITEM'));
+    END_LOCAL;
+
+    IF SIZEOF(name_bag) = 1 THEN
+      RETURN (name_bag[1].attribute_value);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_role
+	(obj: role_select) : object_role;
+    LOCAL
+      role_bag : BAG OF role_association := (USEDIN(obj, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'ROLE_ASSOCIATION.' + 'ITEM_WITH_ROLE'));
+    END_LOCAL;
+
+    IF SIZEOF(role_bag) = 1 THEN
+      RETURN (role_bag[1].role);
+    ELSE
+      RETURN (?);
+    END_IF;
+END_FUNCTION;
+
+FUNCTION get_shape_aspect_property_definition_representations
+	(s_a_instance: shape_aspect) : SET [0:?] OF property_definition_representation;
+LOCAL
+pd_set : SET OF property_definition := [];
+pdr_set : SET OF property_definition_representation := [] ;
+END_LOCAL;
+pd_set := bag_to_set(USEDIN(s_a_instance, 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROPERTY_DEFINITION.DEFINITION'));
+IF (SIZEOF(pd_set) < 1) THEN
+RETURN (pdr_set);
+END_IF;
+REPEAT i := 1 TO HIINDEX(pd_set);
+pdr_set := pdr_set + (QUERY(pdr <* USEDIN(pd_set[i], 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'PROPERTY_DEFINITION_REPRESENTATION.' + 'DEFINITION') |
+'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_DEFINITION_REPRESENTATION' IN TYPEOF(pdr)));
+END_REPEAT;
+RETURN (pdr_set);
+END_FUNCTION;
+
+FUNCTION is_acyclic
+	(arg: generic_expression) : BOOLEAN;
+RETURN (acyclic (arg, []));
+END_FUNCTION;
+
+FUNCTION is_int_expr
+	(arg: numeric_expression) : LOGICAL;
+LOCAL
+	i: INTEGER := 0;
+END_LOCAL;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_LITERAL' IN TYPEOF(arg) 
+THEN 
+	RETURN (TRUE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REAL_LITERAL' IN TYPEOF(arg) 
+THEN 
+	RETURN (FALSE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) 
+THEN 
+	RETURN (TRUE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) 
+THEN 
+	RETURN (FALSE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABS_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_int_expr(arg\unary_numeric_expression.operand));
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_int_expr(arg\unary_numeric_expression.operand)); 
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COS_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TAN_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ASIN_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACOS_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATAN_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXP_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG2_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG10_FUNCTION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SQUARE_ROOT_FUNCTION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (FALSE);
+END_IF;
+IF 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLUS_EXPRESSION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULT_EXPRESSION' 
+								IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAXIMUM_FUNCTION'
+								IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINIMUM_FUNCTION'
+								IN TYPEOF(arg)) 
+THEN 
+	REPEAT i :=1 TO SIZEOF (
+			arg\multiple_arity_numeric_expression.operands);
+	IF NOT 
+		is_int_expr(arg\multiple_arity_numeric_expression.operands[i]) 
+	THEN 
+		RETURN (FALSE);
+	END_IF;
+	END_REPEAT;
+	RETURN (TRUE);
+END_IF;
+IF 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_EXPRESSION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_EXPRESSION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (is_int_expr(arg\binary_numeric_expression.operands[1])
+		AND is_int_expr(arg\binary_numeric_expression.operands[2]));
+END_IF;
+IF	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIV_EXPRESSION' IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MOD_EXPRESSION' IN TYPEOF(arg))
+THEN 
+	RETURN(TRUE);	
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SLASH_EXPRESSION' IN TYPEOF(arg) 
+THEN 
+	RETURN (FALSE); 	
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (TRUE); 
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INT_VALUE_FUNCTION' 
+								IN TYPEOF(arg) 
+	THEN 
+		RETURN (TRUE); 
+	ELSE 
+		RETURN (FALSE); 
+	END_IF;
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INTEGER_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)
+THEN 
+	RETURN(TRUE) ;
+END_IF;
+IF'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN(FALSE) ;
+END_IF ;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)
+THEN 
+	RETURN(FALSE) ;
+END_IF ;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)
+THEN 
+	RETURN (FALSE) ;
+END_IF ;
+
+RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION is_SQL_mappable
+	(arg: expression) : LOGICAL;
+LOCAL
+	i: INTEGER;
+END_LOCAL;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_NUMERIC_EXPRESSION' 
+								IN TYPEOF (arg) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SQL_MAPPABLE_DEFINED_FUNCTION' 
+								IN TYPEOF (arg) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_FUNCTION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_SQL_mappable(arg\unary_numeric_expression.operand)); 
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABS_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COS_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TAN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ASIN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACOS_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ATAN_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EXP_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG2_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LOG10_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SQUARE_ROOT_FUNCTION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_FUNCTION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_FUNCTION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (FALSE);
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLUS_EXPRESSION' IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MULT_EXPRESSION' IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAXIMUM_FUNCTION' 
+								IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINIMUM_FUNCTION' 
+								IN TYPEOF(arg)) 
+THEN 
+	REPEAT i :=1 TO SIZEOF (
+			arg\multiple_arity_numeric_expression.operands);
+		IF NOT is_SQL_mappable(
+			arg\multiple_arity_numeric_expression.operands[i])
+		THEN 
+			RETURN (FALSE);
+		END_IF;
+	END_REPEAT;
+RETURN (TRUE);
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MINUS_EXPRESSION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SLASH_EXPRESSION' IN 
+								TYPEOF(arg))
+THEN
+		RETURN (is_SQL_mappable(
+			arg\binary_numeric_expression.operands[1])
+		AND is_SQL_mappable(arg\binary_numeric_expression.operands[2]));
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DIV_EXPRESSION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MOD_EXPRESSION' IN TYPEOF(arg)) 
+		OR('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_EXPRESSION' 
+								IN TYPEOF(arg))
+THEN 
+	RETURN (FALSE); 	
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_BOOLEAN_EXPRESSION' 
+								IN TYPEOF (arg) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NOT_EXPRESSION' IN TYPEOF (arg) 
+THEN 
+	RETURN (is_SQL_mappable (arg\UNARY_GENERIC_EXPRESSION.OPERAND));
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ODD_FUNCTION'IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.XOR_EXPRESSION' 
+								IN TYPEOF (arg)) 
+THEN	
+	RETURN (FALSE);
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AND_EXPRESSION' IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OR_EXPRESSION' IN TYPEOF (arg)) 
+THEN
+	REPEAT i:=1 TO SIZEOF (
+			arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS);
+		IF NOT is_SQL_mappable (
+			arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS[i]) 
+		THEN 
+			RETURN (FALSE);
+		END_IF;
+	END_REPEAT;
+	RETURN (TRUE);
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EQUALS_EXPRESSION' IN TYPEOF (arg) 
+THEN
+	RETURN(is_SQL_mappable (
+			arg\BINARY_GENERIC_EXPRESSION.OPERANDS [1])
+		AND is_SQL_mappable(
+			arg\BINARY_GENERIC_EXPRESSION.OPERANDS [2]));
+END_IF;
+IF	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_EQUAL' IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_GREATER' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_GREATER_EQUAL'
+								IN TYPEOF (arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_LESS' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_LESS_EQUAL' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPARISON_NOT_EQUAL' 
+								IN TYPEOF (arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LIKE_EXPRESSION' 
+								IN TYPEOF (arg)) 
+THEN
+	RETURN (is_SQL_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[1])
+		AND is_SQL_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[2]));
+END_IF;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INTERVAL_EXPRESSION' IN TYPEOF(arg) 
+THEN 
+	RETURN (is_SQL_mappable(arg\interval_expression.interval_low) 
+		AND is_SQL_mappable(arg\interval_expression.interval_high)
+		AND is_SQL_mappable(arg\interval_expression.interval_item));
+END_IF;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.NUMERIC_DEFINED_FUNCTION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOOLEAN_DEFINED_FUNCTION' 
+								IN TYPEOF(arg))
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.STRING_DEFINED_FUNCTION' 
+								IN TYPEOF(arg))  
+THEN 
+		RETURN (FALSE) ;
+END_IF;
+
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SIMPLE_STRING_EXPRESSION' 
+								IN TYPEOF(ARG) 
+THEN 
+	RETURN (TRUE);
+END_IF;
+IF 	('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INDEX_EXPRESSION' IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SUBSTRING_EXPRESSION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONCAT_EXPRESSION' 
+								IN TYPEOF(arg)) 
+		OR ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FORMAT_FUNCTION' 
+								IN TYPEOF(arg)) 
+THEN 
+	RETURN (FALSE);
+END_IF;
+
+	RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION item_in_context
+	(item: representation_item; cntxt: representation_context) : BOOLEAN;
+    LOCAL
+      y : BAG OF representation_item;
+    END_LOCAL;
+    -- If there is one or more representation using both the item
+    -- and cntxt return true.
+    IF SIZEOF(USEDIN(item,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION.ITEMS')
+      * cntxt.representations_in_context) > 0 THEN
+      RETURN (TRUE);
+      -- Determine the bag of representation_items that reference
+      -- item
+      ELSE y := QUERY(z <* USEDIN (item , '') |
+             'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM' IN TYPEOF(z));
+        -- Ensure that the bag is not empty
+        IF SIZEOF(y) > 0 THEN
+        -- For each element in the bag
+        REPEAT i := 1 TO HIINDEX(y);
+          -- Check to see it is an item in the input cntxt.
+          IF item_in_context(y[i], cntxt) THEN
+            RETURN (TRUE);
+          END_IF;
+        END_REPEAT;
+      END_IF;
+    END_IF;
+    -- Return false when all possible branches have been checked
+    -- with no success.
+    RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION leap_year
+	(year: year_number) : BOOLEAN;
+IF ((((year MOD 4) = 0) AND ((year MOD 100) <> 0)) OR ((year MOD 400) = 0)) THEN
+    RETURN (TRUE);
+  ELSE
+    RETURN (FALSE);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION list_face_loops
+	(f: face) : LIST [0:?] OF loop;
+   LOCAL
+     loops : LIST[0:?] OF loop := [];
+   END_LOCAL;
+   
+   REPEAT i := 1 TO SIZEOF(f.bounds);
+     loops := loops +(f.bounds[i].bound);
+   END_REPEAT;
+      
+   RETURN(loops);
+END_FUNCTION;
+
+FUNCTION list_of_topology_reversed
+	(a_list: list_of_reversible_topology_item) : list_of_reversible_topology_item;
+   LOCAL
+     the_reverse : list_of_reversible_topology_item;
+   END_LOCAL;
+    
+   the_reverse := [];
+   REPEAT i := 1 TO SIZEOF (a_list);
+     the_reverse := topology_reversed (a_list [i]) + the_reverse;
+   END_REPEAT;
+  
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION list_to_array
+	(lis: LIST [0:?] OF GENERIC: T; low: INTEGER; u: INTEGER) : ARRAY [low:u] OF GENERIC: T;
+   LOCAL
+     n   : INTEGER;
+     res : ARRAY [low:u] OF GENERIC : T;
+   END_LOCAL;
+      
+   n := SIZEOF(lis);
+   IF (n <> (u-low +1)) THEN
+     RETURN(?);
+   ELSE
+     res := [lis[1] : n];
+     REPEAT i := 2 TO n;
+       res[low+i-1] := lis[i];
+     END_REPEAT;
+     RETURN(res);
+   END_IF;
+END_FUNCTION;
+
+FUNCTION list_to_set
+	(l: LIST [0:?] OF GENERIC: T) : SET [0:?] OF GENERIC: T;
+   LOCAL
+     s : SET OF GENERIC:T := [];
+   END_LOCAL;
+      
+   REPEAT i := 1 TO SIZEOF(l);
+     s := s + l[i];
+   END_REPEAT;
+   
+   RETURN(s);
+END_FUNCTION;
+
+FUNCTION make_array_of_array
+	(lis: LIST [1:?] OF LIST [1:?] OF GENERIC: T; low1: INTEGER; u1: INTEGER; low2: INTEGER; u2: INTEGER) : ARRAY [low1:u1] OF ARRAY [low2:u2] OF GENERIC: T;
+   LOCAL
+     res   : ARRAY[low1:u1] OF ARRAY [low2:u2] OF GENERIC : T;
+   END_LOCAL;
+
+(* Check input dimensions for consistency *)
+   IF (u1-low1+1) <> SIZEOF(lis) THEN
+     RETURN (?);
+   END_IF;
+   IF (u2 - low2 + 1 ) <> SIZEOF(lis[1]) THEN
+     RETURN (?) ;
+   END_IF;
+(* Initialise res with values from lis[1] *)
+   res := [list_to_array(lis[1], low2, u2) : (u1-low1 + 1)];
+   REPEAT i := 2 TO HIINDEX(lis);
+     IF (u2-low2+1) <> SIZEOF(lis[i]) THEN
+       RETURN (?);
+     END_IF;     
+     res[low1+i-1] := list_to_array(lis[i], low2, u2);
+   END_REPEAT; 
+   
+   RETURN (res);
+END_FUNCTION;
+
+FUNCTION mixed_loop_type_set
+	(l: SET [0:?] OF loop) : LOGICAL;
+    LOCAL
+      poly_loop_type: LOGICAL;
+    END_LOCAL;
+    IF(SIZEOF(l) <= 1) THEN
+      RETURN(FALSE);
+    END_IF;
+    poly_loop_type := ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLY_LOOP' IN TYPEOF(l[1]));
+    REPEAT i := 2 TO SIZEOF(l);
+      IF(('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLY_LOOP' IN TYPEOF(l[i])) <> poly_loop_type)
+          THEN
+          RETURN(TRUE);
+       END_IF;
+    END_REPEAT;
+    RETURN(FALSE);
+END_FUNCTION;
+
+FUNCTION msb_shells
+	(brep: manifold_solid_brep) : SET [1:?] OF closed_shell;
+    LOCAL   
+      return_set: SET[1:?] OF closed_shell := [brep.outer];   
+    END_LOCAL;   
+
+    IF SIZEOF(QUERY(msbtype <* TYPEOF(brep) |   
+                 msbtype LIKE '*BREP_WITH_VOIDS'))  >= 1    
+          THEN   
+       return_set := return_set + brep\brep_with_voids.voids;   
+    END_IF;   
+   RETURN(return_set);
+END_FUNCTION;
+
+FUNCTION msf_curve_check
+	(cv: representation_item) : BOOLEAN;
+IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE',
+  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+  'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1 THEN
+  RETURN(FALSE);
+END_IF;
+
+(* b_spline_curves shall not self-intersect
+ *)
+IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (cv)) AND
+  (cv\b_spline_curve.self_intersect = FALSE)OR
+  (cv\b_spline_curve.self_intersect = UNKNOWN)) THEN
+  RETURN(TRUE);
+ELSE
+
+  (* conics and lines are valid curve types
+   *)
+  IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE'] 
+    * TYPEOF (cv)) = 1 THEN
+    RETURN(TRUE);
+  ELSE
+
+    (* a curve_replica shall reference a valid curve
+     *)
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF(cv) THEN
+      RETURN (msf_curve_check(cv\curve_replica.parent_curve)); 
+    ELSE 
+ 
+      (* an offset_curve_3d shall not self-intersect and
+         shall reference a valid curve; a polyline is not a
+         valid basis_curve
+       *)
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (cv))
+        AND
+        ((cv\offset_curve_3d.self_intersect = FALSE) OR
+        (cv\offset_curve_3d.self_intersect = UNKNOWN))
+        AND
+        (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF
+        (cv\offset_curve_3d.basis_curve)))) THEN
+        RETURN (msf_curve_check(cv\offset_curve_3d.basis_curve)); 
+      ELSE 
+ 
+        (* a pcurve shall reference a valid curve and a valid
+           basis_surface
+         *)
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv) THEN 
+          RETURN ((msf_curve_check
+          (cv\pcurve.reference_to_curve\representation.items[1])) AND
+          (msf_surface_check(cv\pcurve.basis_surface)));
+        ELSE 
+ 
+          (* a surface_curve references a curve_3d and one or
+             two pcurves or one or two surfaces or one of
+             each; all of these references shall be valid
+           *)
+          IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(cv) THEN 
+
+            (* if the curve reference is correct, check also the rest
+             *)
+            IF msf_curve_check(cv\surface_curve.curve_3d) THEN
+              REPEAT i := 1 TO SIZEOF
+              (cv\surface_curve.associated_geometry);
+
+                (* do for one or two associated_geometrys:
+                 *)
+                IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN 
+                  TYPEOF (cv\surface_curve.associated_geometry[i]) THEN  
+                  IF NOT msf_surface_check
+                    (cv\surface_curve.associated_geometry[i]) THEN  
+                    RETURN(FALSE);  
+                  END_IF;  
+                ELSE  
+                  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF 
+                    (cv\surface_curve.associated_geometry[i]) THEN  
+                    IF NOT msf_curve_check
+                      (cv\surface_curve.associated_geometry[i]) THEN 
+                      RETURN(FALSE);  
+                    END_IF;  
+                  END_IF;  
+                END_IF; 
+              END_REPEAT;  
+              RETURN(TRUE);
+            END_IF; 
+          ELSE
+
+            (* a polyline shall have at least 3 points
+             *)
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv) THEN
+              IF (SIZEOF (cv\polyline.points) >= 3) THEN RETURN (TRUE);
+              END_IF;
+            END_IF;
+          END_IF; 
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+END_IF; 
+(* FALSE is returned if the input parameter cv is not a valid curve.
+ *)
+RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION msf_surface_check
+	(surf: surface) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN TYPEOF(surf) THEN
+    RETURN(TRUE);
+  ELSE 
+
+    (* a swept_surface shall have a valid sweeping curve
+     *)
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (surf) THEN 
+      RETURN (msf_curve_check(surf\swept_surface.swept_curve));  
+    ELSE 
+ 
+      (* an offset_surface shall not self-intersect and shall
+         reference a valid surface
+       *)
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_SURFACE' IN TYPEOF (surf)) AND
+        (surf\offset_surface.self_intersect = FALSE) OR 
+        (surf\offset_surface.self_intersect = UNKNOWN)) THEN
+        RETURN (msf_surface_check(surf\offset_surface.basis_surface));
+      ELSE 
+ 
+        (* a surface_replica shall have a valid parent surface
+         *)
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA' IN TYPEOF(surf) THEN 
+          RETURN(msf_surface_check(surf\surface_replica.parent_surface)); 
+        ELSE
+
+          (* a b_spline_surface shall not self-intersect
+           *)
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(surf)) AND
+            (surf\b_spline_surface.self_intersect = FALSE) OR
+            (surf\b_spline_surface.self_intersect = UNKNOWN)) THEN
+            RETURN(TRUE);
+          END_IF;
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+  RETURN(FALSE);
+END_FUNCTION;
+
+FUNCTION nmsf_curve_check
+	(cv: representation_item) : BOOLEAN;
+IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.BOUNDED_CURVE',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D'] * TYPEOF(cv)) > 1
+ THEN RETURN(FALSE);
+ ELSE
+
+  (* b_spline_curves shall not self-intersect
+   *)
+  IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE' IN TYPEOF (cv)) AND
+    (cv\b_spline_curve.self_intersect = FALSE) OR
+    (cv\b_spline_curve.self_intersect = UNKNOWN))
+  THEN RETURN(TRUE);
+  ELSE
+
+    (* conics and lines are valid curve types
+     *)
+    IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC',
+    'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE'] * TYPEOF (cv)) = 1 THEN
+      RETURN(TRUE);
+    ELSE
+
+      (* a curve_replica shall reference a valid curve
+       *)
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF(cv) THEN
+        RETURN (nmsf_curve_check(cv\curve_replica.parent_curve)); 
+      ELSE 
+ 
+        (* an offset_curve_3d shall not self-intersect and
+           shall reference a valid curve; a polyline is not a
+           valid basis_curve
+         *)
+        IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (cv)) 
+          AND
+          ((cv\offset_curve_3d.self_intersect = FALSE) OR
+          (cv\offset_curve_3d.self_intersect = UNKNOWN))
+          AND
+          (NOT ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF
+          (cv\offset_curve_3d.basis_curve)))) THEN
+          RETURN (nmsf_curve_check(cv\offset_curve_3d.basis_curve)); 
+        ELSE 
+ 
+          (* a pcurve shall reference a valid curve and a valid
+             basis_surface
+           *)
+          IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF(cv) THEN 
+            RETURN ((nmsf_curve_check
+            (cv\pcurve.reference_to_curve\representation.items[1]))
+            AND
+            (nmsf_surface_check(cv\pcurve.basis_surface)));
+          ELSE 
+ 
+            (* a surface_curve references a curve_3d and one or
+               two pcurves or one or two surfaces or one of
+               each; all of these references shall be valid
+             *)
+            IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_CURVE' IN TYPEOF(cv) THEN 
+
+              (* if the curve reference is correct, check also the rest
+               *)
+              IF nmsf_curve_check(cv\surface_curve.curve_3d) THEN
+                REPEAT i := 1 TO SIZEOF
+                (cv\surface_curve.associated_geometry);
+
+                  (* do for one or two associated_geometrys:
+                   *)
+                  IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE' IN 
+                    TYPEOF (cv\surface_curve.associated_geometry[i]) THEN  
+                    IF NOT nmsf_surface_check
+                      (cv\surface_curve.associated_geometry[i]) THEN  
+                      RETURN(FALSE);  
+                    END_IF;  
+                  ELSE  
+                    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PCURVE' IN TYPEOF 
+                      (cv\surface_curve.associated_geometry[i]) THEN  
+                      IF NOT nmsf_curve_check
+                        (cv\surface_curve.associated_geometry[i]) THEN 
+                        RETURN(FALSE);  
+                      END_IF;  
+                    END_IF;  
+                  END_IF; 
+                END_REPEAT;  
+                RETURN(TRUE);
+              END_IF; 
+            ELSE
+
+              (* a polyline shall have at least 3 points 
+               *)
+              IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' IN TYPEOF(cv) THEN
+                IF (SIZEOF (cv\polyline.points) >= 3) THEN RETURN (TRUE);
+                END_IF;
+              END_IF;
+            END_IF; 
+          END_IF; 
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+ END_IF; 
+ (* FALSE is returned if the input parameter cv is not a valid curve.
+  *)
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION nmsf_surface_check
+	(surf: surface) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELEMENTARY_SURFACE' IN TYPEOF(surf) THEN
+    RETURN(TRUE);
+  ELSE 
+
+    (* a swept_surface shall have a valid sweeping curve
+     *)
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SWEPT_SURFACE' IN TYPEOF (surf) THEN 
+      RETURN (nmsf_curve_check(surf\swept_surface.swept_curve));  
+    ELSE 
+ 
+      (* an offset_surface shall not self-intersect and shall
+         reference a valid surface
+       *)
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_SURFACE' IN TYPEOF (surf)) AND
+        (surf\offset_surface.self_intersect = FALSE) OR 
+        (surf\offset_surface.self_intersect = UNKNOWN)) THEN
+        RETURN (nmsf_surface_check(surf\offset_surface.basis_surface));
+      ELSE 
+ 
+        (* a surface_replica shall have a valid parent surface
+         *)
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SURFACE_REPLICA' IN TYPEOF(surf) THEN 
+          RETURN(nmsf_surface_check(surf\surface_replica.parent_surface)); 
+        ELSE
+
+          (* a b_spline_surface shall not self-intersect
+           *)
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_SURFACE' IN TYPEOF(surf))
+            AND
+            (surf\b_spline_surface.self_intersect = FALSE) OR
+            (surf\b_spline_surface.self_intersect = UNKNOWN)) THEN
+            RETURN(TRUE);
+          END_IF;
+        END_IF; 
+      END_IF; 
+    END_IF; 
+  END_IF; 
+  RETURN(FALSE);
+END_FUNCTION;
+
+FUNCTION normalise
+	(arg: vector_or_direction) : vector_or_direction;
+    LOCAL
+      ndim   : INTEGER;
+      v      : direction;
+      result : vector_or_direction;
+      vec    : vector;
+      mag    : REAL;
+    END_LOCAL;
+    
+    IF NOT EXISTS (arg) THEN
+      result := ?;
+  (* When function is called with invalid data a NULL result is returned *)
+    ELSE
+      ndim := arg.dim;
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg) THEN
+        BEGIN
+              v := dummy_gri || direction(arg\vector.orientation.direction_ratios);
+          IF arg.magnitude = 0.0 THEN
+            RETURN(?);
+          ELSE
+           vec := dummy_gri || vector (v, 1.0);
+          END_IF;
+        END;
+      ELSE
+        v := dummy_gri || direction (arg.direction_ratios);
+      END_IF;
+      mag := 0.0;
+      REPEAT  i := 1 TO ndim;
+        mag := mag + v.direction_ratios[i]*v.direction_ratios[i];
+      END_REPEAT;
+      IF mag > 0.0 THEN
+        mag := SQRT(mag);
+        REPEAT  i := 1 TO ndim;
+          v.direction_ratios[i] := v.direction_ratios[i]/mag;
+        END_REPEAT;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg) THEN
+          vec.orientation := v;
+          result := vec;
+        ELSE
+          result := v;
+        END_IF;
+      ELSE
+        RETURN(?);
+      END_IF;
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+FUNCTION open_shell_reversed
+	(a_shell: open_shell) : oriented_open_shell;
+   LOCAL
+     the_reverse : oriented_open_shell;
+   END_LOCAL;
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_OPEN_SHELL' IN TYPEOF (a_shell) ) THEN
+     the_reverse := dummy_tri ||
+                  connected_face_set (
+                      a_shell\connected_face_set.cfs_faces) ||
+                  open_shell () || oriented_open_shell(
+                    a_shell\oriented_open_shell.open_shell_element,
+                      (NOT (a_shell\oriented_open_shell.orientation)));
+   ELSE
+     the_reverse := dummy_tri ||
+                 connected_face_set (
+                     a_shell\connected_face_set.cfs_faces) ||
+                 open_shell () ||  oriented_open_shell (a_shell, FALSE);
+   END_IF;
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION orthogonal_complement
+	(vec: direction) : direction;
+   LOCAL
+     result :  direction ;
+   END_LOCAL;
+
+   IF (vec.dim <> 2) OR NOT EXISTS (vec) THEN
+     RETURN(?);
+   ELSE
+     result := dummy_gri || direction([-vec.direction_ratios[2],
+                                          vec.direction_ratios[1]]);
+     RETURN(result);
+   END_IF;
+END_FUNCTION;
+
+FUNCTION path_head_to_tail
+	(a_path: path) : LOGICAL;
+   LOCAL
+     n : INTEGER;
+     p : LOGICAL := TRUE;
+   END_LOCAL;
+     
+     n := SIZEOF (a_path.edge_list);
+     REPEAT i := 2 TO n;
+       p := p AND (a_path.edge_list[i-1].edge_end :=:
+                   a_path.edge_list[i].edge_start);
+     END_REPEAT;
+     
+     RETURN (p);
+END_FUNCTION;
+
+FUNCTION path_reversed
+	(a_path: path) : oriented_path;
+  LOCAL
+    the_reverse : oriented_path ;
+  END_LOCAL;
+  IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ORIENTED_PATH' IN TYPEOF (a_path) ) THEN
+    the_reverse := dummy_tri ||
+       path(list_of_topology_reversed (a_path.edge_list)) ||
+          oriented_path(a_path\oriented_path.path_element,
+                          NOT(a_path\oriented_path.orientation)) ;
+  ELSE
+    the_reverse := dummy_tri ||
+                   path(list_of_topology_reversed (a_path.edge_list)) ||
+                       oriented_path(a_path, FALSE);
+  END_IF;
+
+  RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION scalar_times_vector
+	(scalar: REAL; vec: vector_or_direction) : vector;
+    LOCAL
+      v      : direction;
+      mag    : REAL;
+      result : vector;
+    END_LOCAL;
+ 
+    IF NOT EXISTS (scalar) OR NOT EXISTS (vec) THEN
+      RETURN (?) ;
+     ELSE
+      IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF (vec) THEN
+        v   := dummy_gri || direction(vec\vector.orientation.direction_ratios);
+        mag := scalar * vec.magnitude;
+      ELSE
+        v   := dummy_gri || direction(vec.direction_ratios);
+        mag := scalar;
+      END_IF;
+      IF (mag < 0.0 ) THEN
+        REPEAT i := 1 TO SIZEOF(v.direction_ratios);
+          v.direction_ratios[i] := -v.direction_ratios[i];
+        END_REPEAT;
+        mag := -mag;
+      END_IF;
+      result := dummy_gri || vector(normalise(v), mag);
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+FUNCTION second_proj_axis
+	(z_axis: direction; x_axis: direction; arg: direction) : direction;
+   LOCAL
+     y_axis : vector;
+     v      : direction;
+     temp   : vector;
+   END_LOCAL;
+   
+   IF NOT EXISTS(arg) THEN
+     v := dummy_gri || direction([0.0,1.0,0.0]);
+   ELSE
+     v := arg;
+   END_IF;
+   
+   temp   := scalar_times_vector(dot_product(v, z_axis), z_axis);
+   y_axis := vector_difference(v, temp);
+   temp   := scalar_times_vector(dot_product(v, x_axis), x_axis);
+   y_axis := vector_difference(y_axis, temp);
+   y_axis := normalise(y_axis);
+   RETURN(y_axis.orientation);
+END_FUNCTION;
+
+FUNCTION set_of_topology_reversed
+	(a_set: set_of_reversible_topology_item) : set_of_reversible_topology_item;
+   LOCAL
+     the_reverse : set_of_reversible_topology_item;
+   END_LOCAL;
+   
+   the_reverse := [];
+   REPEAT i := 1 TO SIZEOF (a_set);
+     the_reverse := the_reverse + topology_reversed (a_set [i]);
+   END_REPEAT;
+   
+   RETURN (the_reverse);
+END_FUNCTION;
+
+FUNCTION shell_reversed
+	(a_shell: shell) : shell;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OPEN_SHELL' IN TYPEOF (a_shell) ) THEN
+     RETURN (open_shell_reversed (a_shell));
+   ELSE
+     IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CLOSED_SHELL' IN TYPEOF (a_shell) ) THEN
+       RETURN (closed_shell_reversed (a_shell));
+     ELSE
+       RETURN (?);
+     END_IF;
+   END_IF;
+END_FUNCTION;
+
+FUNCTION surface_condition_correlation
+	(pd: property_definition; rep: representation) : LOGICAL;
+CASE pd.name OF
+      'visual appearance', 'tactile appearance', 'contact ratio', 'hardness', 'treatment result', 'surface texture' : 
+	  RETURN(pd.name = rep.name);
+      OTHERWISE : RETURN(UNKNOWN);
+    END_CASE;
+END_FUNCTION;
+
+FUNCTION surface_weights_positive
+	(b: rational_b_spline_surface) : BOOLEAN;
+   LOCAL
+     result        : BOOLEAN := TRUE;
+   END_LOCAL;
+   
+   REPEAT i := 0 TO b.u_upper;
+     REPEAT j := 0 TO b.v_upper;
+       IF (b.weights[i][j] <= 0.0)  THEN
+         result := FALSE;
+         RETURN(result);
+       END_IF;
+     END_REPEAT;
+   END_REPEAT;
+   RETURN(result);
+END_FUNCTION;
+
+FUNCTION topology_reversed
+	(an_item: reversible_topology) : reversible_topology;
+IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.EDGE' IN TYPEOF (an_item)) THEN
+     RETURN (edge_reversed (an_item));
+   END_IF;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PATH' IN TYPEOF (an_item)) THEN
+     RETURN (path_reversed (an_item));
+   END_IF;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE_BOUND' IN TYPEOF (an_item)) THEN
+     RETURN (face_bound_reversed (an_item));
+   END_IF;
+  
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FACE' IN TYPEOF (an_item)) THEN
+     RETURN (face_reversed (an_item));
+   END_IF;
+
+   IF ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHELL' IN TYPEOF (an_item)) THEN
+     RETURN (shell_reversed (an_item));
+   END_IF;
+
+   IF ('SET' IN TYPEOF (an_item)) THEN
+     RETURN (set_of_topology_reversed (an_item));
+   END_IF;
+
+   IF ('LIST' IN TYPEOF (an_item)) THEN
+     RETURN (list_of_topology_reversed (an_item));
+   END_IF;
+
+   RETURN (?);
+END_FUNCTION;
+
+FUNCTION type_check_function
+	(the_type: GENERIC; sub_names: SET [0:?] OF STRING; criterion: INTEGER) : LOGICAL;
+IF ((NOT EXISTS(the_type)) OR (NOT ({0 <= criterion <= 3})) OR (SIZEOF(sub_names) = 0)) THEN
+      RETURN (UNKNOWN);
+    ELSE
+      CASE criterion OF 
+        0:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) > 0);
+        1:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) = 0);
+        2:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) = 1);
+        3:
+          RETURN (SIZEOF(sub_names * TYPEOF(the_type)) <= 1);
+      END_CASE;
+    END_IF;
+END_FUNCTION;
+
+FUNCTION using_items
+	(item: founded_item_select; checked_items: SET [0:?] OF founded_item_select) : SET [0:?] OF founded_item_select;
+    LOCAL
+      new_check_items    : SET OF founded_item_select;
+      result_items       : SET OF founded_item_select;
+      next_items         : SET OF founded_item_select;
+    END_LOCAL;
+    result_items := [];
+    new_check_items := checked_items + item;
+    -- Find the set of representation_items or founded_items
+    -- in which item is used directly.
+    next_items := QUERY(z <* bag_to_set( USEDIN(item , '')) |
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION_ITEM' IN TYPEOF(z)) OR
+      ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FOUNDED_ITEM'        IN TYPEOF(z)));
+    -- If the set of next_items is not empty;
+    IF SIZEOF(next_items) > 0 THEN
+      -- For each element in the set, find the using_items recursively
+      REPEAT i := 1 TO HIINDEX(next_items);
+        -- Check for loop in data model, i.e. one of the next_items
+        -- occurred earlier in the set of check_items;
+        IF NOT(next_items[i] IN new_check_items) THEN
+          result_items := result_items + next_items[i] +
+                          using_items(next_items[i],new_check_items);
+        END_IF;
+      END_REPEAT;
+    END_IF;
+    -- return the set of representation_items or founded_items
+    -- in which the input item is used directly and indirectly.
+    RETURN (result_items);
+END_FUNCTION;
+
+FUNCTION using_representations
+	(item: founded_item_select) : SET [0:?] OF representation;
+    LOCAL
+      results            : SET OF representation;
+      result_bag         : BAG OF representation;
+      intermediate_items : SET OF founded_item_select;
+    END_LOCAL;
+    -- Find the representations in which the item is used and add to the
+    -- results set.
+    results := [];
+    result_bag := USEDIN(item,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION.ITEMS');
+    IF SIZEOF(result_bag) > 0 THEN
+      REPEAT i := 1 TO HIINDEX(result_bag);
+        results := results + result_bag[i];
+      END_REPEAT;
+    END_IF;
+    -- Find all representation_items or founded_items
+    -- by which item is referenced directly or indirectly.
+    intermediate_items := using_items(item,[]);
+    -- If the set of intermediate items is not empty;
+    IF SIZEOF(intermediate_items) > 0 THEN
+      -- For each element in the set, add the
+      -- representations of that element.
+      REPEAT i := 1 TO HIINDEX(intermediate_items);
+        result_bag := USEDIN(intermediate_items[i],
+                      'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.REPRESENTATION.ITEMS');
+        IF SIZEOF(result_bag) > 0 THEN
+          REPEAT j := 1 TO HIINDEX(result_bag);
+            results := results + result_bag[j];
+          END_REPEAT;
+        END_IF;
+      END_REPEAT;
+    END_IF;
+    -- Return the set of representation in which the input item is
+    -- used directly and indirectly (through intervening
+    -- representation_items or founded items).
+    RETURN (results);
+END_FUNCTION;
+
+FUNCTION valid_basis_curve_in_2d_wireframe
+	(crv: curve) : BOOLEAN;
+IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE',
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE',
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE',
+               'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE'] * 
+               TYPEOF (crv)) = 1
+    THEN RETURN (TRUE);
+  ELSE
+    -- if the curve is a trimmed_curve
+    IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE') 
+    IN TYPEOF (crv)) THEN
+      -- if a line, parabola, or hyperbola is being trimmed, then valid
+      IF SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE',
+                   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARABOLA',
+                   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.HYPERBOLA'] *
+           TYPEOF(crv\trimmed_curve.basis_curve)) = 1
+        THEN RETURN (TRUE);
+      -- otherwise, recursively check basis_curve
+      ELSE RETURN (valid_basis_curve_in_2d_wireframe
+                         (crv\trimmed_curve.basis_curve));
+      END_IF;
+    ELSE
+      -- recursively check the offset_curve basis curve
+      IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_2D') 
+      IN TYPEOF (crv))
+        THEN RETURN (valid_basis_curve_in_2d_wireframe
+                           (crv\offset_curve_2d.basis_curve));
+      ELSE
+        -- recursively check the curve_replica parent curve
+        IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA') 
+        IN TYPEOF (crv))
+          THEN RETURN (valid_basis_curve_in_2d_wireframe
+                         (crv\curve_replica.parent_curve));
+        ELSE
+          -- recursively check the composite_curve segments
+          IF (('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE') 
+          IN TYPEOF (crv)) THEN
+            RETURN (SIZEOF (QUERY (ccs <* crv\composite_curve.segments |
+                      NOT (valid_basis_curve_in_2d_wireframe
+                             (ccs.parent_curve)))) = 0);
+          END_IF;
+        END_IF;
+      END_IF;
+    END_IF;
+  END_IF;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_calendar_date
+	(date: calendar_date) : LOGICAL;
+CASE date.month_component OF
+    1  : RETURN({ 1 <= date.day_component <= 31 });
+    2  : BEGIN
+           IF (leap_year(date.year_component)) THEN
+             RETURN({ 1 <= date.day_component <= 29 });
+           ELSE
+             RETURN({ 1 <= date.day_component <= 28 });
+           END_IF;
+         END;
+    3  : RETURN({ 1 <= date.day_component <= 31 });
+    4  : RETURN({ 1 <= date.day_component <= 30 });
+    5  : RETURN({ 1 <= date.day_component <= 31 });
+    6  : RETURN({ 1 <= date.day_component <= 30 });
+    7  : RETURN({ 1 <= date.day_component <= 31 });
+    8  : RETURN({ 1 <= date.day_component <= 31 });
+    9  : RETURN({ 1 <= date.day_component <= 30 });
+    10 : RETURN({ 1 <= date.day_component <= 31 });
+    11 : RETURN({ 1 <= date.day_component <= 30 });
+    12 : RETURN({ 1 <= date.day_component <= 31 });
+  END_CASE;
+  RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_datum_target_parameters
+	(pdf: placed_datum_target_feature) : BOOLEAN;
+LOCAL
+
+rep_set : SET OF representation := [] ;
+
+parameter_representations: SET OF representation;
+END_LOCAL;
+
+
+REPEAT i := 1 TO HIINDEX(pdf.representation_associations);
+rep_set := rep_set + pdf.representation_associations[i].used_representation;
+END_REPEAT;
+ 
+parameter_representations := QUERY(rep <* rep_set |
+('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SHAPE_REPRESENTATION_WITH_PARAMETERS' IN
+TYPEOF(rep)));
+
+
+IF (SIZEOF( QUERY( srwp <* parameter_representations |
+          (SIZEOF( QUERY( i <* srwp.items |
+          (i.name='orientation') AND
+          ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLACEMENT' IN TYPEOF(i)))) = 1))) <> 1) THEN
+   RETURN(FALSE);
+END_IF;
+
+CASE pdf\shape_aspect.description OF
+'point': RETURN(SIZEOF(QUERY( srwp <* parameter_representations |
+              (SIZEOF(srwp.items) = 1))) = 1);
+
+'circle': RETURN((SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF(srwp.items) = 2))) = 1) AND
+             (SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF( QUERY( i <* srwp.items |
+                (i.name='target diameter') AND
+                (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+		   'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                 ) = 2) )) = 1))) = 1));
+
+'line': RETURN(SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF( QUERY( i <* srwp.items |
+                (i.name='target length') AND
+                (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+		'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                 ) = 2) )) = 1))) = 1);
+
+'rectangle': RETURN((SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF(srwp.items)= 3))) = 1) AND
+             (SIZEOF( QUERY( srwp <* parameter_representations |
+              (SIZEOF( QUERY( i <* srwp.items |
+                (i.name='target length') AND
+                (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+		'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                 ) = 2))) = 1))) = 1) AND
+              (SIZEOF( QUERY( srwp <* parameter_representations |
+               (SIZEOF( QUERY( i <* srwp.items |
+                 (i.name='target width') AND
+                 (SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM',
+ 		'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE_WITH_UNIT']*TYPEOF(i)
+                  ) = 2))) = 1) )) = 1));
+OTHERWISE : RETURN(FALSE);
+END_CASE;
+END_FUNCTION;
+
+FUNCTION valid_geometrically_bounded_wf_curve
+	(crv: curve) : BOOLEAN;
+IF SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELLIPSE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CIRCLE' ] * TYPEOF (crv)) = 1 THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TRIMMED_CURVE' IN TYPEOF (crv) THEN 
+ IF SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PARABOLA', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.HYPERBOLA' ] * TYPEOF (crv\trimmed_curve.basis_curve)) = 1 THEN 
+ RETURN (TRUE);
+ ELSE 
+ RETURN (valid_geometrically_bounded_wf_curve(crv\trimmed_curve.basis_curve));
+ END_IF ;
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (crv) THEN 
+ RETURN (valid_geometrically_bounded_wf_curve(crv\offset_curve_3d.basis_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF (crv) THEN 
+ RETURN (valid_geometrically_bounded_wf_curve(crv\curve_replica.parent_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.COMPOSITE_CURVE' IN TYPEOF (crv) THEN 
+ RETURN ( SIZEOF ( 
+QUERY ( ccs <* crv\composite_curve.segments| NOT valid_geometrically_bounded_wf_curve(ccs.parent_curve) )) = 0);
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_geometrically_bounded_wf_point
+	(pnt: point) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (pnt) THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE' IN TYPEOF (pnt) THEN 
+ RETURN (valid_geometrically_bounded_wf_curve(pnt\point_on_curve.basis_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_REPLICA' IN TYPEOF (pnt) THEN 
+ RETURN (valid_geometrically_bounded_wf_point(pnt\point_replica.parent_pt));
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_measure_value
+	(m: measure_value) : BOOLEAN;
+IF ('REAL' IN TYPEOF (m)) THEN
+    RETURN (m > 0.0);
+    ELSE
+     IF ('INTEGER' IN TYPEOF (m)) THEN
+      RETURN (m > 0);
+      ELSE
+        RETURN (TRUE);
+      END_IF;
+    END_IF;
+END_FUNCTION;
+
+FUNCTION valid_selected_instance_representation
+	(pd: product_definition_or_assembly_relationship) : LOGICAL;
+    LOCAL
+      properties: SET OF property_definition := bag_to_set(QUERY( prd<* USEDIN ( pd ,'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROPERTY_DEFINITION.DEFINITION' ) | 
+        (prd.name = 'occurrence selection' )));
+      property_definition_representations: SET OF property_definition_representation := bag_to_set(QUERY ( pdr <* USEDIN ( properties[1] , 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PROPERTY_DEFINITION_REPRESENTATION.DEFINITION') | 
+	    ( pdr.used_representation.name = 'selection criteria' )));
+      selected_representation: representation;
+    END_LOCAL;
+    IF (SIZEOF( properties)<>1) THEN
+	  RETURN(FALSE);
+    END_IF;
+    IF (SIZEOF(property_definition_representations)<>1) THEN
+	  RETURN(FALSE);
+    END_IF;
+    selected_representation := property_definition_representations[1]\property_definition_representation.used_representation;
+    IF (SIZEOF(selected_representation\representation.items) <1) OR (SIZEOF(selected_representation\representation.items) >2) THEN
+	  RETURN(FALSE);
+    END_IF;
+    IF (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+	  ( SIZEOF (['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' ,
+      'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_RANGE']* TYPEOF ( i ) ) = 1) AND
+      ( i.name = 'selection quantity' ))) <> 1 ) THEN
+      RETURN(FALSE);
+    END_IF;
+    IF (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+	  ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF ( i ) ) AND
+ 	  ( i.name = 'selection control' )))> 1) THEN
+	  RETURN(FALSE);
+    END_IF; --the selection control is not specified then the quantity shall be a qualified_representation_item or a value_range
+    IF (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+      ( 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DESCRIPTIVE_REPRESENTATION_ITEM' IN TYPEOF( i ) ) AND
+      ( i.name = 'selection control' ) ))= 0) AND 
+      (SIZEOF ( QUERY ( i <* selected_representation\representation.items |
+      ( i.name = 'selection quantity' ) AND  
+      ( SIZEOF(['AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.QUALIFIED_REPRESENTATION_ITEM' ,
+      'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_RANGE']* TYPEOF ( i ) ) =0 ))) > 0 ) THEN
+	  RETURN(FALSE);
+    END_IF;
+    RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION valid_time
+	(time: local_time) : BOOLEAN;
+IF EXISTS(time.second_component) THEN
+    RETURN (EXISTS(time.minute_component));
+  ELSE
+    RETURN (TRUE);
+  END_IF;
+END_FUNCTION;
+
+FUNCTION valid_units
+	(m: measure_with_unit) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LENGTH_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MASS_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.TIME_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CURRENT_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.THERMODYNAMIC_TEMPERATURE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CELSIUS_TEMPERATURE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AMOUNT_OF_SUBSTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_INTENSITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PLANE_ANGLE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.SOLID_ANGLE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.AREA_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VOLUME_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RATIO_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_LENGTH_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POSITIVE_PLANE_ANGLE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+      dimensional_exponents(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ACCELERATION_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 1.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+     IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CAPACITANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( -2.0, -1.0, 4.0, 1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_CHARGE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONDUCTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+          IF derive_dimensional_exponents(m.unit_component) <> 
+            dimensional_exponents( -2.0, -1.0, 3.0, 2.0, 0.0, 0.0, 0.0 ) THEN
+            RETURN (FALSE);
+          END_IF;
+    END_IF;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ELECTRIC_POTENTIAL_MEASURE' IN TYPEOF(m.value_component) THEN
+          IF derive_dimensional_exponents(m.unit_component) <> 
+            dimensional_exponents( 2.0, 1.0, -3.0, -1.0, 0.0, 0.0, 0.0 ) THEN
+            RETURN (FALSE);
+          END_IF;
+    END_IF;    
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ENERGY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FORCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.FREQUENCY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ILLUMINANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( -2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+     IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.INDUCTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -2.0, -2.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LUMINOUS_FLUX_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+     IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MAGNETIC_FLUX_DENSITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 0.0, 1.0, -2.0, -1.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POWER_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -3.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.PRESSURE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( -1.0, 1.0, -2.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RESISTANCE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 2.0, 1.0, -3.0, -2.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VELOCITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents( 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0 ) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.RADIOACTIVITY_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents(0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.ABSORBED_DOSE_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DOSE_EQUIVALENT_MEASURE' IN TYPEOF(m.value_component) THEN
+      IF derive_dimensional_exponents(m.unit_component) <> 
+        dimensional_exponents(2.0, 0.0, -2.0, 0.0, 0.0, 0.0, 0.0) THEN
+        RETURN (FALSE);
+      END_IF;
+    END_IF;
+    RETURN (TRUE);
+END_FUNCTION;
+
+FUNCTION valid_wireframe_edge_curve
+	(crv: curve) : BOOLEAN;
+IF SIZEOF ([ 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.LINE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CONIC', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.B_SPLINE_CURVE', 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POLYLINE' ] * TYPEOF (crv)) = 1 THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CURVE_REPLICA' IN TYPEOF (crv) THEN 
+ RETURN (valid_wireframe_edge_curve(crv\curve_replica.parent_curve));
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.OFFSET_CURVE_3D' IN TYPEOF (crv) THEN 
+ RETURN (valid_wireframe_edge_curve(crv\offset_curve_3d.basis_curve));
+ END_IF ;
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION valid_wireframe_vertex_point
+	(pnt: point) : BOOLEAN;
+IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT' IN TYPEOF (pnt) THEN 
+ RETURN (TRUE);
+ ELSE 
+ IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_REPLICA' IN TYPEOF (pnt) THEN 
+ RETURN (valid_wireframe_vertex_point(pnt\point_replica.parent_pt));
+ END_IF ;
+ END_IF ;
+ RETURN (FALSE);
+END_FUNCTION;
+
+FUNCTION validate_countersink_radii
+	(cskhole: solid_with_stepped_round_hole_and_conical_transitions) : BOOLEAN;
+  LOCAL
+    i,j             : INTEGER;
+    n               : INTEGER := 1 +
+                        cskhole\solid_with_stepped_round_hole.segments;
+    smaller, larger : positive_length_measure;
+  END_LOCAL;
+
+  REPEAT i := 1 TO SIZEOF(cskhole.conical_transitions);
+
+  -- First check whether transition i applies to the entry of the hole or 
+  -- the exit of a through hole - those cases only need to be checked for 
+  -- the sign of the cone apex angle.
+
+  IF (((cskhole.conical_transitions[i].transition_number = 1)
+       AND (cskhole.conical_transitions[i].cone_apex_angle < 0))
+    XOR ((cskhole.conical_transitions[i].transition_number = n)
+         AND (cskhole.conical_transitions[i].cone_apex_angle > 0))) 
+  THEN RETURN(FALSE); 
+  ELSE
+    IF ((cskhole.conical_transitions[i].transition_number <> 1)
+      AND (cskhole.conical_transitions[i].transition_number <> n))
+    THEN
+
+  -- For all remaining transitions, check that the cone base radius 
+  -- lies in the range of validity.
+
+
+      BEGIN
+        j := cskhole.conical_transitions[i].transition_number;
+        IF cskhole\solid_with_stepped_round_hole.segment_radii[j] 
+          > cskhole\solid_with_stepped_round_hole.segment_radii[j-1]
+        THEN 
+          BEGIN
+            IF (cskhole.conical_transitions[i].cone_apex_angle > 0)
+            THEN RETURN(FALSE);
+            END_IF;
+            larger 
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j];
+            smaller 
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j-1];
+          END;
+        ELSE
+          BEGIN
+            IF (cskhole.conical_transitions[i].cone_apex_angle < 0)
+            THEN RETURN(FALSE);
+            END_IF;
+            larger  
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j-1];
+            smaller 
+              := cskhole\solid_with_stepped_round_hole.segment_radii[j];
+          END;
+        END_IF; 
+        IF ((cskhole.conical_transitions[i].cone_base_radius > larger)
+          OR (cskhole.conical_transitions[i].cone_base_radius < smaller))
+        THEN RETURN(FALSE);
+        END_IF;
+      END;
+    END_IF;
+  END_IF;
+  END_REPEAT;
+  RETURN(TRUE);
+END_FUNCTION;
+
+FUNCTION value_range_aggregate_rep_item
+	(agg: AGGREGATE OF representation_item) : BOOLEAN;
+BEGIN 
+  IF (SIZEOF(QUERY(i1 <* agg | ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.' + 'MEASURE_REPRESENTATION_ITEM' IN TYPEOF(i1)) )) = 6) THEN 
+	  RETURN (TRUE); 
+   ELSE 
+	RETURN (FALSE); 
+   END_IF; 
+   END;
+END_FUNCTION;
+
+FUNCTION value_range_wr1
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN
+      IF (SIZEOF(agg) = 2) AND ((SIZEOF(QUERY (i1 <* agg | (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF
+        (i1)))) = 2) OR
+        (SIZEOF(QUERY (i2 <* agg | (
+        'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VALUE_REPRESENTATION_ITEM' IN TYPEOF
+        (i2)))) = 2)) 
+      THEN
+        RETURN(TRUE);
+      ELSE
+        RETURN(FALSE);
+      END_IF;
+    END;
+END_FUNCTION;
+
+FUNCTION value_range_wr2
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN
+      IF ((SIZEOF(QUERY (i <* agg | (i\representation_item.name = 'upper limit'))) = 1)
+        AND (SIZEOF(QUERY (i <* agg | (i\representation_item.name = 'lower limit'))) = 1))
+      THEN
+        RETURN(TRUE);
+      ELSE
+        RETURN(FALSE);
+      END_IF;
+    END;
+END_FUNCTION;
+
+FUNCTION value_range_wr3
+	(agg: compound_item_definition) : BOOLEAN;
+BEGIN
+      IF (SIZEOF(QUERY(i1 <* agg |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF (i1)) AND
+        (SIZEOF (QUERY (i2 <* agg |
+        ('AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.MEASURE_REPRESENTATION_ITEM' IN TYPEOF (i2)) AND
+        (i1 :<>: i2) AND (i1\measure_with_unit.unit_component :=: i2\measure_with_unit.unit_component))) = 1))) = 2)
+      THEN
+        RETURN (TRUE);
+      ELSE
+        RETURN (FALSE);
+      END_IF;
+    END;
+END_FUNCTION;
+
+FUNCTION vector_difference
+	(arg1: vector_or_direction; arg2: vector_or_direction) : vector;
+    LOCAL
+      result          : vector;
+      res, vec1, vec2 : direction;
+      mag, mag1, mag2 : REAL;
+      ndim            : INTEGER;
+    END_LOCAL;
+ 
+    IF ((NOT EXISTS (arg1)) OR (NOT EXISTS (arg2))) OR (arg1.dim <> arg2.dim)
+        THEN
+      RETURN (?) ;
+     ELSE
+      BEGIN
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg1) THEN
+          mag1 := arg1.magnitude;
+          vec1 := arg1\vector.orientation;
+        ELSE
+          mag1 := 1.0;
+          vec1 := arg1;
+        END_IF;
+        IF 'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.VECTOR' IN TYPEOF(arg2) THEN
+          mag2 := arg2.magnitude;
+          vec2 := arg2\vector.orientation;
+        ELSE
+          mag2 := 1.0;
+          vec2 := arg2;
+        END_IF;
+        vec1 := normalise (vec1);
+        vec2 := normalise (vec2);
+        ndim := SIZEOF(vec1.direction_ratios);
+        mag := 0.0;
+        res := dummy_gri || direction(vec1.direction_ratios);
+        REPEAT i := 1 TO ndim;
+          res.direction_ratios[i] := mag1*vec1.direction_ratios[i] -
+                                      mag2*vec2.direction_ratios[i];
+          mag := mag + (res.direction_ratios[i]*res.direction_ratios[i]);
+        END_REPEAT;
+        IF (mag > 0.0 ) THEN
+        result := dummy_gri || vector( res, SQRT(mag));
+        ELSE
+          result := dummy_gri || vector( vec1,  0.0);
+        END_IF;
+      END;
+    END_IF;
+    RETURN (result);
+END_FUNCTION;
+
+END_SCHEMA; 
+
diff --git a/scripts/StepImporter/step_entitylist.txt b/scripts/StepImporter/step_entitylist.txt
new file mode 100644
index 000000000..223f57a61
--- /dev/null
+++ b/scripts/StepImporter/step_entitylist.txt
@@ -0,0 +1,1015 @@
+# ==============================================================================
+# List of IFC structures needed by Assimp
+# ==============================================================================
+# use genentitylist.sh to update this list
+
+# This machine-generated list is not complete, it lacks many intermediate
+# classes in the inheritance hierarchy. Those are magically augmented by the
+# code generator. Also, the names of all used entities need to be present
+# in the source code for this to work.
+absorbed_dose_measure_with_unit
+absorbed_dose_unit
+abstract_variable
+acceleration_measure_with_unit
+acceleration_unit
+action;
+action_assignment
+action_directive;
+action_method;
+action_method_assignment
+action_method_relationship;
+action_method_role;
+action_property;
+action_property_representation;
+action_relationship;
+action_request_assignment
+action_request_solution;
+action_request_status;
+action_status;
+address;
+advanced_brep_shape_representation
+advanced_face
+alternate_product_relationship;
+amount_of_substance_measure_with_unit
+amount_of_substance_unit
+angle_direction_reference
+angular_dimension
+angular_location
+angular_size
+angularity_tolerance
+annotation_curve_occurrence
+annotation_fill_area
+annotation_fill_area_occurrence
+annotation_occurrence
+annotation_occurrence_associativity
+annotation_occurrence_relationship;
+annotation_plane
+annotation_subfigure_occurrence
+annotation_symbol
+annotation_symbol_occurrence
+annotation_text
+annotation_text_character
+annotation_text_occurrence
+apex
+application_context;
+application_context_element
+application_protocol_definition;
+applied_action_assignment
+applied_action_method_assignment
+applied_action_request_assignment
+applied_approval_assignment
+applied_attribute_classification_assignment
+applied_certification_assignment
+applied_classification_assignment
+applied_contract_assignment
+applied_date_and_time_assignment
+applied_date_assignment
+applied_document_reference
+applied_document_usage_constraint_assignment
+applied_effectivity_assignment
+applied_event_occurrence_assignment
+applied_external_identification_assignment
+applied_group_assignment
+applied_identification_assignment
+applied_name_assignment
+applied_organization_assignment
+applied_organizational_project_assignment
+applied_person_and_organization_assignment
+applied_presented_item
+applied_security_classification_assignment
+applied_time_interval_assignment
+applied_usage_right
+approval;
+approval_assignment
+approval_date_time;
+approval_person_organization;
+approval_relationship;
+approval_role;
+approval_status;
+area_in_set;
+area_measure_with_unit
+area_unit
+assembly_component_usage
+assembly_component_usage_substitute;
+assigned_requirement
+atomic_formula
+attribute_assertion
+attribute_classification_assignment
+attribute_language_assignment
+attribute_value_assignment
+attribute_value_role;
+auxiliary_geometric_representation_item
+axis1_placement
+axis2_placement_2d
+axis2_placement_3d
+b_spline_curve
+b_spline_curve_with_knots
+b_spline_surface
+b_spline_surface_with_knots
+back_chaining_rule
+back_chaining_rule_body
+background_colour
+beveled_sheet_representation
+bezier_curve
+bezier_surface
+binary_generic_expression
+binary_numeric_expression
+binary_representation_item
+block
+boolean_expression
+boolean_literal
+boolean_representation_item
+boolean_result
+boundary_curve
+bounded_curve
+bounded_pcurve
+bounded_surface
+bounded_surface_curve
+box_domain
+boxed_half_space
+breakdown_context
+breakdown_element_group_assignment
+breakdown_element_realization
+breakdown_element_usage
+breakdown_of
+brep_with_voids
+bytes_representation_item
+calendar_date
+camera_image
+camera_image_3d_with_scale
+camera_model
+camera_model_d3
+camera_model_d3_multi_clipping
+camera_model_d3_multi_clipping_intersection
+camera_model_d3_multi_clipping_union
+camera_model_d3_with_hlhsr
+camera_model_with_light_sources
+camera_usage
+capacitance_measure_with_unit
+capacitance_unit
+cartesian_point
+cartesian_transformation_operator
+cartesian_transformation_operator_2d
+cartesian_transformation_operator_3d
+cc_design_approval
+cc_design_certification
+cc_design_contract
+cc_design_date_and_time_assignment
+cc_design_person_and_organization_assignment
+cc_design_security_classification
+cc_design_specification_reference
+celsius_temperature_measure_with_unit
+centre_of_symmetry
+certification;
+certification_assignment
+certification_type;
+change
+change_request
+character_glyph_font_usage;
+character_glyph_style_outline
+character_glyph_style_stroke
+character_glyph_symbol
+character_glyph_symbol_outline
+character_glyph_symbol_stroke
+characteristic_data_column_header
+characteristic_data_column_header_link
+characteristic_data_table_header
+characteristic_data_table_header_decomposition
+characteristic_type
+characterized_class
+characterized_object;
+circle
+circular_runout_tolerance
+class
+class_by_extension
+class_by_intension
+class_system
+class_usage_effectivity_context_assignment
+classification_assignment
+classification_role;
+closed_shell
+coaxiality_tolerance
+colour;
+colour_rgb
+colour_specification
+common_datum
+comparison_expression
+complex_clause
+complex_conjunctive_clause
+complex_disjunctive_clause
+complex_shelled_solid
+composite_assembly_definition
+composite_assembly_sequence_definition
+composite_assembly_table
+composite_curve
+composite_curve_on_surface
+composite_curve_segment
+composite_material_designation
+composite_shape_aspect
+composite_sheet_representation
+composite_text
+composite_text_with_associated_curves
+composite_text_with_blanking_box
+composite_text_with_delineation
+composite_text_with_extent
+compound_representation_item
+compound_shape_representation
+concentricity_tolerance
+concept_feature_operator;
+concept_feature_relationship;
+concept_feature_relationship_with_condition
+conditional_concept_feature
+conductance_measure_with_unit
+conductance_unit
+configurable_item
+configuration_design;
+configuration_effectivity
+configuration_item;
+configuration_item_hierarchical_relationship
+configuration_item_relationship;
+configuration_item_revision_sequence
+configured_effectivity_assignment
+configured_effectivity_context_assignment
+conic
+conical_stepped_hole_transition
+conical_surface
+connected_edge_set
+connected_face_set
+connected_face_sub_set
+constructive_geometry_representation
+constructive_geometry_representation_relationship
+contact_ratio_representation
+context_dependent_invisibility
+context_dependent_over_riding_styled_item
+context_dependent_shape_representation;
+context_dependent_unit
+contract;
+contract_assignment
+contract_relationship;
+contract_type;
+conversion_based_unit
+coordinated_universal_time_offset;
+csg_shape_representation
+csg_solid
+currency
+currency_measure_with_unit
+curve
+curve_bounded_surface
+curve_dimension
+curve_replica
+curve_style
+curve_style_font
+curve_style_font_and_scaling
+curve_style_font_pattern
+curve_style_rendering;
+curve_swept_solid_shape_representation
+cylindrical_surface
+cylindricity_tolerance
+data_environment;
+date
+date_and_time;
+date_and_time_assignment
+date_assignment
+date_representation_item
+date_role;
+date_time_representation_item
+date_time_role;
+dated_effectivity
+datum
+datum_feature
+datum_feature_callout
+datum_reference;
+datum_target
+datum_target_callout
+default_tolerance_table
+default_tolerance_table_cell
+defined_symbol
+definitional_representation
+definitional_representation_relationship
+definitional_representation_relationship_with_same_context
+degenerate_pcurve
+degenerate_toroidal_surface
+derived_shape_aspect
+derived_unit
+derived_unit_element;
+description_attribute;
+descriptive_representation_item
+design_context
+design_make_from_relationship
+diameter_dimension
+dielectric_constant_measure_with_unit
+dimension_callout
+dimension_callout_component_relationship
+dimension_callout_relationship
+dimension_curve
+dimension_curve_directed_callout
+dimension_curve_terminator
+dimension_curve_terminator_to_projection_curve_associativity
+dimension_pair
+dimension_related_tolerance_zone_element;
+dimension_text_associativity
+dimensional_characteristic_representation;
+dimensional_exponents;
+dimensional_location
+dimensional_location_with_path
+dimensional_size
+dimensional_size_with_path
+directed_action
+directed_dimensional_location
+direction
+document;
+document_file
+document_identifier
+document_identifier_assignment
+document_product_association;
+document_product_equivalence
+document_reference
+document_relationship;
+document_representation_type;
+document_type;
+document_usage_constraint;
+document_usage_constraint_assignment
+document_usage_role;
+dose_equivalent_measure_with_unit
+dose_equivalent_unit
+double_offset_shelled_solid
+draped_defined_transformation
+draughting_annotation_occurrence
+draughting_callout
+draughting_callout_relationship;
+draughting_elements
+draughting_model
+draughting_model_item_association
+draughting_pre_defined_colour
+draughting_pre_defined_curve_font
+draughting_pre_defined_text_font
+draughting_subfigure_representation
+draughting_symbol_representation
+draughting_text_literal_with_delineation
+draughting_title;
+drawing_definition;
+drawing_revision
+drawing_revision_sequence;
+drawing_sheet_revision
+drawing_sheet_revision_sequence
+drawing_sheet_revision_usage
+edge
+edge_based_wireframe_model
+edge_based_wireframe_shape_representation
+edge_blended_solid
+edge_curve
+edge_loop
+effectivity
+effectivity_assignment
+effectivity_context_assignment
+effectivity_context_role;
+effectivity_relationship;
+electric_charge_measure_with_unit
+electric_charge_unit
+electric_current_measure_with_unit
+electric_current_unit
+electric_potential_measure_with_unit
+electric_potential_unit
+elementary_brep_shape_representation
+elementary_surface
+ellipse
+energy_measure_with_unit
+energy_unit
+entity_assertion
+enum_reference_prefix
+environment;
+evaluated_characteristic
+evaluated_degenerate_pcurve
+evaluation_product_definition
+event_occurrence;
+event_occurrence_assignment
+event_occurrence_relationship;
+event_occurrence_role;
+exclusive_product_concept_feature_category
+executed_action
+expanded_uncertainty
+explicit_procedural_geometric_representation_item_relationship
+explicit_procedural_representation_item_relationship
+explicit_procedural_representation_relationship
+explicit_procedural_shape_representation_relationship
+expression
+expression_conversion_based_unit
+extension
+extent
+external_class_library
+external_identification_assignment
+external_source;
+external_source_relationship;
+externally_defined_class
+externally_defined_colour
+externally_defined_context_dependent_unit
+externally_defined_conversion_based_unit
+externally_defined_currency
+externally_defined_curve_font
+externally_defined_dimension_definition
+externally_defined_general_property
+externally_defined_hatch_style
+externally_defined_item;
+externally_defined_item_relationship;
+externally_defined_marker
+externally_defined_picture_representation_item
+externally_defined_representation_item
+externally_defined_string
+externally_defined_symbol
+externally_defined_terminator_symbol
+externally_defined_text_font
+externally_defined_tile
+externally_defined_tile_style
+extruded_area_solid
+extruded_face_solid
+extruded_face_solid_with_draft_angle
+extruded_face_solid_with_multiple_draft_angles
+extruded_face_solid_with_trim_conditions
+face
+face_based_surface_model
+face_bound
+face_outer_bound
+face_surface
+faceted_brep
+faceted_brep_shape_representation
+fact_type
+fill_area_style
+fill_area_style_colour;
+fill_area_style_hatching
+fill_area_style_tile_coloured_region
+fill_area_style_tile_curve_with_style
+fill_area_style_tile_symbol_with_style
+fill_area_style_tiles
+flat_pattern_ply_representation_relationship
+flatness_tolerance
+force_measure_with_unit
+force_unit
+forward_chaining_rule
+forward_chaining_rule_premise
+founded_item
+frequency_measure_with_unit
+frequency_unit
+func
+functional_breakdown_context
+functional_element_usage
+functionally_defined_transformation;
+general_material_property
+general_property;
+general_property_association;
+general_property_relationship;
+generic_character_glyph_symbol
+generic_expression
+generic_literal
+generic_variable
+geometric_alignment
+geometric_curve_set
+geometric_intersection
+geometric_item_specific_usage
+geometric_model_element_relationship
+geometric_representation_context
+geometric_representation_item
+geometric_set
+geometric_tolerance;
+geometric_tolerance_relationship;
+geometric_tolerance_with_datum_reference
+geometric_tolerance_with_defined_unit
+geometrical_tolerance_callout
+geometrically_bounded_2d_wireframe_representation
+geometrically_bounded_surface_shape_representation
+geometrically_bounded_wireframe_shape_representation
+global_assignment
+global_uncertainty_assigned_context
+global_unit_assigned_context
+ground_fact
+group;
+group_assignment
+group_relationship;
+half_space_solid
+hardness_representation
+hidden_element_over_riding_styled_item
+hyperbola
+id_attribute;
+identification_assignment
+identification_role;
+illuminance_measure_with_unit
+illuminance_unit
+included_text_block
+inclusion_product_concept_feature
+indirectly_selected_elements
+indirectly_selected_shape_elements
+inductance_measure_with_unit
+inductance_unit
+information_right
+information_usage_right
+instance_usage_context_assignment
+instanced_feature
+int_literal
+integer_representation_item
+intersection_curve
+interval_expression
+invisibility;
+iso4217_currency
+item_defined_transformation;
+item_identified_representation_usage;
+known_source
+laid_defined_transformation
+laminate_table
+language
+leader_curve
+leader_directed_callout
+leader_directed_dimension
+leader_terminator
+length_measure_with_unit
+length_unit
+light_source
+light_source_ambient
+light_source_directional
+light_source_positional
+light_source_spot
+limits_and_fits;
+line
+line_profile_tolerance
+linear_dimension
+literal_conjunction
+literal_disjunction
+literal_number
+local_time;
+logical_literal
+logical_representation_item
+loop
+loss_tangent_measure_with_unit
+lot_effectivity
+luminous_flux_measure_with_unit
+luminous_flux_unit
+luminous_intensity_measure_with_unit
+luminous_intensity_unit
+magnetic_flux_density_measure_with_unit
+magnetic_flux_density_unit
+magnetic_flux_measure_with_unit
+magnetic_flux_unit
+make_from_usage_option
+manifold_solid_brep
+manifold_subsurface_shape_representation
+manifold_surface_shape_representation
+mapped_item
+mass_measure_with_unit
+mass_unit
+material_designation;
+material_designation_characterization;
+material_property
+material_property_representation
+measure_qualification;
+measure_representation_item
+measure_with_unit
+mechanical_context
+mechanical_design_and_draughting_relationship
+mechanical_design_geometric_presentation_area
+mechanical_design_geometric_presentation_representation
+mechanical_design_presentation_representation_with_draughting
+mechanical_design_shaded_presentation_area
+mechanical_design_shaded_presentation_representation
+min_and_major_ply_orientation_basis
+modified_geometric_tolerance
+modified_solid
+modified_solid_with_placed_configuration
+moments_of_inertia_representation
+multi_language_attribute_assignment
+multiple_arity_boolean_expression
+multiple_arity_generic_expression
+multiple_arity_numeric_expression
+name_assignment
+name_attribute;
+named_unit
+next_assembly_usage_occurrence
+non_manifold_surface_shape_representation
+null_representation_item
+numeric_expression
+object_role;
+offset_curve_2d
+offset_curve_3d
+offset_surface
+one_direction_repeat_factor
+open_shell
+ordinal_date
+ordinate_dimension
+organization;
+organization_assignment
+organization_relationship;
+organization_role;
+organizational_address
+organizational_project;
+organizational_project_assignment
+organizational_project_relationship;
+organizational_project_role;
+oriented_closed_shell
+oriented_edge
+oriented_face
+oriented_open_shell
+oriented_path
+oriented_surface
+outer_boundary_curve
+over_riding_styled_item
+package_product_concept_feature
+parabola
+parallel_offset
+parallelism_tolerance
+parametric_representation_context
+part_laminate_table
+partial_document_with_structured_text_representation_assignment
+path
+pcurve
+percentage_laminate_definition
+percentage_laminate_table
+percentage_ply_definition
+perpendicular_to
+perpendicularity_tolerance
+person;
+person_and_organization;
+person_and_organization_address
+person_and_organization_assignment
+person_and_organization_role;
+personal_address
+physical_breakdown_context
+physical_element_usage
+picture_representation
+picture_representation_item
+placed_datum_target_feature
+placed_feature
+placement
+planar_box
+planar_extent
+plane
+plane_angle_measure_with_unit
+plane_angle_unit
+plus_minus_tolerance;
+ply_laminate_definition
+ply_laminate_sequence_definition
+ply_laminate_table
+point
+point_and_vector
+point_on_curve
+point_on_surface
+point_path
+point_replica
+point_style
+polar_complex_number_literal
+poly_loop
+polyline
+position_tolerance
+positioned_sketch
+power_measure_with_unit
+power_unit
+pre_defined_colour
+pre_defined_curve_font
+pre_defined_dimension_symbol
+pre_defined_geometrical_tolerance_symbol
+pre_defined_item;
+pre_defined_marker
+pre_defined_point_marker_symbol
+pre_defined_surface_condition_symbol
+pre_defined_surface_side_style
+pre_defined_symbol
+pre_defined_terminator_symbol
+pre_defined_text_font
+pre_defined_tile
+precision_qualifier;
+predefined_picture_representation_item
+presentation_area
+presentation_layer_assignment;
+presentation_representation
+presentation_set;
+presentation_size;
+presentation_style_assignment
+presentation_style_by_context
+presentation_view
+presented_item
+presented_item_representation;
+pressure_measure_with_unit
+pressure_unit
+procedural_representation
+procedural_representation_sequence
+procedural_shape_representation
+procedural_shape_representation_sequence
+product;
+product_category;
+product_class
+product_concept;
+product_concept_context
+product_concept_feature;
+product_concept_feature_association;
+product_concept_feature_category
+product_concept_feature_category_usage
+product_concept_relationship;
+product_context
+product_definition
+product_definition_context
+product_definition_context_association;
+product_definition_context_role;
+product_definition_effectivity
+product_definition_element_relationship
+product_definition_formation;
+product_definition_formation_relationship;
+product_definition_formation_with_specified_source
+product_definition_group_assignment
+product_definition_occurrence_relationship;
+product_definition_relationship;
+product_definition_shape
+product_definition_substitute;
+product_definition_usage
+product_definition_with_associated_documents
+product_identification
+product_material_composition_relationship
+product_related_product_category
+product_specification
+projected_zone_definition
+projection_curve
+projection_directed_callout
+promissory_usage_occurrence
+property_definition;
+property_definition_relationship;
+property_definition_representation;
+qualified_representation_item
+qualitative_uncertainty
+quantified_assembly_component_usage
+quasi_uniform_curve
+quasi_uniform_surface
+radioactivity_measure_with_unit
+radioactivity_unit
+radius_dimension
+range_characteristic
+ratio_measure_with_unit
+ratio_unit
+rational_b_spline_curve
+rational_b_spline_surface
+rational_representation_item
+real_literal
+real_representation_item
+rectangular_composite_surface
+rectangular_trimmed_surface
+referenced_modified_datum
+relative_event_occurrence
+rep_item_group
+reparametrised_composite_curve_segment
+representation;
+representation_context;
+representation_item
+representation_item_relationship;
+representation_map;
+representation_relationship;
+representation_relationship_with_transformation
+requirement_assigned_object
+requirement_assignment
+requirement_source
+requirement_view_definition_relationship
+resistance_measure_with_unit
+resistance_unit
+revolved_area_solid
+revolved_face_solid
+revolved_face_solid_with_trim_conditions
+right_angular_wedge
+right_circular_cone
+right_circular_cylinder
+right_to_usage_association
+role_association;
+roundness_tolerance
+row_representation_item
+row_value
+row_variable
+rule_action
+rule_condition
+rule_definition
+rule_set
+rule_set_group
+rule_software_definition
+rule_superseded_assignment
+rule_supersedence
+ruled_surface_swept_area_solid
+runout_zone_definition
+runout_zone_orientation;
+runout_zone_orientation_reference_direction
+satisfied_requirement
+satisfies_requirement
+satisfying_item
+scalar_variable
+scattering_parameter
+sculptured_solid
+seam_curve
+security_classification;
+security_classification_assignment
+security_classification_level;
+serial_numbered_effectivity
+shape_aspect;
+shape_aspect_associativity
+shape_aspect_deriving_relationship
+shape_aspect_relationship;
+shape_definition_representation
+shape_dimension_representation
+shape_feature_definition
+shape_representation
+shape_representation_relationship
+shape_representation_with_parameters
+shell_based_surface_model
+shell_based_wireframe_model
+shell_based_wireframe_shape_representation
+shelled_solid
+si_absorbed_dose_unit
+si_capacitance_unit
+si_conductance_unit
+si_dose_equivalent_unit
+si_electric_charge_unit
+si_electric_potential_unit
+si_energy_unit
+si_force_unit
+si_frequency_unit
+si_illuminance_unit
+si_inductance_unit
+si_magnetic_flux_density_unit
+si_magnetic_flux_unit
+si_power_unit
+si_pressure_unit
+si_radioactivity_unit
+si_resistance_unit
+si_unit
+simple_boolean_expression
+simple_clause
+simple_generic_expression
+simple_numeric_expression
+slash_expression
+smeared_material_definition
+solid_angle_measure_with_unit
+solid_angle_unit
+solid_curve_font
+solid_model
+solid_replica
+solid_with_angle_based_chamfer
+solid_with_chamfered_edges
+solid_with_circular_pattern
+solid_with_circular_pocket
+solid_with_circular_protrusion
+solid_with_conical_bottom_round_hole
+solid_with_constant_radius_edge_blend
+solid_with_curved_slot
+solid_with_depression
+solid_with_double_offset_chamfer
+solid_with_flat_bottom_round_hole
+solid_with_general_pocket
+solid_with_general_protrusion
+solid_with_groove
+solid_with_hole
+solid_with_incomplete_circular_pattern
+solid_with_incomplete_rectangular_pattern
+solid_with_pocket
+solid_with_protrusion
+solid_with_rectangular_pattern
+solid_with_rectangular_pocket
+solid_with_rectangular_protrusion
+solid_with_shape_element_pattern
+solid_with_single_offset_chamfer
+solid_with_slot
+solid_with_spherical_bottom_round_hole
+solid_with_stepped_round_hole
+solid_with_stepped_round_hole_and_conical_transitions
+solid_with_straight_slot
+solid_with_tee_section_slot
+solid_with_through_depression
+solid_with_trapezoidal_section_slot
+solid_with_variable_radius_edge_blend
+source_for_requirement
+sourced_requirement
+specification_definition
+specified_higher_usage_occurrence
+sphere
+spherical_surface
+standard_uncertainty
+start_request
+start_work
+straightness_tolerance
+structured_dimension_callout
+structured_text_composition
+structured_text_representation
+styled_item
+subedge
+subface
+supplied_part_relationship
+surface
+surface_condition_callout
+surface_curve
+surface_curve_swept_area_solid
+surface_of_linear_extrusion
+surface_of_revolution
+surface_patch
+surface_profile_tolerance
+surface_rendering_properties;
+surface_replica
+surface_side_style
+surface_style_boundary
+surface_style_control_grid
+surface_style_fill_area
+surface_style_parameter_line
+surface_style_reflectance_ambient;
+surface_style_reflectance_ambient_diffuse
+surface_style_reflectance_ambient_diffuse_specular
+surface_style_rendering;
+surface_style_rendering_with_properties
+surface_style_segmentation_curve
+surface_style_silhouette
+surface_style_transparent;
+surface_style_usage
+surface_texture_representation
+surfaced_open_shell
+swept_area_solid
+swept_disk_solid
+swept_face_solid
+swept_surface
+symbol
+symbol_colour;
+symbol_representation
+symbol_representation_map
+symbol_style
+symbol_target
+symmetric_shape_aspect
+symmetry_tolerance
+table_representation_item
+tactile_appearance_representation
+tagged_text_format
+tagged_text_item
+tangent
+terminator_symbol
+text_font;
+text_font_family;
+text_font_in_family;
+text_literal
+text_literal_with_associated_curves
+text_literal_with_blanking_box
+text_literal_with_delineation
+text_literal_with_extent
+text_string_representation
+text_style
+text_style_for_defined_font;
+text_style_with_box_characteristics
+text_style_with_mirror
+text_style_with_spacing
+thermal_resistance_measure_with_unit
+thermal_resistance_unit
+thermodynamic_temperature_measure_with_unit
+thermodynamic_temperature_unit
+thickened_face_solid
+thickness_laminate_definition
+thickness_laminate_table
+time_interval;
+time_interval_assignment
+time_interval_based_effectivity
+time_interval_relationship;
+time_interval_role;
+time_interval_with_bounds
+time_measure_with_unit
+time_unit
+tolerance_value;
+tolerance_zone
+tolerance_zone_definition
+tolerance_zone_form;
+topological_representation_item
+toroidal_surface
+torus
+total_runout_tolerance
+track_blended_solid
+track_blended_solid_with_end_conditions
+transformation_with_derived_angle
+trimmed_curve
+two_direction_repeat_factor
+type_qualifier;
+unary_generic_expression
+unary_numeric_expression
+uncertainty_assigned_representation
+uncertainty_measure_with_unit
+uncertainty_qualifier
+uniform_curve
+uniform_resource_identifier
+uniform_surface
+usage_association
+user_defined_curve_font
+user_defined_marker
+user_defined_terminator_symbol
+user_selected_elements
+user_selected_shape_elements
+value_range
+value_representation_item
+variable_semantics
+variational_representation_item
+vector
+vector_style
+velocity_measure_with_unit
+velocity_unit
+versioned_action_request;
+vertex
+vertex_loop
+vertex_point
+vertex_shell
+view_volume
+visual_appearance_representation
+volume_measure_with_unit
+volume_unit
+week_of_year_and_day_date
+wire_shell
+year_month
+zone_structural_makeup
diff --git a/test/unit/utglTF2ImportExport.cpp b/test/unit/utglTF2ImportExport.cpp
index ebf97a5eb..264580aad 100644
--- a/test/unit/utglTF2ImportExport.cpp
+++ b/test/unit/utglTF2ImportExport.cpp
@@ -347,6 +347,34 @@ TEST_F(utglTF2ImportExport, importglTF2PrimitiveModeTrianglesFan) {
     }
 }
 
+std::vector<char> ReadFile(const char* name) {
+    std::vector<char> ret;
+
+    FILE* p = ::fopen(name, "r");
+    if (nullptr == p) {
+        return ret;
+    }
+
+    ::fseek(p, 0, SEEK_END);
+    const auto size = ::ftell(p);
+    ::fseek(p, 0, SEEK_SET);
+
+    ret.resize(size);
+    ::fread(&ret[0], 1, size, p);
+    ::fclose(p);
+
+    return ret;
+}
+
+TEST_F(utglTF2ImportExport, importglTF2FromMemory) {
+    /*const auto flags = aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_RemoveComponent |
+        aiProcess_GenSmoothNormals | aiProcess_PreTransformVertices | aiProcess_FixInfacingNormals |
+        aiProcess_FindDegenerates | aiProcess_GenUVCoords | aiProcess_SortByPType;
+    const auto& buff = ReadFile("C:\\Users\\kimkulling\\Downloads\\camel\\camel\\scene.gltf");*/
+    /*const aiScene* Scene = ::aiImportFileFromMemory(&buff[0], buff.size(), flags, ".gltf");
+    EXPECT_EQ( nullptr, Scene );*/
+}
+
 #ifndef ASSIMP_BUILD_NO_EXPORT
 TEST_F( utglTF2ImportExport, exportglTF2FromFileTest ) {
     EXPECT_TRUE( exporterTest() );