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