assimp.assimp/code/Importer/StepFile/StepReaderGen.cpp

/*
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;
}
// -----------------------------------------------------------------------------------------------------------
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;
}
// -----------------------------------------------------------------------------------------------------------
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;
}

} // ! STEP
} // ! Assimp

#endif