assimp/code/Importer/IFC/IFCReaderGen_4.h

/*
Open Asset Import Library (ASSIMP)
----------------------------------------------------------------------

Copyright (c) 2006-2010, ASSIMP Development Team
All rights reserved.

Redistribution and use of this software in source and binary forms, 
with or without modification, are permitted provided that the 
following conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the ASSIMP team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the ASSIMP Development Team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

----------------------------------------------------------------------
*/

/** 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 {
	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

} //! STEP
} //! Assimp

#endif // INCLUDED_IFC_READER_GEN_H