diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h')
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h | 4380 |
1 files changed, 4380 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h new file mode 100644 index 0000000..f87f121 --- /dev/null +++ b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h @@ -0,0 +1,4380 @@ +/* +Open Asset Import Library (ASSIMP) +---------------------------------------------------------------------- + +Copyright (c) 2006-2020, ASSIMP Development Team +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the +following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the ASSIMP team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the ASSIMP Development Team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---------------------------------------------------------------------- +*/ + +/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */ + +#ifndef INCLUDED_IFC_READER_GEN_H +#define INCLUDED_IFC_READER_GEN_H + +#include "AssetLib/Step/STEPFile.h" + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning( disable : 4512 ) +#endif // _MSC_VER + +namespace Assimp { +namespace IFC { + namespace Schema_2x3 { + + using namespace STEP; + using namespace STEP::EXPRESS; + + + struct NotImplemented : public ObjectHelper<NotImplemented,0> { + + }; + + + // ****************************************************************************** + // IFC Custom data types + // ****************************************************************************** + + + // 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 IfcAreaMeasure + typedef REAL IfcAreaMeasure; + // C++ wrapper type for IfcBoolean + typedef BOOLEAN IfcBoolean; + // C++ wrapper type for IfcBoxAlignment + typedef STRING IfcBoxAlignment; + // C++ wrapper type for IfcCompoundPlaneAngleMeasure + typedef ListOf< INTEGER, 3, 3 > 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 IfcDayInMonthNumber + typedef INTEGER IfcDayInMonthNumber; + // C++ wrapper type for IfcDaylightSavingHour + typedef INTEGER IfcDaylightSavingHour; + // 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 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 IfcHourInDay + typedef INTEGER IfcHourInDay; + // 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 IfcLengthMeasure + typedef REAL IfcLengthMeasure; + // 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 IfcMinuteInHour + typedef INTEGER IfcMinuteInHour; + // 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 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 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 IfcSecondInMinute + typedef REAL IfcSecondInMinute; + // 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 IfcSoundPowerMeasure + typedef REAL IfcSoundPowerMeasure; + // 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 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 IfcTimeMeasure + typedef REAL IfcTimeMeasure; + // C++ wrapper type for IfcTimeStamp + typedef INTEGER IfcTimeStamp; + // C++ wrapper type for IfcTorqueMeasure + typedef REAL IfcTorqueMeasure; + // 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 IfcYearNumber + typedef INTEGER IfcYearNumber; + // 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 IfcAheadOrBehind + typedef ENUMERATION IfcAheadOrBehind; + // 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 IfcBSplineCurveForm + typedef ENUMERATION IfcBSplineCurveForm; + // 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 IfcBuildingElementProxyTypeEnum + typedef ENUMERATION IfcBuildingElementProxyTypeEnum; + // C++ wrapper type for IfcCableCarrierFittingTypeEnum + typedef ENUMERATION IfcCableCarrierFittingTypeEnum; + // C++ wrapper type for IfcCableCarrierSegmentTypeEnum + typedef ENUMERATION IfcCableCarrierSegmentTypeEnum; + // 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 IfcCoilTypeEnum + typedef ENUMERATION IfcCoilTypeEnum; + // C++ wrapper type for IfcColumnTypeEnum + typedef ENUMERATION IfcColumnTypeEnum; + // 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 IfcControllerTypeEnum + typedef ENUMERATION IfcControllerTypeEnum; + // C++ wrapper type for IfcCooledBeamTypeEnum + typedef ENUMERATION IfcCooledBeamTypeEnum; + // C++ wrapper type for IfcCoolingTowerTypeEnum + typedef ENUMERATION IfcCoolingTowerTypeEnum; + // C++ wrapper type for IfcCostScheduleTypeEnum + typedef ENUMERATION IfcCostScheduleTypeEnum; + // C++ wrapper type for IfcCoveringTypeEnum + typedef ENUMERATION IfcCoveringTypeEnum; + // C++ wrapper type for IfcCurrencyEnum + typedef ENUMERATION IfcCurrencyEnum; + // C++ wrapper type for IfcCurtainWallTypeEnum + typedef ENUMERATION IfcCurtainWallTypeEnum; + // 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 IfcDimensionExtentUsage + typedef ENUMERATION IfcDimensionExtentUsage; + // C++ wrapper type for IfcDirectionSenseEnum + typedef ENUMERATION IfcDirectionSenseEnum; + // C++ wrapper type for IfcDistributionChamberElementTypeEnum + typedef ENUMERATION IfcDistributionChamberElementTypeEnum; + // 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 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 IfcElectricCurrentEnum + typedef ENUMERATION IfcElectricCurrentEnum; + // C++ wrapper type for IfcElectricDistributionPointFunctionEnum + typedef ENUMERATION IfcElectricDistributionPointFunctionEnum; + // C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum + typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum; + // C++ wrapper type for IfcElectricGeneratorTypeEnum + typedef ENUMERATION IfcElectricGeneratorTypeEnum; + // C++ wrapper type for IfcElectricHeaterTypeEnum + typedef ENUMERATION IfcElectricHeaterTypeEnum; + // 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 IfcEnergySequenceEnum + typedef ENUMERATION IfcEnergySequenceEnum; + // C++ wrapper type for IfcEnvironmentalImpactCategoryEnum + typedef ENUMERATION IfcEnvironmentalImpactCategoryEnum; + // C++ wrapper type for IfcEvaporativeCoolerTypeEnum + typedef ENUMERATION IfcEvaporativeCoolerTypeEnum; + // C++ wrapper type for IfcEvaporatorTypeEnum + typedef ENUMERATION IfcEvaporatorTypeEnum; + // C++ wrapper type for IfcFanTypeEnum + typedef ENUMERATION IfcFanTypeEnum; + // 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 IfcGasTerminalTypeEnum + typedef ENUMERATION IfcGasTerminalTypeEnum; + // C++ wrapper type for IfcGeometricProjectionEnum + typedef ENUMERATION IfcGeometricProjectionEnum; + // C++ wrapper type for IfcGlobalOrLocalEnum + typedef ENUMERATION IfcGlobalOrLocalEnum; + // C++ wrapper type for IfcHeatExchangerTypeEnum + typedef ENUMERATION IfcHeatExchangerTypeEnum; + // C++ wrapper type for IfcHumidifierTypeEnum + typedef ENUMERATION IfcHumidifierTypeEnum; + // 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 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 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 IfcOutletTypeEnum + typedef ENUMERATION IfcOutletTypeEnum; + // C++ wrapper type for IfcPermeableCoveringOperationEnum + typedef ENUMERATION IfcPermeableCoveringOperationEnum; + // 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 IfcProcedureTypeEnum + typedef ENUMERATION IfcProcedureTypeEnum; + // C++ wrapper type for IfcProfileTypeEnum + typedef ENUMERATION IfcProfileTypeEnum; + // C++ wrapper type for IfcProjectOrderRecordTypeEnum + typedef ENUMERATION IfcProjectOrderRecordTypeEnum; + // C++ wrapper type for IfcProjectOrderTypeEnum + typedef ENUMERATION IfcProjectOrderTypeEnum; + // C++ wrapper type for IfcProjectedOrTrueLengthEnum + typedef ENUMERATION IfcProjectedOrTrueLengthEnum; + // C++ wrapper type for IfcPropertySourceEnum + typedef ENUMERATION IfcPropertySourceEnum; + // 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 IfcReflectanceMethodEnum + typedef ENUMERATION IfcReflectanceMethodEnum; + // C++ wrapper type for IfcReinforcingBarRoleEnum + typedef ENUMERATION IfcReinforcingBarRoleEnum; + // C++ wrapper type for IfcReinforcingBarSurfaceEnum + typedef ENUMERATION IfcReinforcingBarSurfaceEnum; + // C++ wrapper type for IfcResourceConsumptionEnum + typedef ENUMERATION IfcResourceConsumptionEnum; + // C++ wrapper type for IfcRibPlateDirectionEnum + typedef ENUMERATION IfcRibPlateDirectionEnum; + // 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 IfcServiceLifeFactorTypeEnum + typedef ENUMERATION IfcServiceLifeFactorTypeEnum; + // C++ wrapper type for IfcServiceLifeTypeEnum + typedef ENUMERATION IfcServiceLifeTypeEnum; + // C++ wrapper type for IfcSlabTypeEnum + typedef ENUMERATION IfcSlabTypeEnum; + // C++ wrapper type for IfcSoundScaleEnum + typedef ENUMERATION IfcSoundScaleEnum; + // C++ wrapper type for IfcSpaceHeaterTypeEnum + typedef ENUMERATION IfcSpaceHeaterTypeEnum; + // C++ wrapper type for IfcSpaceTypeEnum + typedef ENUMERATION IfcSpaceTypeEnum; + // 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 IfcStructuralCurveTypeEnum + typedef ENUMERATION IfcStructuralCurveTypeEnum; + // C++ wrapper type for IfcStructuralSurfaceTypeEnum + typedef ENUMERATION IfcStructuralSurfaceTypeEnum; + // C++ wrapper type for IfcSurfaceSide + typedef ENUMERATION IfcSurfaceSide; + // C++ wrapper type for IfcSurfaceTextureEnum + typedef ENUMERATION IfcSurfaceTextureEnum; + // C++ wrapper type for IfcSwitchingDeviceTypeEnum + typedef ENUMERATION IfcSwitchingDeviceTypeEnum; + // C++ wrapper type for IfcTankTypeEnum + typedef ENUMERATION IfcTankTypeEnum; + // C++ wrapper type for IfcTendonTypeEnum + typedef ENUMERATION IfcTendonTypeEnum; + // C++ wrapper type for IfcTextPath + typedef ENUMERATION IfcTextPath; + // C++ wrapper type for IfcThermalLoadSourceEnum + typedef ENUMERATION IfcThermalLoadSourceEnum; + // C++ wrapper type for IfcThermalLoadTypeEnum + typedef ENUMERATION IfcThermalLoadTypeEnum; + // C++ wrapper type for IfcTimeSeriesDataTypeEnum + typedef ENUMERATION IfcTimeSeriesDataTypeEnum; + // C++ wrapper type for IfcTimeSeriesScheduleTypeEnum + typedef ENUMERATION IfcTimeSeriesScheduleTypeEnum; + // 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 IfcUnitaryEquipmentTypeEnum + typedef ENUMERATION IfcUnitaryEquipmentTypeEnum; + // C++ wrapper type for IfcValveTypeEnum + typedef ENUMERATION IfcValveTypeEnum; + // C++ wrapper type for IfcVibrationIsolatorTypeEnum + typedef ENUMERATION IfcVibrationIsolatorTypeEnum; + // 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 IfcWorkControlTypeEnum + typedef ENUMERATION IfcWorkControlTypeEnum; + // 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 IfcBooleanOperand + typedef SELECT IfcBooleanOperand; + // C++ wrapper type for IfcCharacterStyleSelect + typedef SELECT IfcCharacterStyleSelect; + // C++ wrapper type for IfcClassificationNotationSelect + typedef SELECT IfcClassificationNotationSelect; + // C++ wrapper type for IfcColour + typedef SELECT IfcColour; + // C++ wrapper type for IfcColourOrFactor + typedef SELECT IfcColourOrFactor; + // C++ wrapper type for IfcConditionCriterionSelect + typedef SELECT IfcConditionCriterionSelect; + // C++ wrapper type for IfcCsgSelect + typedef SELECT IfcCsgSelect; + // C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect + typedef SELECT IfcCurveFontOrScaledCurveFontSelect; + // C++ wrapper type for IfcCurveOrEdgeCurve + typedef SELECT IfcCurveOrEdgeCurve; + // C++ wrapper type for IfcCurveStyleFontSelect + typedef SELECT IfcCurveStyleFontSelect; + // C++ wrapper type for IfcDateTimeSelect + typedef SELECT IfcDateTimeSelect; + // C++ wrapper type for IfcDefinedSymbolSelect + typedef SELECT IfcDefinedSymbolSelect; + // C++ wrapper type for IfcDerivedMeasureValue + typedef SELECT IfcDerivedMeasureValue; + // C++ wrapper type for IfcDocumentSelect + typedef SELECT IfcDocumentSelect; + // C++ wrapper type for IfcDraughtingCalloutElement + typedef SELECT IfcDraughtingCalloutElement; + // C++ wrapper type for IfcFillAreaStyleTileShapeSelect + typedef SELECT IfcFillAreaStyleTileShapeSelect; + // C++ wrapper type for IfcFillStyleSelect + typedef SELECT IfcFillStyleSelect; + // C++ wrapper type for IfcGeometricSetSelect + typedef SELECT IfcGeometricSetSelect; + // 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 IfcObjectReferenceSelect + typedef SELECT IfcObjectReferenceSelect; + // C++ wrapper type for IfcOrientationSelect + typedef SELECT IfcOrientationSelect; + // C++ wrapper type for IfcPointOrVertexPoint + typedef SELECT IfcPointOrVertexPoint; + // C++ wrapper type for IfcPresentationStyleSelect + typedef SELECT IfcPresentationStyleSelect; + // 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 IfcSpecularHighlightSelect + typedef SELECT IfcSpecularHighlightSelect; + // C++ wrapper type for IfcStructuralActivityAssignmentSelect + typedef SELECT IfcStructuralActivityAssignmentSelect; + // C++ wrapper type for IfcSurfaceOrFaceSurface + typedef SELECT IfcSurfaceOrFaceSurface; + // C++ wrapper type for IfcSurfaceStyleElementSelect + typedef SELECT IfcSurfaceStyleElementSelect; + // C++ wrapper type for IfcSymbolStyleSelect + typedef SELECT IfcSymbolStyleSelect; + // C++ wrapper type for IfcTextFontSelect + typedef SELECT IfcTextFontSelect; + // C++ wrapper type for IfcTextStyleSelect + typedef SELECT IfcTextStyleSelect; + // 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; + + + // ****************************************************************************** + // IFC Entities + // ****************************************************************************** + + struct IfcRepresentationItem; + struct IfcGeometricRepresentationItem; + struct IfcCurve; + struct IfcBoundedCurve; + struct IfcCompositeCurve; + struct Ifc2DCompositeCurve; + struct IfcRoot; + struct IfcObjectDefinition; + struct IfcObject; + struct IfcControl; + struct IfcActionRequest; + struct IfcActor; + typedef NotImplemented IfcActorRole; // (not currently used by Assimp) + struct IfcTypeObject; + struct IfcTypeProduct; + struct IfcElementType; + struct IfcDistributionElementType; + struct IfcDistributionControlElementType; + struct IfcActuatorType; + typedef NotImplemented IfcAddress; // (not currently used by Assimp) + struct IfcDistributionFlowElementType; + struct IfcFlowControllerType; + struct IfcAirTerminalBoxType; + struct IfcFlowTerminalType; + struct IfcAirTerminalType; + struct IfcEnergyConversionDeviceType; + struct IfcAirToAirHeatRecoveryType; + struct IfcAlarmType; + struct IfcDraughtingCallout; + struct IfcDimensionCurveDirectedCallout; + struct IfcAngularDimension; + struct IfcProduct; + struct IfcAnnotation; + struct IfcStyledItem; + struct IfcAnnotationOccurrence; + struct IfcAnnotationCurveOccurrence; + struct IfcAnnotationFillArea; + struct IfcAnnotationFillAreaOccurrence; + struct IfcAnnotationSurface; + struct IfcAnnotationSurfaceOccurrence; + struct IfcAnnotationSymbolOccurrence; + struct IfcAnnotationTextOccurrence; + typedef NotImplemented IfcApplication; // (not currently used by Assimp) + typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp) + typedef NotImplemented IfcAppliedValueRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcApproval; // (not currently used by Assimp) + typedef NotImplemented IfcApprovalActorRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcApprovalPropertyRelationship; // (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 IfcIShapeProfileDef; + struct IfcAsymmetricIShapeProfileDef; + struct IfcPlacement; + struct IfcAxis1Placement; + struct IfcAxis2Placement2D; + struct IfcAxis2Placement3D; + struct IfcBSplineCurve; + struct IfcElement; + struct IfcBuildingElement; + struct IfcBeam; + struct IfcBuildingElementType; + struct IfcBeamType; + struct IfcBezierCurve; + typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp) + typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp) + struct IfcCsgPrimitive3D; + struct IfcBlock; + struct IfcBoilerType; + struct IfcBooleanResult; + struct IfcBooleanClippingResult; + typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp) + 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 IfcSurface; + struct IfcBoundedSurface; + struct IfcBoundingBox; + struct IfcHalfSpaceSolid; + struct IfcBoxedHalfSpace; + struct IfcSpatialStructureElement; + struct IfcBuilding; + struct IfcBuildingElementComponent; + struct IfcBuildingElementPart; + struct IfcBuildingElementProxy; + struct IfcBuildingElementProxyType; + struct IfcBuildingStorey; + struct IfcCShapeProfileDef; + struct IfcFlowFittingType; + struct IfcCableCarrierFittingType; + struct IfcFlowSegmentType; + struct IfcCableCarrierSegmentType; + struct IfcCableSegmentType; + typedef NotImplemented IfcCalendarDate; // (not currently used by Assimp) + struct IfcPoint; + struct IfcCartesianPoint; + struct IfcCartesianTransformationOperator; + struct IfcCartesianTransformationOperator2D; + struct IfcCartesianTransformationOperator2DnonUniform; + struct IfcCartesianTransformationOperator3D; + struct IfcCartesianTransformationOperator3DnonUniform; + struct IfcCenterLineProfileDef; + struct IfcFeatureElement; + struct IfcFeatureElementSubtraction; + struct IfcEdgeFeature; + struct IfcChamferEdgeFeature; + struct IfcChillerType; + struct IfcConic; + struct IfcCircle; + struct IfcCircleProfileDef; + struct IfcCircleHollowProfileDef; + typedef NotImplemented IfcClassification; // (not currently used by Assimp) + typedef NotImplemented IfcClassificationItem; // (not currently used by Assimp) + typedef NotImplemented IfcClassificationItemRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcClassificationNotation; // (not currently used by Assimp) + typedef NotImplemented IfcClassificationNotationFacet; // (not currently used by Assimp) + typedef NotImplemented IfcExternalReference; // (not currently used by Assimp) + typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp) + struct IfcTopologicalRepresentationItem; + struct IfcConnectedFaceSet; + struct IfcClosedShell; + struct IfcCoilType; + struct IfcColourSpecification; + struct IfcColourRgb; + struct IfcColumn; + struct IfcColumnType; + struct IfcProperty; + struct IfcComplexProperty; + struct IfcCompositeCurveSegment; + struct IfcCompositeProfileDef; + struct IfcFlowMovingDeviceType; + struct IfcCompressorType; + struct IfcCondenserType; + struct IfcCondition; + struct IfcConditionCriterion; + 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 IfcConnectionPortGeometry; // (not currently used by Assimp) + typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp) + typedef NotImplemented IfcConstraint; // (not currently used by Assimp) + typedef NotImplemented IfcConstraintAggregationRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcConstraintClassificationRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcConstraintRelationship; // (not currently used by Assimp) + struct IfcResource; + struct IfcConstructionResource; + struct IfcConstructionEquipmentResource; + struct IfcConstructionMaterialResource; + struct IfcConstructionProductResource; + struct IfcNamedUnit; + struct IfcContextDependentUnit; + struct IfcControllerType; + struct IfcConversionBasedUnit; + struct IfcCooledBeamType; + struct IfcCoolingTowerType; + typedef NotImplemented IfcCoordinatedUniversalTimeOffset; // (not currently used by Assimp) + struct IfcCostItem; + struct IfcCostSchedule; + typedef NotImplemented IfcCostValue; // (not currently used by Assimp) + struct IfcCovering; + struct IfcCoveringType; + struct IfcCraneRailAShapeProfileDef; + struct IfcCraneRailFShapeProfileDef; + struct IfcCrewResource; + struct IfcSolidModel; + struct IfcCsgSolid; + typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp) + struct IfcCurtainWall; + struct IfcCurtainWallType; + struct IfcCurveBoundedPlane; + 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 IfcDamperType; + typedef NotImplemented IfcDateAndTime; // (not currently used by Assimp) + struct IfcDefinedSymbol; + struct IfcDerivedProfileDef; + typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp) + typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp) + struct IfcDiameterDimension; + typedef NotImplemented IfcDraughtingCalloutRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcDimensionCalloutRelationship; // (not currently used by Assimp) + struct IfcDimensionCurve; + struct IfcTerminatorSymbol; + struct IfcDimensionCurveTerminator; + typedef NotImplemented IfcDimensionPair; // (not currently used by Assimp) + typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp) + struct IfcDirection; + struct IfcElementComponent; + struct IfcDiscreteAccessory; + struct IfcElementComponentType; + struct IfcDiscreteAccessoryType; + struct IfcDistributionElement; + struct IfcDistributionFlowElement; + struct IfcDistributionChamberElement; + struct IfcDistributionChamberElementType; + struct IfcDistributionControlElement; + struct IfcPort; + struct IfcDistributionPort; + typedef NotImplemented IfcDocumentElectronicFormat; // (not currently used by Assimp) + 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 IfcPropertyDefinition; + struct IfcPropertySetDefinition; + typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp) + typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp) + struct IfcDoorStyle; + 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) + typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp) + typedef NotImplemented IfcDraughtingPreDefinedTextFont; // (not currently used by Assimp) + struct IfcDuctFittingType; + struct IfcDuctSegmentType; + struct IfcFlowTreatmentDeviceType; + struct IfcDuctSilencerType; + struct IfcEdge; + struct IfcEdgeCurve; + struct IfcLoop; + struct IfcEdgeLoop; + struct IfcElectricApplianceType; + struct IfcFlowController; + struct IfcElectricDistributionPoint; + struct IfcFlowStorageDeviceType; + struct IfcElectricFlowStorageDeviceType; + struct IfcElectricGeneratorType; + struct IfcElectricHeaterType; + struct IfcElectricMotorType; + struct IfcElectricTimeControlType; + typedef NotImplemented IfcEnergyProperties; // (not currently used by Assimp) + typedef NotImplemented IfcElectricalBaseProperties; // (not currently used by Assimp) + struct IfcSystem; + struct IfcElectricalCircuit; + struct IfcElectricalElement; + struct IfcElementAssembly; + struct IfcElementQuantity; + struct IfcElementarySurface; + struct IfcEllipse; + struct IfcEllipseProfileDef; + struct IfcEnergyConversionDevice; + typedef NotImplemented IfcEnvironmentalImpactValue; // (not currently used by Assimp) + struct IfcEquipmentElement; + struct IfcEquipmentStandard; + struct IfcEvaporativeCoolerType; + struct IfcEvaporatorType; + typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp) + typedef NotImplemented IfcExtendedMaterialProperties; // (not currently used by Assimp) + typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp) + typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp) + typedef NotImplemented IfcExternallyDefinedSymbol; // (not currently used by Assimp) + typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp) + struct IfcSweptAreaSolid; + struct IfcExtrudedAreaSolid; + struct IfcFace; + struct IfcFaceBasedSurfaceModel; + struct IfcFaceBound; + struct IfcFaceOuterBound; + struct IfcFaceSurface; + struct IfcManifoldSolidBrep; + struct IfcFacetedBrep; + struct IfcFacetedBrepWithVoids; + typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp) + typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp) + struct IfcFanType; + struct IfcFastener; + struct IfcFastenerType; + struct IfcFeatureElementAddition; + typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp) + struct IfcFillAreaStyleHatching; + struct IfcFillAreaStyleTileSymbolWithStyle; + struct IfcFillAreaStyleTiles; + struct IfcFilterType; + struct IfcFireSuppressionTerminalType; + struct IfcFlowFitting; + struct IfcFlowInstrumentType; + struct IfcFlowMeterType; + struct IfcFlowMovingDevice; + struct IfcFlowSegment; + struct IfcFlowStorageDevice; + struct IfcFlowTerminal; + struct IfcFlowTreatmentDevice; + typedef NotImplemented IfcFluidFlowProperties; // (not currently used by Assimp) + struct IfcFooting; + typedef NotImplemented IfcFuelProperties; // (not currently used by Assimp) + struct IfcFurnishingElement; + struct IfcFurnishingElementType; + struct IfcFurnitureStandard; + struct IfcFurnitureType; + struct IfcGasTerminalType; + typedef NotImplemented IfcGeneralMaterialProperties; // (not currently used by Assimp) + typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp) + typedef NotImplemented IfcGeneralProfileProperties; // (not currently used by Assimp) + 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 IfcHeatExchangerType; + struct IfcHumidifierType; + typedef NotImplemented IfcHygroscopicMaterialProperties; // (not currently used by Assimp) + typedef NotImplemented IfcImageTexture; // (not currently used by Assimp) + 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 IfcJunctionBoxType; + struct IfcLShapeProfileDef; + struct IfcLaborResource; + 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 IfcLightFixtureType; + typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp) + struct IfcLightSource; + struct IfcLightSourceAmbient; + struct IfcLightSourceDirectional; + struct IfcLightSourceGoniometric; + struct IfcLightSourcePositional; + struct IfcLightSourceSpot; + struct IfcLine; + struct IfcLinearDimension; + struct IfcLocalPlacement; + typedef NotImplemented IfcLocalTime; // (not currently used by Assimp) + struct IfcMappedItem; + typedef NotImplemented IfcMaterial; // (not currently used by Assimp) + typedef NotImplemented IfcMaterialClassificationRelationship; // (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 IfcMaterialLayerSetUsage; // (not currently used by Assimp) + typedef NotImplemented IfcMaterialList; // (not currently used by Assimp) + struct IfcMeasureWithUnit; + typedef NotImplemented IfcMechanicalMaterialProperties; // (not currently used by Assimp) + typedef NotImplemented IfcMechanicalConcreteMaterialProperties; // (not currently used by Assimp) + struct IfcMechanicalFastener; + struct IfcMechanicalFastenerType; + typedef NotImplemented IfcMechanicalSteelMaterialProperties; // (not currently used by Assimp) + struct IfcMember; + struct IfcMemberType; + typedef NotImplemented IfcMetric; // (not currently used by Assimp) + typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp) + struct IfcMotorConnectionType; + struct IfcProcess; + struct IfcTask; + struct IfcMove; + typedef NotImplemented IfcObjective; // (not currently used by Assimp) + struct IfcOccupant; + struct IfcOffsetCurve2D; + struct IfcOffsetCurve3D; + struct IfcOneDirectionRepeatFactor; + struct IfcOpenShell; + struct IfcOpeningElement; + typedef NotImplemented IfcOpticalMaterialProperties; // (not currently used by Assimp) + struct IfcOrderAction; + typedef NotImplemented IfcOrganization; // (not currently used by Assimp) + typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp) + struct IfcOrientedEdge; + struct IfcOutletType; + typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp) + struct IfcPath; + 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 IfcPipeFittingType; + struct IfcPipeSegmentType; + typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp) + struct IfcPlanarExtent; + struct IfcPlanarBox; + struct IfcPlane; + struct IfcPlate; + struct IfcPlateType; + struct IfcPointOnCurve; + struct IfcPointOnSurface; + struct IfcPolyLoop; + struct IfcPolygonalBoundedHalfSpace; + struct IfcPolyline; + typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp) + typedef NotImplemented IfcPreDefinedSymbol; // (not currently used by Assimp) + typedef NotImplemented IfcPreDefinedDimensionSymbol; // (not currently used by Assimp) + typedef NotImplemented IfcPreDefinedPointMarkerSymbol; // (not currently used by Assimp) + typedef NotImplemented IfcPreDefinedTerminatorSymbol; // (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 IfcProductDefinitionShape; + typedef NotImplemented IfcProductsOfCombustionProperties; // (not currently used by Assimp) + struct IfcProject; + struct IfcProjectOrder; + struct IfcProjectOrderRecord; + struct IfcProjectionCurve; + struct IfcProjectionElement; + struct IfcSimpleProperty; + struct IfcPropertyBoundedValue; + typedef NotImplemented IfcPropertyConstraintRelationship; // (not currently used by Assimp) + typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp) + struct IfcPropertyEnumeratedValue; + typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp) + struct IfcPropertyListValue; + struct IfcPropertyReferenceValue; + struct IfcPropertySet; + struct IfcPropertySingleValue; + struct IfcPropertyTableValue; + struct IfcProtectiveDeviceType; + struct IfcProxy; + 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 IfcRadiusDimension; + struct IfcRailing; + struct IfcRailingType; + struct IfcRamp; + struct IfcRampFlight; + struct IfcRampFlightType; + struct IfcRationalBezierCurve; + struct IfcRectangleProfileDef; + struct IfcRectangleHollowProfileDef; + struct IfcRectangularPyramid; + struct IfcRectangularTrimmedSurface; + typedef NotImplemented IfcReferencesValueDocument; // (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 IfcReinforcingMesh; + struct IfcRelationship; + struct IfcRelDecomposes; + struct IfcRelAggregates; + typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsTasks; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToProjectOrder; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp) + typedef NotImplemented IfcRelAssociatesAppliedValue; // (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) + typedef NotImplemented IfcRelAssociatesProfileProperties; // (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 IfcRelConnectsStructuralElement; // (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) + struct IfcRelDefines; + struct IfcRelDefinesByProperties; + typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp) + struct IfcRelFillsElement; + typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp) + typedef NotImplemented IfcRelInteractionRequirements; // (not currently used by Assimp) + typedef NotImplemented IfcRelNests; // (not currently used by Assimp) + typedef NotImplemented IfcRelOccupiesSpaces; // (not currently used by Assimp) + struct IfcRelOverridesProperties; + typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp) + typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp) + typedef NotImplemented IfcRelSchedulesCostItems; // (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) + struct IfcRelVoidsElement; + typedef NotImplemented IfcRelaxation; // (not currently used by Assimp) + struct IfcRepresentation; + struct IfcRepresentationMap; + struct IfcRevolvedAreaSolid; + typedef NotImplemented IfcRibPlateProfileProperties; // (not currently used by Assimp) + struct IfcRightCircularCone; + struct IfcRightCircularCylinder; + struct IfcRoof; + struct IfcRoundedEdgeFeature; + struct IfcRoundedRectangleProfileDef; + struct IfcSIUnit; + struct IfcSanitaryTerminalType; + struct IfcScheduleTimeControl; + typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp) + typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp) + struct IfcSectionedSpine; + struct IfcSensorType; + struct IfcServiceLife; + typedef NotImplemented IfcServiceLifeFactor; // (not currently used by Assimp) + typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp) + struct IfcShapeModel; + struct IfcShapeRepresentation; + struct IfcShellBasedSurfaceModel; + struct IfcSite; + struct IfcSlab; + struct IfcSlabType; + typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp) + typedef NotImplemented IfcSoundProperties; // (not currently used by Assimp) + typedef NotImplemented IfcSoundValue; // (not currently used by Assimp) + struct IfcSpace; + struct IfcSpaceHeaterType; + struct IfcSpaceProgram; + typedef NotImplemented IfcSpaceThermalLoadProperties; // (not currently used by Assimp) + struct IfcSpatialStructureElementType; + struct IfcSpaceType; + struct IfcSphere; + struct IfcStackTerminalType; + struct IfcStair; + struct IfcStairFlight; + struct IfcStairFlightType; + struct IfcStructuralActivity; + struct IfcStructuralAction; + struct IfcStructuralAnalysisModel; + struct IfcStructuralItem; + struct IfcStructuralConnection; + struct IfcStructuralCurveConnection; + struct IfcStructuralMember; + struct IfcStructuralCurveMember; + struct IfcStructuralCurveMemberVarying; + struct IfcStructuralLinearAction; + struct IfcStructuralLinearActionVarying; + typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp) + struct IfcStructuralLoadGroup; + 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 IfcStructuralPlanarAction; + struct IfcStructuralPlanarActionVarying; + struct IfcStructuralPointAction; + struct IfcStructuralPointConnection; + struct IfcStructuralReaction; + struct IfcStructuralPointReaction; + typedef NotImplemented IfcStructuralProfileProperties; // (not currently used by Assimp) + struct IfcStructuralResultGroup; + typedef NotImplemented IfcStructuralSteelProfileProperties; // (not currently used by Assimp) + struct IfcStructuralSurfaceConnection; + struct IfcStructuralSurfaceMember; + struct IfcStructuralSurfaceMemberVarying; + struct IfcStructuredDimensionCallout; + struct IfcStyleModel; + struct IfcStyledRepresentation; + struct IfcSubContractResource; + struct IfcSubedge; + struct IfcSurfaceCurveSweptAreaSolid; + struct IfcSweptSurface; + struct IfcSurfaceOfLinearExtrusion; + struct IfcSurfaceOfRevolution; + 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 IfcSwitchingDeviceType; + typedef NotImplemented IfcSymbolStyle; // (not currently used by Assimp) + struct IfcSystemFurnitureElementType; + struct IfcTShapeProfileDef; + typedef NotImplemented IfcTable; // (not currently used by Assimp) + typedef NotImplemented IfcTableRow; // (not currently used by Assimp) + struct IfcTankType; + typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp) + struct IfcTendon; + struct IfcTendonAnchor; + 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 IfcTextStyleWithBoxCharacteristics; // (not currently used by Assimp) + typedef NotImplemented IfcTextureCoordinate; // (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 IfcThermalMaterialProperties; // (not currently used by Assimp) + typedef NotImplemented IfcTimeSeriesReferenceRelationship; // (not currently used by Assimp) + struct IfcTimeSeriesSchedule; + typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp) + struct IfcTopologyRepresentation; + struct IfcTransformerType; + struct IfcTransportElement; + struct IfcTransportElementType; + struct IfcTrapeziumProfileDef; + struct IfcTrimmedCurve; + struct IfcTubeBundleType; + struct IfcTwoDirectionRepeatFactor; + struct IfcUShapeProfileDef; + struct IfcUnitAssignment; + struct IfcUnitaryEquipmentType; + struct IfcValveType; + struct IfcVector; + struct IfcVertex; + typedef NotImplemented IfcVertexBasedTextureMap; // (not currently used by Assimp) + struct IfcVertexLoop; + struct IfcVertexPoint; + struct IfcVibrationIsolatorType; + struct IfcVirtualElement; + typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp) + struct IfcWall; + struct IfcWallStandardCase; + struct IfcWallType; + struct IfcWasteTerminalType; + typedef NotImplemented IfcWaterProperties; // (not currently used by Assimp) + struct IfcWindow; + typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp) + typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp) + struct IfcWindowStyle; + struct IfcWorkControl; + struct IfcWorkPlan; + struct IfcWorkSchedule; + struct IfcZShapeProfileDef; + struct IfcZone; + + + + // 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 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 IfcCompositeCurve + struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {} + ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments; + LOGICAL::Out SelfIntersect; + }; + + // C++ wrapper for Ifc2DCompositeCurve + struct Ifc2DCompositeCurve : IfcCompositeCurve, ObjectHelper<Ifc2DCompositeCurve,0> { Ifc2DCompositeCurve() : Object("Ifc2DCompositeCurve") {} + + }; + + // C++ wrapper for IfcRoot + struct IfcRoot : ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {} + IfcGloballyUniqueId::Out GlobalId; + 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,0> { IfcControl() : Object("IfcControl") {} + + }; + + // C++ wrapper for IfcActionRequest + struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,1> { IfcActionRequest() : Object("IfcActionRequest") {} + IfcIdentifier::Out RequestID; + }; + + // C++ wrapper for IfcActor + struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {} + IfcActorSelect::Out TheActor; + }; + + // C++ wrapper for IfcTypeObject + struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {} + Maybe< IfcLabel::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 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 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 IfcAlarmType + struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {} + IfcAlarmTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcDraughtingCallout + struct IfcDraughtingCallout : IfcGeometricRepresentationItem, ObjectHelper<IfcDraughtingCallout,1> { IfcDraughtingCallout() : Object("IfcDraughtingCallout") {} + ListOf< IfcDraughtingCalloutElement, 1, 0 >::Out Contents; + }; + + // C++ wrapper for IfcDimensionCurveDirectedCallout + struct IfcDimensionCurveDirectedCallout : IfcDraughtingCallout, ObjectHelper<IfcDimensionCurveDirectedCallout,0> { IfcDimensionCurveDirectedCallout() : Object("IfcDimensionCurveDirectedCallout") {} + + }; + + // C++ wrapper for IfcAngularDimension + struct IfcAngularDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcAngularDimension,0> { IfcAngularDimension() : Object("IfcAngularDimension") {} + + }; + + // C++ wrapper for IfcProduct + struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {} + Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement; + Maybe< Lazy< IfcProductRepresentation > > Representation; + }; + + // C++ wrapper for IfcAnnotation + struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {} + + }; + + // C++ wrapper for IfcStyledItem + struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {} + Maybe< Lazy< IfcRepresentationItem > > Item; + ListOf< Lazy< IfcPresentationStyleAssignment >, 1, 0 > Styles; + Maybe< IfcLabel::Out > Name; + }; + + // C++ wrapper for IfcAnnotationOccurrence + struct IfcAnnotationOccurrence : IfcStyledItem, ObjectHelper<IfcAnnotationOccurrence,0> { IfcAnnotationOccurrence() : Object("IfcAnnotationOccurrence") {} + + }; + + // C++ wrapper for IfcAnnotationCurveOccurrence + struct IfcAnnotationCurveOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationCurveOccurrence,0> { IfcAnnotationCurveOccurrence() : Object("IfcAnnotationCurveOccurrence") {} + + }; + + // 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 IfcAnnotationFillAreaOccurrence + struct IfcAnnotationFillAreaOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationFillAreaOccurrence,2> { IfcAnnotationFillAreaOccurrence() : Object("IfcAnnotationFillAreaOccurrence") {} + Maybe< Lazy< IfcPoint > > FillStyleTarget; + Maybe< IfcGlobalOrLocalEnum::Out > GlobalOrLocal; + }; + + // C++ wrapper for IfcAnnotationSurface + struct IfcAnnotationSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationSurface,2> { IfcAnnotationSurface() : Object("IfcAnnotationSurface") {} + Lazy< IfcGeometricRepresentationItem > Item; + Maybe< Lazy< NotImplemented > > TextureCoordinates; + }; + + // C++ wrapper for IfcAnnotationSurfaceOccurrence + struct IfcAnnotationSurfaceOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSurfaceOccurrence,0> { IfcAnnotationSurfaceOccurrence() : Object("IfcAnnotationSurfaceOccurrence") {} + + }; + + // C++ wrapper for IfcAnnotationSymbolOccurrence + struct IfcAnnotationSymbolOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSymbolOccurrence,0> { IfcAnnotationSymbolOccurrence() : Object("IfcAnnotationSymbolOccurrence") {} + + }; + + // C++ wrapper for IfcAnnotationTextOccurrence + struct IfcAnnotationTextOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationTextOccurrence,0> { IfcAnnotationTextOccurrence() : Object("IfcAnnotationTextOccurrence") {} + + }; + + // 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") {} + IfcIdentifier::Out AssetID; + Lazy< NotImplemented > OriginalValue; + Lazy< NotImplemented > CurrentValue; + Lazy< NotImplemented > TotalReplacementCost; + IfcActorSelect::Out Owner; + IfcActorSelect::Out User; + Lazy< NotImplemented > ResponsiblePerson; + Lazy< NotImplemented > IncorporationDate; + Lazy< NotImplemented > DepreciatedValue; + }; + + // C++ wrapper for IfcParameterizedProfileDef + struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {} + Lazy< IfcAxis2Placement2D > Position; + }; + + // C++ wrapper for IfcIShapeProfileDef + struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,5> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {} + IfcPositiveLengthMeasure::Out OverallWidth; + IfcPositiveLengthMeasure::Out OverallDepth; + IfcPositiveLengthMeasure::Out WebThickness; + IfcPositiveLengthMeasure::Out FlangeThickness; + Maybe< IfcPositiveLengthMeasure::Out > FilletRadius; + }; + + // C++ wrapper for IfcAsymmetricIShapeProfileDef + struct IfcAsymmetricIShapeProfileDef : IfcIShapeProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,4> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {} + IfcPositiveLengthMeasure::Out TopFlangeWidth; + Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness; + Maybe< IfcPositiveLengthMeasure::Out > TopFlangeFilletRadius; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY; + }; + + // 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 IfcBSplineCurve + struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {} + INTEGER::Out Degree; + ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList; + IfcBSplineCurveForm::Out CurveForm; + LOGICAL::Out ClosedCurve; + LOGICAL::Out SelfIntersect; + }; + + // C++ wrapper for IfcElement + struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {} + Maybe< IfcIdentifier::Out > Tag; + }; + + // C++ wrapper for IfcBuildingElement + struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {} + + }; + + // C++ wrapper for IfcBeam + struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,0> { IfcBeam() : Object("IfcBeam") {} + + }; + + // 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 IfcBezierCurve + struct IfcBezierCurve : IfcBSplineCurve, ObjectHelper<IfcBezierCurve,0> { IfcBezierCurve() : Object("IfcBezierCurve") {} + + }; + + // 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 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 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 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; + BOOLEAN::Out AgreementFlag; + }; + + // C++ wrapper for IfcBoxedHalfSpace + struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {} + Lazy< IfcBoundingBox > Enclosure; + }; + + // C++ wrapper for IfcSpatialStructureElement + struct IfcSpatialStructureElement : IfcProduct, ObjectHelper<IfcSpatialStructureElement,2> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {} + Maybe< IfcLabel::Out > LongName; + 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 IfcBuildingElementComponent + struct IfcBuildingElementComponent : IfcBuildingElement, ObjectHelper<IfcBuildingElementComponent,0> { IfcBuildingElementComponent() : Object("IfcBuildingElementComponent") {} + + }; + + // C++ wrapper for IfcBuildingElementPart + struct IfcBuildingElementPart : IfcBuildingElementComponent, ObjectHelper<IfcBuildingElementPart,0> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {} + + }; + + // C++ wrapper for IfcBuildingElementProxy + struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {} + Maybe< IfcElementCompositionEnum::Out > CompositionType; + }; + + // 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 IfcCShapeProfileDef + struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,6> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {} + IfcPositiveLengthMeasure::Out Depth; + IfcPositiveLengthMeasure::Out Width; + IfcPositiveLengthMeasure::Out WallThickness; + IfcPositiveLengthMeasure::Out Girth; + Maybe< IfcPositiveLengthMeasure::Out > InternalFilletRadius; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX; + }; + + // 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 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 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 IfcCartesianTransformationOperator + struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {} + Maybe< Lazy< IfcDirection > > Axis1; + Maybe< Lazy< IfcDirection > > Axis2; + Lazy< IfcCartesianPoint > LocalOrigin; + Maybe< REAL::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< REAL::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< REAL::Out > Scale2; + Maybe< REAL::Out > Scale3; + }; + + // C++ wrapper for IfcCenterLineProfileDef + struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {} + IfcPositiveLengthMeasure::Out Thickness; + }; + + // C++ wrapper for IfcFeatureElement + struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {} + + }; + + // C++ wrapper for IfcFeatureElementSubtraction + struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {} + + }; + + // C++ wrapper for IfcEdgeFeature + struct IfcEdgeFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcEdgeFeature,1> { IfcEdgeFeature() : Object("IfcEdgeFeature") {} + Maybe< IfcPositiveLengthMeasure::Out > FeatureLength; + }; + + // C++ wrapper for IfcChamferEdgeFeature + struct IfcChamferEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcChamferEdgeFeature,2> { IfcChamferEdgeFeature() : Object("IfcChamferEdgeFeature") {} + Maybe< IfcPositiveLengthMeasure::Out > Width; + Maybe< IfcPositiveLengthMeasure::Out > Height; + }; + + // C++ wrapper for IfcChillerType + struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {} + IfcChillerTypeEnum::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 IfcTopologicalRepresentationItem + struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {} + + }; + + // 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 IfcCoilType + struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {} + IfcCoilTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcColourSpecification + struct IfcColourSpecification : 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,0> { IfcColumn() : Object("IfcColumn") {} + + }; + + // C++ wrapper for IfcColumnType + struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {} + IfcColumnTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcProperty + struct IfcProperty : 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 IfcCompositeCurveSegment + struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {} + IfcTransitionCode::Out Transition; + BOOLEAN::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 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 IfcCondenserType + struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {} + IfcCondenserTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcCondition + struct IfcCondition : IfcGroup, ObjectHelper<IfcCondition,0> { IfcCondition() : Object("IfcCondition") {} + + }; + + // C++ wrapper for IfcConditionCriterion + struct IfcConditionCriterion : IfcControl, ObjectHelper<IfcConditionCriterion,2> { IfcConditionCriterion() : Object("IfcConditionCriterion") {} + IfcConditionCriterionSelect::Out Criterion; + IfcDateTimeSelect::Out CriterionDateTime; + }; + + // C++ wrapper for IfcResource + struct IfcResource : IfcObject, ObjectHelper<IfcResource,0> { IfcResource() : Object("IfcResource") {} + + }; + + // C++ wrapper for IfcConstructionResource + struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,4> { IfcConstructionResource() : Object("IfcConstructionResource") {} + Maybe< IfcIdentifier::Out > ResourceIdentifier; + Maybe< IfcLabel::Out > ResourceGroup; + Maybe< IfcResourceConsumptionEnum::Out > ResourceConsumption; + Maybe< Lazy< IfcMeasureWithUnit > > BaseQuantity; + }; + + // C++ wrapper for IfcConstructionEquipmentResource + struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,0> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {} + + }; + + // C++ wrapper for IfcConstructionMaterialResource + struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,2> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {} + Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > Suppliers; + Maybe< IfcRatioMeasure::Out > UsageRatio; + }; + + // C++ wrapper for IfcConstructionProductResource + struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,0> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {} + + }; + + // 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 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 IfcCooledBeamType + struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {} + IfcCooledBeamTypeEnum::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,0> { IfcCostItem() : Object("IfcCostItem") {} + + }; + + // C++ wrapper for IfcCostSchedule + struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,8> { IfcCostSchedule() : Object("IfcCostSchedule") {} + Maybe< IfcActorSelect::Out > SubmittedBy; + Maybe< IfcActorSelect::Out > PreparedBy; + Maybe< IfcDateTimeSelect::Out > SubmittedOn; + Maybe< IfcLabel::Out > Status; + Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > TargetUsers; + Maybe< IfcDateTimeSelect::Out > UpdateDate; + IfcIdentifier::Out ID; + IfcCostScheduleTypeEnum::Out PredefinedType; + }; + + // 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 IfcCraneRailAShapeProfileDef + struct IfcCraneRailAShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailAShapeProfileDef,12> { IfcCraneRailAShapeProfileDef() : Object("IfcCraneRailAShapeProfileDef") {} + IfcPositiveLengthMeasure::Out OverallHeight; + IfcPositiveLengthMeasure::Out BaseWidth2; + Maybe< IfcPositiveLengthMeasure::Out > Radius; + IfcPositiveLengthMeasure::Out HeadWidth; + IfcPositiveLengthMeasure::Out HeadDepth2; + IfcPositiveLengthMeasure::Out HeadDepth3; + IfcPositiveLengthMeasure::Out WebThickness; + IfcPositiveLengthMeasure::Out BaseWidth4; + IfcPositiveLengthMeasure::Out BaseDepth1; + IfcPositiveLengthMeasure::Out BaseDepth2; + IfcPositiveLengthMeasure::Out BaseDepth3; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY; + }; + + // C++ wrapper for IfcCraneRailFShapeProfileDef + struct IfcCraneRailFShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailFShapeProfileDef,9> { IfcCraneRailFShapeProfileDef() : Object("IfcCraneRailFShapeProfileDef") {} + IfcPositiveLengthMeasure::Out OverallHeight; + IfcPositiveLengthMeasure::Out HeadWidth; + Maybe< IfcPositiveLengthMeasure::Out > Radius; + IfcPositiveLengthMeasure::Out HeadDepth2; + IfcPositiveLengthMeasure::Out HeadDepth3; + IfcPositiveLengthMeasure::Out WebThickness; + IfcPositiveLengthMeasure::Out BaseDepth1; + IfcPositiveLengthMeasure::Out BaseDepth2; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY; + }; + + // C++ wrapper for IfcCrewResource + struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,0> { IfcCrewResource() : Object("IfcCrewResource") {} + + }; + + // C++ wrapper for IfcSolidModel + struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {} + + }; + + // 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,0> { IfcCurtainWall() : Object("IfcCurtainWall") {} + + }; + + // 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 IfcPresentationStyle + struct IfcPresentationStyle : ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {} + Maybe< IfcLabel::Out > Name; + }; + + // C++ wrapper for IfcDamperType + struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {} + IfcDamperTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcDefinedSymbol + struct IfcDefinedSymbol : IfcGeometricRepresentationItem, ObjectHelper<IfcDefinedSymbol,2> { IfcDefinedSymbol() : Object("IfcDefinedSymbol") {} + IfcDefinedSymbolSelect::Out Definition; + Lazy< IfcCartesianTransformationOperator2D > Target; + }; + + // 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 IfcDiameterDimension + struct IfcDiameterDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcDiameterDimension,0> { IfcDiameterDimension() : Object("IfcDiameterDimension") {} + + }; + + // C++ wrapper for IfcDimensionCurve + struct IfcDimensionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcDimensionCurve,0> { IfcDimensionCurve() : Object("IfcDimensionCurve") {} + + }; + + // C++ wrapper for IfcTerminatorSymbol + struct IfcTerminatorSymbol : IfcAnnotationSymbolOccurrence, ObjectHelper<IfcTerminatorSymbol,1> { IfcTerminatorSymbol() : Object("IfcTerminatorSymbol") {} + Lazy< IfcAnnotationCurveOccurrence > AnnotatedCurve; + }; + + // C++ wrapper for IfcDimensionCurveTerminator + struct IfcDimensionCurveTerminator : IfcTerminatorSymbol, ObjectHelper<IfcDimensionCurveTerminator,1> { IfcDimensionCurveTerminator() : Object("IfcDimensionCurveTerminator") {} + IfcDimensionExtentUsage::Out Role; + }; + + // C++ wrapper for IfcDirection + struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {} + ListOf< REAL, 2, 3 >::Out DirectionRatios; + }; + + // C++ wrapper for IfcElementComponent + struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {} + + }; + + // C++ wrapper for IfcDiscreteAccessory + struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,0> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {} + + }; + + // C++ wrapper for IfcElementComponentType + struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {} + + }; + + // C++ wrapper for IfcDiscreteAccessoryType + struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,0> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {} + + }; + + // C++ wrapper for IfcDistributionElement + struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {} + + }; + + // C++ wrapper for IfcDistributionFlowElement + struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {} + + }; + + // C++ wrapper for IfcDistributionChamberElement + struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,0> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {} + + }; + + // C++ wrapper for IfcDistributionChamberElementType + struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {} + IfcDistributionChamberElementTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcDistributionControlElement + struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,1> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {} + Maybe< IfcIdentifier::Out > ControlElementId; + }; + + // C++ wrapper for IfcPort + struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {} + + }; + + // C++ wrapper for IfcDistributionPort + struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,1> { IfcDistributionPort() : Object("IfcDistributionPort") {} + Maybe< IfcFlowDirectionEnum::Out > FlowDirection; + }; + + // C++ wrapper for IfcDoor + struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,2> { IfcDoor() : Object("IfcDoor") {} + Maybe< IfcPositiveLengthMeasure::Out > OverallHeight; + Maybe< IfcPositiveLengthMeasure::Out > OverallWidth; + }; + + // C++ wrapper for IfcPropertyDefinition + struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {} + + }; + + // C++ wrapper for IfcPropertySetDefinition + struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {} + + }; + + // C++ wrapper for IfcDoorStyle + struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {} + IfcDoorStyleOperationEnum::Out OperationType; + IfcDoorStyleConstructionEnum::Out ConstructionType; + BOOLEAN::Out ParameterTakesPrecedence; + BOOLEAN::Out Sizeable; + }; + + // C++ wrapper for IfcDuctFittingType + struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {} + IfcDuctFittingTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcDuctSegmentType + struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {} + IfcDuctSegmentTypeEnum::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; + BOOLEAN::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 IfcElectricApplianceType + struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {} + IfcElectricApplianceTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcFlowController + struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {} + + }; + + // C++ wrapper for IfcElectricDistributionPoint + struct IfcElectricDistributionPoint : IfcFlowController, ObjectHelper<IfcElectricDistributionPoint,2> { IfcElectricDistributionPoint() : Object("IfcElectricDistributionPoint") {} + IfcElectricDistributionPointFunctionEnum::Out DistributionPointFunction; + Maybe< IfcLabel::Out > UserDefinedFunction; + }; + + // 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 IfcElectricGeneratorType + struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {} + IfcElectricGeneratorTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcElectricHeaterType + struct IfcElectricHeaterType : IfcFlowTerminalType, ObjectHelper<IfcElectricHeaterType,1> { IfcElectricHeaterType() : Object("IfcElectricHeaterType") {} + IfcElectricHeaterTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcElectricMotorType + struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {} + IfcElectricMotorTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcElectricTimeControlType + struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {} + IfcElectricTimeControlTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcSystem + struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {} + + }; + + // C++ wrapper for IfcElectricalCircuit + struct IfcElectricalCircuit : IfcSystem, ObjectHelper<IfcElectricalCircuit,0> { IfcElectricalCircuit() : Object("IfcElectricalCircuit") {} + + }; + + // C++ wrapper for IfcElectricalElement + struct IfcElectricalElement : IfcElement, ObjectHelper<IfcElectricalElement,0> { IfcElectricalElement() : Object("IfcElectricalElement") {} + + }; + + // C++ wrapper for IfcElementAssembly + struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {} + Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace; + IfcElementAssemblyTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcElementQuantity + struct IfcElementQuantity : IfcPropertySetDefinition, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {} + Maybe< IfcLabel::Out > MethodOfMeasurement; + ListOf< Lazy< NotImplemented >, 1, 0 > Quantities; + }; + + // C++ wrapper for IfcElementarySurface + struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {} + Lazy< IfcAxis2Placement3D > Position; + }; + + // 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 IfcEnergyConversionDevice + struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {} + + }; + + // C++ wrapper for IfcEquipmentElement + struct IfcEquipmentElement : IfcElement, ObjectHelper<IfcEquipmentElement,0> { IfcEquipmentElement() : Object("IfcEquipmentElement") {} + + }; + + // C++ wrapper for IfcEquipmentStandard + struct IfcEquipmentStandard : IfcControl, ObjectHelper<IfcEquipmentStandard,0> { IfcEquipmentStandard() : Object("IfcEquipmentStandard") {} + + }; + + // C++ wrapper for IfcEvaporativeCoolerType + struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {} + IfcEvaporativeCoolerTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcEvaporatorType + struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {} + IfcEvaporatorTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcSweptAreaSolid + struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {} + Lazy< IfcProfileDef > SweptArea; + 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 IfcFace + struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {} + ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds; + }; + + // 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; + BOOLEAN::Out Orientation; + }; + + // C++ wrapper for IfcFaceOuterBound + struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {} + + }; + + // C++ wrapper for IfcFaceSurface + struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {} + Lazy< IfcSurface > FaceSurface; + BOOLEAN::Out SameSense; + }; + + // C++ wrapper for IfcManifoldSolidBrep + struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {} + Lazy< IfcClosedShell > Outer; + }; + + // C++ wrapper for IfcFacetedBrep + struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {} + + }; + + // C++ wrapper for IfcFacetedBrepWithVoids + struct IfcFacetedBrepWithVoids : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {} + ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids; + }; + + // 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,0> { IfcFastener() : Object("IfcFastener") {} + + }; + + // C++ wrapper for IfcFastenerType + struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,0> { IfcFastenerType() : Object("IfcFastenerType") {} + + }; + + // C++ wrapper for IfcFeatureElementAddition + struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {} + + }; + + // 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 IfcFillAreaStyleTileSymbolWithStyle + struct IfcFillAreaStyleTileSymbolWithStyle : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTileSymbolWithStyle,1> { IfcFillAreaStyleTileSymbolWithStyle() : Object("IfcFillAreaStyleTileSymbolWithStyle") {} + Lazy< IfcAnnotationSymbolOccurrence > Symbol; + }; + + // C++ wrapper for IfcFillAreaStyleTiles + struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {} + Lazy< IfcOneDirectionRepeatFactor > TilingPattern; + ListOf< IfcFillAreaStyleTileShapeSelect, 1, 0 >::Out Tiles; + IfcPositiveRatioMeasure::Out TilingScale; + }; + + // C++ wrapper for IfcFilterType + struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {} + IfcFilterTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcFireSuppressionTerminalType + struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {} + IfcFireSuppressionTerminalTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcFlowFitting + struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {} + + }; + + // C++ wrapper for IfcFlowInstrumentType + struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {} + IfcFlowInstrumentTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcFlowMeterType + struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {} + IfcFlowMeterTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcFlowMovingDevice + struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {} + + }; + + // C++ wrapper for IfcFlowSegment + struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {} + + }; + + // C++ wrapper for IfcFlowStorageDevice + struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {} + + }; + + // C++ wrapper for IfcFlowTerminal + struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {} + + }; + + // C++ wrapper for IfcFlowTreatmentDevice + struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {} + + }; + + // C++ wrapper for IfcFooting + struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {} + 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 IfcFurnitureStandard + struct IfcFurnitureStandard : IfcControl, ObjectHelper<IfcFurnitureStandard,0> { IfcFurnitureStandard() : Object("IfcFurnitureStandard") {} + + }; + + // C++ wrapper for IfcFurnitureType + struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,1> { IfcFurnitureType() : Object("IfcFurnitureType") {} + IfcAssemblyPlaceEnum::Out AssemblyPlace; + }; + + // C++ wrapper for IfcGasTerminalType + struct IfcGasTerminalType : IfcFlowTerminalType, ObjectHelper<IfcGasTerminalType,1> { IfcGasTerminalType() : Object("IfcGasTerminalType") {} + IfcGasTerminalTypeEnum::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< REAL::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,3> { IfcGrid() : Object("IfcGrid") {} + ListOf< Lazy< NotImplemented >, 1, 0 > UAxes; + ListOf< Lazy< NotImplemented >, 1, 0 > VAxes; + Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes; + }; + + // 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< Lazy< NotImplemented > > PlacementRefDirection; + }; + + // C++ wrapper for IfcHeatExchangerType + struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {} + IfcHeatExchangerTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcHumidifierType + struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {} + IfcHumidifierTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcInventory + struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {} + IfcInventoryTypeEnum::Out InventoryType; + IfcActorSelect::Out Jurisdiction; + ListOf< Lazy< NotImplemented >, 1, 0 > ResponsiblePersons; + Lazy< NotImplemented > LastUpdateDate; + Maybe< Lazy< NotImplemented > > CurrentValue; + Maybe< Lazy< NotImplemented > > OriginalValue; + }; + + // 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,8> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {} + IfcPositiveLengthMeasure::Out Depth; + Maybe< IfcPositiveLengthMeasure::Out > Width; + IfcPositiveLengthMeasure::Out Thickness; + Maybe< IfcPositiveLengthMeasure::Out > FilletRadius; + Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius; + Maybe< IfcPlaneAngleMeasure::Out > LegSlope; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY; + }; + + // C++ wrapper for IfcLaborResource + struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {} + Maybe< IfcText::Out > SkillSet; + }; + + // C++ wrapper for IfcLampType + struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {} + IfcLampTypeEnum::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 IfcLinearDimension + struct IfcLinearDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcLinearDimension,0> { IfcLinearDimension() : Object("IfcLinearDimension") {} + + }; + + // 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 : IfcFastener, ObjectHelper<IfcMechanicalFastener,2> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {} + Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter; + Maybe< IfcPositiveLengthMeasure::Out > NominalLength; + }; + + // C++ wrapper for IfcMechanicalFastenerType + struct IfcMechanicalFastenerType : IfcFastenerType, ObjectHelper<IfcMechanicalFastenerType,0> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {} + + }; + + // C++ wrapper for IfcMember + struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,0> { IfcMember() : Object("IfcMember") {} + + }; + + // C++ wrapper for IfcMemberType + struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {} + IfcMemberTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcMotorConnectionType + struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {} + IfcMotorConnectionTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcProcess + struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,0> { IfcProcess() : Object("IfcProcess") {} + + }; + + // C++ wrapper for IfcTask + struct IfcTask : IfcProcess, ObjectHelper<IfcTask,5> { IfcTask() : Object("IfcTask") {} + IfcIdentifier::Out TaskId; + Maybe< IfcLabel::Out > Status; + Maybe< IfcLabel::Out > WorkMethod; + BOOLEAN::Out IsMilestone; + Maybe< INTEGER::Out > Priority; + }; + + // C++ wrapper for IfcMove + struct IfcMove : IfcTask, ObjectHelper<IfcMove,3> { IfcMove() : Object("IfcMove") {} + Lazy< IfcSpatialStructureElement > MoveFrom; + Lazy< IfcSpatialStructureElement > MoveTo; + Maybe< ListOf< IfcText, 1, 0 >::Out > PunchList; + }; + + // C++ wrapper for IfcOccupant + struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {} + IfcOccupantTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcOffsetCurve2D + struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {} + Lazy< IfcCurve > BasisCurve; + IfcLengthMeasure::Out Distance; + LOGICAL::Out SelfIntersect; + }; + + // C++ wrapper for IfcOffsetCurve3D + struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {} + Lazy< IfcCurve > BasisCurve; + IfcLengthMeasure::Out Distance; + LOGICAL::Out SelfIntersect; + Lazy< IfcDirection > RefDirection; + }; + + // C++ wrapper for IfcOneDirectionRepeatFactor + struct IfcOneDirectionRepeatFactor : IfcGeometricRepresentationItem, ObjectHelper<IfcOneDirectionRepeatFactor,1> { IfcOneDirectionRepeatFactor() : Object("IfcOneDirectionRepeatFactor") {} + Lazy< IfcVector > RepeatFactor; + }; + + // C++ wrapper for IfcOpenShell + struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {} + + }; + + // C++ wrapper for IfcOpeningElement + struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,0> { IfcOpeningElement() : Object("IfcOpeningElement") {} + + }; + + // C++ wrapper for IfcOrderAction + struct IfcOrderAction : IfcTask, ObjectHelper<IfcOrderAction,1> { IfcOrderAction() : Object("IfcOrderAction") {} + IfcIdentifier::Out ActionID; + }; + + // C++ wrapper for IfcOrientedEdge + struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {} + Lazy< IfcEdge > EdgeElement; + BOOLEAN::Out Orientation; + }; + + // 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 IfcPerformanceHistory + struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,1> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {} + IfcLabel::Out LifeCyclePhase; + }; + + // C++ wrapper for IfcPermit + struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,1> { IfcPermit() : Object("IfcPermit") {} + IfcIdentifier::Out PermitID; + }; + + // C++ wrapper for IfcPile + struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {} + IfcPileTypeEnum::Out PredefinedType; + Maybe< IfcPileConstructionEnum::Out > ConstructionType; + }; + + // C++ wrapper for IfcPipeFittingType + struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {} + IfcPipeFittingTypeEnum::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,0> { IfcPlate() : Object("IfcPlate") {} + + }; + + // 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 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,3> { IfcProcedure() : Object("IfcProcedure") {} + IfcIdentifier::Out ProcedureID; + IfcProcedureTypeEnum::Out ProcedureType; + Maybe< IfcLabel::Out > UserDefinedProcedureType; + }; + + // C++ wrapper for IfcProductDefinitionShape + struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {} + + }; + + // C++ wrapper for IfcProject + struct IfcProject : IfcObject, ObjectHelper<IfcProject,4> { IfcProject() : Object("IfcProject") {} + Maybe< IfcLabel::Out > LongName; + Maybe< IfcLabel::Out > Phase; + ListOf< Lazy< IfcRepresentationContext >, 1, 0 > RepresentationContexts; + Lazy< IfcUnitAssignment > UnitsInContext; + }; + + // C++ wrapper for IfcProjectOrder + struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {} + IfcIdentifier::Out ID; + IfcProjectOrderTypeEnum::Out PredefinedType; + Maybe< IfcLabel::Out > Status; + }; + + // C++ wrapper for IfcProjectOrderRecord + struct IfcProjectOrderRecord : IfcControl, ObjectHelper<IfcProjectOrderRecord,2> { IfcProjectOrderRecord() : Object("IfcProjectOrderRecord") {} + ListOf< Lazy< NotImplemented >, 1, 0 > Records; + IfcProjectOrderRecordTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcProjectionCurve + struct IfcProjectionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcProjectionCurve,0> { IfcProjectionCurve() : Object("IfcProjectionCurve") {} + + }; + + // C++ wrapper for IfcProjectionElement + struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,0> { IfcProjectionElement() : Object("IfcProjectionElement") {} + + }; + + // C++ wrapper for IfcSimpleProperty + struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {} + + }; + + // C++ wrapper for IfcPropertyBoundedValue + struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,3> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {} + Maybe< IfcValue::Out > UpperBoundValue; + Maybe< IfcValue::Out > LowerBoundValue; + Maybe< IfcUnit::Out > Unit; + }; + + // C++ wrapper for IfcPropertyEnumeratedValue + struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {} + ListOf< IfcValue, 1, 0 >::Out EnumerationValues; + Maybe< Lazy< NotImplemented > > EnumerationReference; + }; + + // C++ wrapper for IfcPropertyListValue + struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {} + ListOf< IfcValue, 1, 0 >::Out ListValues; + Maybe< IfcUnit::Out > Unit; + }; + + // C++ wrapper for IfcPropertyReferenceValue + struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {} + Maybe< IfcLabel::Out > UsageName; + 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,5> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {} + ListOf< IfcValue, 1, 0 >::Out DefiningValues; + ListOf< IfcValue, 1, 0 >::Out DefinedValues; + Maybe< IfcText::Out > Expression; + Maybe< IfcUnit::Out > DefiningUnit; + Maybe< IfcUnit::Out > DefinedUnit; + }; + + // 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 IfcPumpType + struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {} + IfcPumpTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcRadiusDimension + struct IfcRadiusDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcRadiusDimension,0> { IfcRadiusDimension() : Object("IfcRadiusDimension") {} + + }; + + // 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") {} + IfcRampTypeEnum::Out ShapeType; + }; + + // C++ wrapper for IfcRampFlight + struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,0> { IfcRampFlight() : Object("IfcRampFlight") {} + + }; + + // C++ wrapper for IfcRampFlightType + struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {} + IfcRampFlightTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcRationalBezierCurve + struct IfcRationalBezierCurve : IfcBezierCurve, ObjectHelper<IfcRationalBezierCurve,1> { IfcRationalBezierCurve() : Object("IfcRationalBezierCurve") {} + ListOf< REAL, 2, 0 >::Out WeightsData; + }; + + // 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< IfcPositiveLengthMeasure::Out > InnerFilletRadius; + Maybe< IfcPositiveLengthMeasure::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; + BOOLEAN::Out Usense; + BOOLEAN::Out Vsense; + }; + + // C++ wrapper for IfcReinforcingElement + struct IfcReinforcingElement : IfcBuildingElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {} + Maybe< IfcLabel::Out > SteelGrade; + }; + + // C++ wrapper for IfcReinforcingBar + struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {} + IfcPositiveLengthMeasure::Out NominalDiameter; + IfcAreaMeasure::Out CrossSectionArea; + Maybe< IfcPositiveLengthMeasure::Out > BarLength; + IfcReinforcingBarRoleEnum::Out BarRole; + Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface; + }; + + // C++ wrapper for IfcReinforcingMesh + struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,8> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {} + Maybe< IfcPositiveLengthMeasure::Out > MeshLength; + Maybe< IfcPositiveLengthMeasure::Out > MeshWidth; + IfcPositiveLengthMeasure::Out LongitudinalBarNominalDiameter; + IfcPositiveLengthMeasure::Out TransverseBarNominalDiameter; + IfcAreaMeasure::Out LongitudinalBarCrossSectionArea; + IfcAreaMeasure::Out TransverseBarCrossSectionArea; + IfcPositiveLengthMeasure::Out LongitudinalBarSpacing; + IfcPositiveLengthMeasure::Out TransverseBarSpacing; + }; + + // C++ wrapper for IfcRelationship + struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {} + + }; + + // C++ wrapper for IfcRelDecomposes + struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,2> { IfcRelDecomposes() : Object("IfcRelDecomposes") {} + Lazy< IfcObjectDefinition > RelatingObject; + ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects; + }; + + // C++ wrapper for IfcRelAggregates + struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,0> { IfcRelAggregates() : Object("IfcRelAggregates") {} + + }; + + // 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< IfcSpatialStructureElement > RelatingStructure; + }; + + // C++ wrapper for IfcRelDefines + struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,1> { IfcRelDefines() : Object("IfcRelDefines") {} + ListOf< Lazy< IfcObject >, 1, 0 > RelatedObjects; + }; + + // C++ wrapper for IfcRelDefinesByProperties + struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,1> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {} + Lazy< IfcPropertySetDefinition > RelatingPropertyDefinition; + }; + + // C++ wrapper for IfcRelFillsElement + struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {} + Lazy< IfcOpeningElement > RelatingOpeningElement; + Lazy< IfcElement > RelatedBuildingElement; + }; + + // C++ wrapper for IfcRelOverridesProperties + struct IfcRelOverridesProperties : IfcRelDefinesByProperties, ObjectHelper<IfcRelOverridesProperties,1> { IfcRelOverridesProperties() : Object("IfcRelOverridesProperties") {} + ListOf< Lazy< IfcProperty >, 1, 0 > OverridingProperties; + }; + + // C++ wrapper for IfcRelVoidsElement + struct IfcRelVoidsElement : IfcRelConnects, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {} + Lazy< IfcElement > RelatingBuildingElement; + Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement; + }; + + // 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 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") {} + IfcRoofTypeEnum::Out ShapeType; + }; + + // C++ wrapper for IfcRoundedEdgeFeature + struct IfcRoundedEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcRoundedEdgeFeature,1> { IfcRoundedEdgeFeature() : Object("IfcRoundedEdgeFeature") {} + Maybe< IfcPositiveLengthMeasure::Out > Radius; + }; + + // 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 IfcSanitaryTerminalType + struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {} + IfcSanitaryTerminalTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcScheduleTimeControl + struct IfcScheduleTimeControl : IfcControl, ObjectHelper<IfcScheduleTimeControl,18> { IfcScheduleTimeControl() : Object("IfcScheduleTimeControl") {} + Maybe< IfcDateTimeSelect::Out > ActualStart; + Maybe< IfcDateTimeSelect::Out > EarlyStart; + Maybe< IfcDateTimeSelect::Out > LateStart; + Maybe< IfcDateTimeSelect::Out > ScheduleStart; + Maybe< IfcDateTimeSelect::Out > ActualFinish; + Maybe< IfcDateTimeSelect::Out > EarlyFinish; + Maybe< IfcDateTimeSelect::Out > LateFinish; + Maybe< IfcDateTimeSelect::Out > ScheduleFinish; + Maybe< IfcTimeMeasure::Out > ScheduleDuration; + Maybe< IfcTimeMeasure::Out > ActualDuration; + Maybe< IfcTimeMeasure::Out > RemainingTime; + Maybe< IfcTimeMeasure::Out > FreeFloat; + Maybe< IfcTimeMeasure::Out > TotalFloat; + Maybe< BOOLEAN::Out > IsCritical; + Maybe< IfcDateTimeSelect::Out > StatusTime; + Maybe< IfcTimeMeasure::Out > StartFloat; + Maybe< IfcTimeMeasure::Out > FinishFloat; + Maybe< IfcPositiveRatioMeasure::Out > Completion; + }; + + // 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 IfcSensorType + struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {} + IfcSensorTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcServiceLife + struct IfcServiceLife : IfcControl, ObjectHelper<IfcServiceLife,2> { IfcServiceLife() : Object("IfcServiceLife") {} + IfcServiceLifeTypeEnum::Out ServiceLifeType; + IfcTimeMeasure::Out ServiceLifeDuration; + }; + + // 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 IfcSlabType + struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {} + IfcSlabTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcSpace + struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {} + IfcInternalOrExternalEnum::Out InteriorOrExteriorSpace; + Maybe< IfcLengthMeasure::Out > ElevationWithFlooring; + }; + + // C++ wrapper for IfcSpaceHeaterType + struct IfcSpaceHeaterType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {} + IfcSpaceHeaterTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcSpaceProgram + struct IfcSpaceProgram : IfcControl, ObjectHelper<IfcSpaceProgram,5> { IfcSpaceProgram() : Object("IfcSpaceProgram") {} + IfcIdentifier::Out SpaceProgramIdentifier; + Maybe< IfcAreaMeasure::Out > MaxRequiredArea; + Maybe< IfcAreaMeasure::Out > MinRequiredArea; + Maybe< Lazy< IfcSpatialStructureElement > > RequestedLocation; + IfcAreaMeasure::Out StandardRequiredArea; + }; + + // C++ wrapper for IfcSpatialStructureElementType + struct IfcSpatialStructureElementType : IfcElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {} + + }; + + // C++ wrapper for IfcSpaceType + struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,1> { IfcSpaceType() : Object("IfcSpaceType") {} + IfcSpaceTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcSphere + struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {} + IfcPositiveLengthMeasure::Out Radius; + }; + + // 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") {} + IfcStairTypeEnum::Out ShapeType; + }; + + // C++ wrapper for IfcStairFlight + struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,4> { IfcStairFlight() : Object("IfcStairFlight") {} + Maybe< INTEGER::Out > NumberOfRiser; + Maybe< INTEGER::Out > NumberOfTreads; + Maybe< IfcPositiveLengthMeasure::Out > RiserHeight; + Maybe< IfcPositiveLengthMeasure::Out > TreadLength; + }; + + // C++ wrapper for IfcStairFlightType + struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {} + IfcStairFlightTypeEnum::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,2> { IfcStructuralAction() : Object("IfcStructuralAction") {} + BOOLEAN::Out DestabilizingLoad; + Maybe< Lazy< IfcStructuralReaction > > CausedBy; + }; + + // C++ wrapper for IfcStructuralAnalysisModel + struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,4> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {} + IfcAnalysisModelTypeEnum::Out PredefinedType; + Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane; + Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy; + Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults; + }; + + // 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 IfcStructuralCurveConnection + struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,0> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {} + + }; + + // C++ wrapper for IfcStructuralMember + struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {} + + }; + + // C++ wrapper for IfcStructuralCurveMember + struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,1> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {} + IfcStructuralCurveTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcStructuralCurveMemberVarying + struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {} + + }; + + // C++ wrapper for IfcStructuralLinearAction + struct IfcStructuralLinearAction : IfcStructuralAction, ObjectHelper<IfcStructuralLinearAction,1> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {} + IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue; + }; + + // C++ wrapper for IfcStructuralLinearActionVarying + struct IfcStructuralLinearActionVarying : IfcStructuralLinearAction, ObjectHelper<IfcStructuralLinearActionVarying,2> { IfcStructuralLinearActionVarying() : Object("IfcStructuralLinearActionVarying") {} + Lazy< NotImplemented > VaryingAppliedLoadLocation; + ListOf< Lazy< NotImplemented >, 1, 0 > SubsequentAppliedLoads; + }; + + // C++ wrapper for IfcStructuralLoadGroup + struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {} + IfcLoadGroupTypeEnum::Out PredefinedType; + IfcActionTypeEnum::Out ActionType; + IfcActionSourceTypeEnum::Out ActionSource; + Maybe< IfcPositiveRatioMeasure::Out > Coefficient; + Maybe< IfcLabel::Out > Purpose; + }; + + // C++ wrapper for IfcStructuralPlanarAction + struct IfcStructuralPlanarAction : IfcStructuralAction, ObjectHelper<IfcStructuralPlanarAction,1> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {} + IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue; + }; + + // C++ wrapper for IfcStructuralPlanarActionVarying + struct IfcStructuralPlanarActionVarying : IfcStructuralPlanarAction, ObjectHelper<IfcStructuralPlanarActionVarying,2> { IfcStructuralPlanarActionVarying() : Object("IfcStructuralPlanarActionVarying") {} + Lazy< NotImplemented > VaryingAppliedLoadLocation; + ListOf< Lazy< NotImplemented >, 2, 0 > SubsequentAppliedLoads; + }; + + // C++ wrapper for IfcStructuralPointAction + struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {} + + }; + + // C++ wrapper for IfcStructuralPointConnection + struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,0> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {} + + }; + + // C++ wrapper for IfcStructuralReaction + struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {} + + }; + + // 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; + BOOLEAN::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") {} + IfcStructuralSurfaceTypeEnum::Out PredefinedType; + Maybe< IfcPositiveLengthMeasure::Out > Thickness; + }; + + // C++ wrapper for IfcStructuralSurfaceMemberVarying + struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,2> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {} + ListOf< IfcPositiveLengthMeasure, 2, 0 >::Out SubsequentThickness; + Lazy< NotImplemented > VaryingThicknessLocation; + }; + + // C++ wrapper for IfcStructuredDimensionCallout + struct IfcStructuredDimensionCallout : IfcDraughtingCallout, ObjectHelper<IfcStructuredDimensionCallout,0> { IfcStructuredDimensionCallout() : Object("IfcStructuredDimensionCallout") {} + + }; + + // C++ wrapper for IfcStyleModel + struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {} + + }; + + // C++ wrapper for IfcStyledRepresentation + struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {} + + }; + + // C++ wrapper for IfcSubContractResource + struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,2> { IfcSubContractResource() : Object("IfcSubContractResource") {} + Maybe< IfcActorSelect::Out > SubContractor; + Maybe< IfcText::Out > JobDescription; + }; + + // 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; + IfcParameterValue::Out StartParam; + IfcParameterValue::Out EndParam; + Lazy< IfcSurface > ReferenceSurface; + }; + + // C++ wrapper for IfcSweptSurface + struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {} + Lazy< IfcProfileDef > SweptCurve; + 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 : ObjectHelper<IfcSurfaceStyleShading,1> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {} + Lazy< IfcColourRgb > SurfaceColour; + }; + + // C++ wrapper for IfcSurfaceStyleRendering + struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,8> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {} + Maybe< IfcNormalisedRatioMeasure::Out > Transparency; + 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 : 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; + IfcParameterValue::Out StartParam; + IfcParameterValue::Out EndParam; + }; + + // C++ wrapper for IfcSwitchingDeviceType + struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {} + IfcSwitchingDeviceTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcSystemFurnitureElementType + struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,0> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {} + + }; + + // C++ wrapper for IfcTShapeProfileDef + struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,10> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {} + IfcPositiveLengthMeasure::Out Depth; + IfcPositiveLengthMeasure::Out FlangeWidth; + IfcPositiveLengthMeasure::Out WebThickness; + IfcPositiveLengthMeasure::Out FlangeThickness; + Maybe< IfcPositiveLengthMeasure::Out > FilletRadius; + Maybe< IfcPositiveLengthMeasure::Out > FlangeEdgeRadius; + Maybe< IfcPositiveLengthMeasure::Out > WebEdgeRadius; + Maybe< IfcPlaneAngleMeasure::Out > WebSlope; + Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY; + }; + + // C++ wrapper for IfcTankType + struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {} + IfcTankTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcTendon + struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {} + IfcTendonTypeEnum::Out PredefinedType; + IfcPositiveLengthMeasure::Out NominalDiameter; + 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,0> { IfcTendonAnchor() : Object("IfcTendonAnchor") {} + + }; + + // 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 IfcTimeSeriesSchedule + struct IfcTimeSeriesSchedule : IfcControl, ObjectHelper<IfcTimeSeriesSchedule,3> { IfcTimeSeriesSchedule() : Object("IfcTimeSeriesSchedule") {} + Maybe< ListOf< IfcDateTimeSelect, 1, 0 >::Out > ApplicableDates; + IfcTimeSeriesScheduleTypeEnum::Out TimeSeriesScheduleType; + Lazy< NotImplemented > TimeSeries; + }; + + // C++ wrapper for IfcTopologyRepresentation + struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {} + + }; + + // 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,3> { IfcTransportElement() : Object("IfcTransportElement") {} + Maybe< IfcTransportElementTypeEnum::Out > OperationType; + Maybe< IfcMassMeasure::Out > CapacityByWeight; + Maybe< IfcCountMeasure::Out > CapacityByNumber; + }; + + // 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 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; + BOOLEAN::Out SenseAgreement; + IfcTrimmingPreference::Out MasterRepresentation; + }; + + // C++ wrapper for IfcTubeBundleType + struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {} + IfcTubeBundleTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcTwoDirectionRepeatFactor + struct IfcTwoDirectionRepeatFactor : IfcOneDirectionRepeatFactor, ObjectHelper<IfcTwoDirectionRepeatFactor,1> { IfcTwoDirectionRepeatFactor() : Object("IfcTwoDirectionRepeatFactor") {} + Lazy< IfcVector > SecondRepeatFactor; + }; + + // C++ wrapper for IfcUShapeProfileDef + struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,8> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {} + IfcPositiveLengthMeasure::Out Depth; + IfcPositiveLengthMeasure::Out FlangeWidth; + IfcPositiveLengthMeasure::Out WebThickness; + IfcPositiveLengthMeasure::Out FlangeThickness; + Maybe< IfcPositiveLengthMeasure::Out > FilletRadius; + Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius; + Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope; + Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX; + }; + + // C++ wrapper for IfcUnitAssignment + struct IfcUnitAssignment : ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {} + ListOf< IfcUnit, 1, 0 >::Out Units; + }; + + // C++ wrapper for IfcUnitaryEquipmentType + struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {} + IfcUnitaryEquipmentTypeEnum::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 IfcVibrationIsolatorType + struct IfcVibrationIsolatorType : IfcDiscreteAccessoryType, 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 IfcWall + struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,0> { IfcWall() : Object("IfcWall") {} + + }; + + // 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 IfcWasteTerminalType + struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {} + IfcWasteTerminalTypeEnum::Out PredefinedType; + }; + + // C++ wrapper for IfcWindow + struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,2> { IfcWindow() : Object("IfcWindow") {} + Maybe< IfcPositiveLengthMeasure::Out > OverallHeight; + Maybe< IfcPositiveLengthMeasure::Out > OverallWidth; + }; + + // C++ wrapper for IfcWindowStyle + struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {} + IfcWindowStyleConstructionEnum::Out ConstructionType; + IfcWindowStyleOperationEnum::Out OperationType; + BOOLEAN::Out ParameterTakesPrecedence; + BOOLEAN::Out Sizeable; + }; + + // C++ wrapper for IfcWorkControl + struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,10> { IfcWorkControl() : Object("IfcWorkControl") {} + IfcIdentifier::Out Identifier; + IfcDateTimeSelect::Out CreationDate; + Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators; + Maybe< IfcLabel::Out > Purpose; + Maybe< IfcTimeMeasure::Out > Duration; + Maybe< IfcTimeMeasure::Out > TotalFloat; + IfcDateTimeSelect::Out StartTime; + Maybe< IfcDateTimeSelect::Out > FinishTime; + Maybe< IfcWorkControlTypeEnum::Out > WorkControlType; + Maybe< IfcLabel::Out > UserDefinedControlType; + }; + + // C++ wrapper for IfcWorkPlan + struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,0> { IfcWorkPlan() : Object("IfcWorkPlan") {} + + }; + + // C++ wrapper for IfcWorkSchedule + struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,0> { IfcWorkSchedule() : Object("IfcWorkSchedule") {} + + }; + + // 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< IfcPositiveLengthMeasure::Out > FilletRadius; + Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius; + }; + + // C++ wrapper for IfcZone + struct IfcZone : IfcGroup, ObjectHelper<IfcZone,0> { IfcZone() : Object("IfcZone") {} + + }; + + void GetSchema(EXPRESS::ConversionSchema& out); + } //! Schema_2x3 +} //! IFC + +namespace STEP { + + // ****************************************************************************** + // Converter stubs + // ****************************************************************************** + +#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::Schema_2x3::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::Schema_2x3::type* in) + + DECL_CONV_STUB(IfcRepresentationItem); + DECL_CONV_STUB(IfcGeometricRepresentationItem); + DECL_CONV_STUB(IfcCurve); + DECL_CONV_STUB(IfcBoundedCurve); + DECL_CONV_STUB(IfcCompositeCurve); + DECL_CONV_STUB(Ifc2DCompositeCurve); + 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(IfcTypeObject); + DECL_CONV_STUB(IfcTypeProduct); + DECL_CONV_STUB(IfcElementType); + DECL_CONV_STUB(IfcDistributionElementType); + DECL_CONV_STUB(IfcDistributionControlElementType); + DECL_CONV_STUB(IfcActuatorType); + DECL_CONV_STUB(IfcDistributionFlowElementType); + DECL_CONV_STUB(IfcFlowControllerType); + DECL_CONV_STUB(IfcAirTerminalBoxType); + DECL_CONV_STUB(IfcFlowTerminalType); + DECL_CONV_STUB(IfcAirTerminalType); + DECL_CONV_STUB(IfcEnergyConversionDeviceType); + DECL_CONV_STUB(IfcAirToAirHeatRecoveryType); + DECL_CONV_STUB(IfcAlarmType); + DECL_CONV_STUB(IfcDraughtingCallout); + DECL_CONV_STUB(IfcDimensionCurveDirectedCallout); + DECL_CONV_STUB(IfcAngularDimension); + DECL_CONV_STUB(IfcProduct); + DECL_CONV_STUB(IfcAnnotation); + DECL_CONV_STUB(IfcStyledItem); + DECL_CONV_STUB(IfcAnnotationOccurrence); + DECL_CONV_STUB(IfcAnnotationCurveOccurrence); + DECL_CONV_STUB(IfcAnnotationFillArea); + DECL_CONV_STUB(IfcAnnotationFillAreaOccurrence); + DECL_CONV_STUB(IfcAnnotationSurface); + DECL_CONV_STUB(IfcAnnotationSurfaceOccurrence); + DECL_CONV_STUB(IfcAnnotationSymbolOccurrence); + DECL_CONV_STUB(IfcAnnotationTextOccurrence); + 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(IfcIShapeProfileDef); + DECL_CONV_STUB(IfcAsymmetricIShapeProfileDef); + DECL_CONV_STUB(IfcPlacement); + DECL_CONV_STUB(IfcAxis1Placement); + DECL_CONV_STUB(IfcAxis2Placement2D); + DECL_CONV_STUB(IfcAxis2Placement3D); + DECL_CONV_STUB(IfcBSplineCurve); + DECL_CONV_STUB(IfcElement); + DECL_CONV_STUB(IfcBuildingElement); + DECL_CONV_STUB(IfcBeam); + DECL_CONV_STUB(IfcBuildingElementType); + DECL_CONV_STUB(IfcBeamType); + DECL_CONV_STUB(IfcBezierCurve); + DECL_CONV_STUB(IfcCsgPrimitive3D); + DECL_CONV_STUB(IfcBlock); + DECL_CONV_STUB(IfcBoilerType); + DECL_CONV_STUB(IfcBooleanResult); + DECL_CONV_STUB(IfcBooleanClippingResult); + DECL_CONV_STUB(IfcSurface); + DECL_CONV_STUB(IfcBoundedSurface); + DECL_CONV_STUB(IfcBoundingBox); + DECL_CONV_STUB(IfcHalfSpaceSolid); + DECL_CONV_STUB(IfcBoxedHalfSpace); + DECL_CONV_STUB(IfcSpatialStructureElement); + DECL_CONV_STUB(IfcBuilding); + DECL_CONV_STUB(IfcBuildingElementComponent); + DECL_CONV_STUB(IfcBuildingElementPart); + DECL_CONV_STUB(IfcBuildingElementProxy); + DECL_CONV_STUB(IfcBuildingElementProxyType); + DECL_CONV_STUB(IfcBuildingStorey); + DECL_CONV_STUB(IfcCShapeProfileDef); + DECL_CONV_STUB(IfcFlowFittingType); + DECL_CONV_STUB(IfcCableCarrierFittingType); + DECL_CONV_STUB(IfcFlowSegmentType); + DECL_CONV_STUB(IfcCableCarrierSegmentType); + DECL_CONV_STUB(IfcCableSegmentType); + DECL_CONV_STUB(IfcPoint); + DECL_CONV_STUB(IfcCartesianPoint); + 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(IfcFeatureElement); + DECL_CONV_STUB(IfcFeatureElementSubtraction); + DECL_CONV_STUB(IfcEdgeFeature); + DECL_CONV_STUB(IfcChamferEdgeFeature); + DECL_CONV_STUB(IfcChillerType); + DECL_CONV_STUB(IfcConic); + DECL_CONV_STUB(IfcCircle); + DECL_CONV_STUB(IfcCircleProfileDef); + DECL_CONV_STUB(IfcCircleHollowProfileDef); + DECL_CONV_STUB(IfcTopologicalRepresentationItem); + DECL_CONV_STUB(IfcConnectedFaceSet); + DECL_CONV_STUB(IfcClosedShell); + DECL_CONV_STUB(IfcCoilType); + DECL_CONV_STUB(IfcColourSpecification); + DECL_CONV_STUB(IfcColourRgb); + DECL_CONV_STUB(IfcColumn); + DECL_CONV_STUB(IfcColumnType); + DECL_CONV_STUB(IfcProperty); + DECL_CONV_STUB(IfcComplexProperty); + DECL_CONV_STUB(IfcCompositeCurveSegment); + DECL_CONV_STUB(IfcCompositeProfileDef); + DECL_CONV_STUB(IfcFlowMovingDeviceType); + DECL_CONV_STUB(IfcCompressorType); + DECL_CONV_STUB(IfcCondenserType); + DECL_CONV_STUB(IfcCondition); + DECL_CONV_STUB(IfcConditionCriterion); + DECL_CONV_STUB(IfcResource); + DECL_CONV_STUB(IfcConstructionResource); + DECL_CONV_STUB(IfcConstructionEquipmentResource); + DECL_CONV_STUB(IfcConstructionMaterialResource); + DECL_CONV_STUB(IfcConstructionProductResource); + DECL_CONV_STUB(IfcNamedUnit); + DECL_CONV_STUB(IfcContextDependentUnit); + DECL_CONV_STUB(IfcControllerType); + DECL_CONV_STUB(IfcConversionBasedUnit); + DECL_CONV_STUB(IfcCooledBeamType); + DECL_CONV_STUB(IfcCoolingTowerType); + DECL_CONV_STUB(IfcCostItem); + DECL_CONV_STUB(IfcCostSchedule); + DECL_CONV_STUB(IfcCovering); + DECL_CONV_STUB(IfcCoveringType); + DECL_CONV_STUB(IfcCraneRailAShapeProfileDef); + DECL_CONV_STUB(IfcCraneRailFShapeProfileDef); + DECL_CONV_STUB(IfcCrewResource); + DECL_CONV_STUB(IfcSolidModel); + DECL_CONV_STUB(IfcCsgSolid); + DECL_CONV_STUB(IfcCurtainWall); + DECL_CONV_STUB(IfcCurtainWallType); + DECL_CONV_STUB(IfcCurveBoundedPlane); + DECL_CONV_STUB(IfcPresentationStyle); + DECL_CONV_STUB(IfcDamperType); + DECL_CONV_STUB(IfcDefinedSymbol); + DECL_CONV_STUB(IfcDerivedProfileDef); + DECL_CONV_STUB(IfcDiameterDimension); + DECL_CONV_STUB(IfcDimensionCurve); + DECL_CONV_STUB(IfcTerminatorSymbol); + DECL_CONV_STUB(IfcDimensionCurveTerminator); + DECL_CONV_STUB(IfcDirection); + DECL_CONV_STUB(IfcElementComponent); + DECL_CONV_STUB(IfcDiscreteAccessory); + DECL_CONV_STUB(IfcElementComponentType); + DECL_CONV_STUB(IfcDiscreteAccessoryType); + DECL_CONV_STUB(IfcDistributionElement); + DECL_CONV_STUB(IfcDistributionFlowElement); + DECL_CONV_STUB(IfcDistributionChamberElement); + DECL_CONV_STUB(IfcDistributionChamberElementType); + DECL_CONV_STUB(IfcDistributionControlElement); + DECL_CONV_STUB(IfcPort); + DECL_CONV_STUB(IfcDistributionPort); + DECL_CONV_STUB(IfcDoor); + DECL_CONV_STUB(IfcPropertyDefinition); + DECL_CONV_STUB(IfcPropertySetDefinition); + DECL_CONV_STUB(IfcDoorStyle); + DECL_CONV_STUB(IfcDuctFittingType); + DECL_CONV_STUB(IfcDuctSegmentType); + 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(IfcElectricApplianceType); + DECL_CONV_STUB(IfcFlowController); + DECL_CONV_STUB(IfcElectricDistributionPoint); + DECL_CONV_STUB(IfcFlowStorageDeviceType); + DECL_CONV_STUB(IfcElectricFlowStorageDeviceType); + DECL_CONV_STUB(IfcElectricGeneratorType); + DECL_CONV_STUB(IfcElectricHeaterType); + DECL_CONV_STUB(IfcElectricMotorType); + DECL_CONV_STUB(IfcElectricTimeControlType); + DECL_CONV_STUB(IfcSystem); + DECL_CONV_STUB(IfcElectricalCircuit); + DECL_CONV_STUB(IfcElectricalElement); + DECL_CONV_STUB(IfcElementAssembly); + DECL_CONV_STUB(IfcElementQuantity); + DECL_CONV_STUB(IfcElementarySurface); + DECL_CONV_STUB(IfcEllipse); + DECL_CONV_STUB(IfcEllipseProfileDef); + DECL_CONV_STUB(IfcEnergyConversionDevice); + DECL_CONV_STUB(IfcEquipmentElement); + DECL_CONV_STUB(IfcEquipmentStandard); + DECL_CONV_STUB(IfcEvaporativeCoolerType); + DECL_CONV_STUB(IfcEvaporatorType); + DECL_CONV_STUB(IfcSweptAreaSolid); + DECL_CONV_STUB(IfcExtrudedAreaSolid); + DECL_CONV_STUB(IfcFace); + DECL_CONV_STUB(IfcFaceBasedSurfaceModel); + DECL_CONV_STUB(IfcFaceBound); + DECL_CONV_STUB(IfcFaceOuterBound); + DECL_CONV_STUB(IfcFaceSurface); + DECL_CONV_STUB(IfcManifoldSolidBrep); + DECL_CONV_STUB(IfcFacetedBrep); + DECL_CONV_STUB(IfcFacetedBrepWithVoids); + DECL_CONV_STUB(IfcFanType); + DECL_CONV_STUB(IfcFastener); + DECL_CONV_STUB(IfcFastenerType); + DECL_CONV_STUB(IfcFeatureElementAddition); + DECL_CONV_STUB(IfcFillAreaStyleHatching); + DECL_CONV_STUB(IfcFillAreaStyleTileSymbolWithStyle); + DECL_CONV_STUB(IfcFillAreaStyleTiles); + DECL_CONV_STUB(IfcFilterType); + DECL_CONV_STUB(IfcFireSuppressionTerminalType); + DECL_CONV_STUB(IfcFlowFitting); + DECL_CONV_STUB(IfcFlowInstrumentType); + DECL_CONV_STUB(IfcFlowMeterType); + DECL_CONV_STUB(IfcFlowMovingDevice); + DECL_CONV_STUB(IfcFlowSegment); + DECL_CONV_STUB(IfcFlowStorageDevice); + DECL_CONV_STUB(IfcFlowTerminal); + DECL_CONV_STUB(IfcFlowTreatmentDevice); + DECL_CONV_STUB(IfcFooting); + DECL_CONV_STUB(IfcFurnishingElement); + DECL_CONV_STUB(IfcFurnishingElementType); + DECL_CONV_STUB(IfcFurnitureStandard); + DECL_CONV_STUB(IfcFurnitureType); + DECL_CONV_STUB(IfcGasTerminalType); + 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(IfcHeatExchangerType); + DECL_CONV_STUB(IfcHumidifierType); + DECL_CONV_STUB(IfcInventory); + DECL_CONV_STUB(IfcJunctionBoxType); + DECL_CONV_STUB(IfcLShapeProfileDef); + DECL_CONV_STUB(IfcLaborResource); + DECL_CONV_STUB(IfcLampType); + 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(IfcLinearDimension); + 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(IfcMember); + DECL_CONV_STUB(IfcMemberType); + DECL_CONV_STUB(IfcMotorConnectionType); + DECL_CONV_STUB(IfcProcess); + DECL_CONV_STUB(IfcTask); + DECL_CONV_STUB(IfcMove); + DECL_CONV_STUB(IfcOccupant); + DECL_CONV_STUB(IfcOffsetCurve2D); + DECL_CONV_STUB(IfcOffsetCurve3D); + DECL_CONV_STUB(IfcOneDirectionRepeatFactor); + DECL_CONV_STUB(IfcOpenShell); + DECL_CONV_STUB(IfcOpeningElement); + DECL_CONV_STUB(IfcOrderAction); + DECL_CONV_STUB(IfcOrientedEdge); + DECL_CONV_STUB(IfcOutletType); + DECL_CONV_STUB(IfcPath); + DECL_CONV_STUB(IfcPerformanceHistory); + DECL_CONV_STUB(IfcPermit); + DECL_CONV_STUB(IfcPile); + DECL_CONV_STUB(IfcPipeFittingType); + DECL_CONV_STUB(IfcPipeSegmentType); + DECL_CONV_STUB(IfcPlanarExtent); + DECL_CONV_STUB(IfcPlanarBox); + DECL_CONV_STUB(IfcPlane); + DECL_CONV_STUB(IfcPlate); + DECL_CONV_STUB(IfcPlateType); + DECL_CONV_STUB(IfcPointOnCurve); + DECL_CONV_STUB(IfcPointOnSurface); + DECL_CONV_STUB(IfcPolyLoop); + DECL_CONV_STUB(IfcPolygonalBoundedHalfSpace); + DECL_CONV_STUB(IfcPolyline); + DECL_CONV_STUB(IfcPresentationStyleAssignment); + DECL_CONV_STUB(IfcProcedure); + DECL_CONV_STUB(IfcProductDefinitionShape); + DECL_CONV_STUB(IfcProject); + DECL_CONV_STUB(IfcProjectOrder); + DECL_CONV_STUB(IfcProjectOrderRecord); + DECL_CONV_STUB(IfcProjectionCurve); + 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(IfcProtectiveDeviceType); + DECL_CONV_STUB(IfcProxy); + DECL_CONV_STUB(IfcPumpType); + DECL_CONV_STUB(IfcRadiusDimension); + DECL_CONV_STUB(IfcRailing); + DECL_CONV_STUB(IfcRailingType); + DECL_CONV_STUB(IfcRamp); + DECL_CONV_STUB(IfcRampFlight); + DECL_CONV_STUB(IfcRampFlightType); + DECL_CONV_STUB(IfcRationalBezierCurve); + 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(IfcReinforcingMesh); + 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(IfcRelOverridesProperties); + DECL_CONV_STUB(IfcRelVoidsElement); + DECL_CONV_STUB(IfcRepresentation); + DECL_CONV_STUB(IfcRepresentationMap); + DECL_CONV_STUB(IfcRevolvedAreaSolid); + DECL_CONV_STUB(IfcRightCircularCone); + DECL_CONV_STUB(IfcRightCircularCylinder); + DECL_CONV_STUB(IfcRoof); + DECL_CONV_STUB(IfcRoundedEdgeFeature); + DECL_CONV_STUB(IfcRoundedRectangleProfileDef); + DECL_CONV_STUB(IfcSIUnit); + DECL_CONV_STUB(IfcSanitaryTerminalType); + DECL_CONV_STUB(IfcScheduleTimeControl); + DECL_CONV_STUB(IfcSectionedSpine); + DECL_CONV_STUB(IfcSensorType); + DECL_CONV_STUB(IfcServiceLife); + DECL_CONV_STUB(IfcShapeModel); + DECL_CONV_STUB(IfcShapeRepresentation); + DECL_CONV_STUB(IfcShellBasedSurfaceModel); + DECL_CONV_STUB(IfcSite); + DECL_CONV_STUB(IfcSlab); + DECL_CONV_STUB(IfcSlabType); + DECL_CONV_STUB(IfcSpace); + DECL_CONV_STUB(IfcSpaceHeaterType); + DECL_CONV_STUB(IfcSpaceProgram); + DECL_CONV_STUB(IfcSpatialStructureElementType); + DECL_CONV_STUB(IfcSpaceType); + DECL_CONV_STUB(IfcSphere); + DECL_CONV_STUB(IfcStackTerminalType); + DECL_CONV_STUB(IfcStair); + DECL_CONV_STUB(IfcStairFlight); + DECL_CONV_STUB(IfcStairFlightType); + DECL_CONV_STUB(IfcStructuralActivity); + DECL_CONV_STUB(IfcStructuralAction); + DECL_CONV_STUB(IfcStructuralAnalysisModel); + DECL_CONV_STUB(IfcStructuralItem); + DECL_CONV_STUB(IfcStructuralConnection); + DECL_CONV_STUB(IfcStructuralCurveConnection); + DECL_CONV_STUB(IfcStructuralMember); + DECL_CONV_STUB(IfcStructuralCurveMember); + DECL_CONV_STUB(IfcStructuralCurveMemberVarying); + DECL_CONV_STUB(IfcStructuralLinearAction); + DECL_CONV_STUB(IfcStructuralLinearActionVarying); + DECL_CONV_STUB(IfcStructuralLoadGroup); + DECL_CONV_STUB(IfcStructuralPlanarAction); + DECL_CONV_STUB(IfcStructuralPlanarActionVarying); + DECL_CONV_STUB(IfcStructuralPointAction); + DECL_CONV_STUB(IfcStructuralPointConnection); + DECL_CONV_STUB(IfcStructuralReaction); + DECL_CONV_STUB(IfcStructuralPointReaction); + DECL_CONV_STUB(IfcStructuralResultGroup); + DECL_CONV_STUB(IfcStructuralSurfaceConnection); + DECL_CONV_STUB(IfcStructuralSurfaceMember); + DECL_CONV_STUB(IfcStructuralSurfaceMemberVarying); + DECL_CONV_STUB(IfcStructuredDimensionCallout); + DECL_CONV_STUB(IfcStyleModel); + DECL_CONV_STUB(IfcStyledRepresentation); + DECL_CONV_STUB(IfcSubContractResource); + DECL_CONV_STUB(IfcSubedge); + DECL_CONV_STUB(IfcSurfaceCurveSweptAreaSolid); + 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(IfcSwitchingDeviceType); + DECL_CONV_STUB(IfcSystemFurnitureElementType); + DECL_CONV_STUB(IfcTShapeProfileDef); + DECL_CONV_STUB(IfcTankType); + DECL_CONV_STUB(IfcTendon); + DECL_CONV_STUB(IfcTendonAnchor); + DECL_CONV_STUB(IfcTextLiteral); + DECL_CONV_STUB(IfcTextLiteralWithExtent); + DECL_CONV_STUB(IfcTimeSeriesSchedule); + DECL_CONV_STUB(IfcTopologyRepresentation); + DECL_CONV_STUB(IfcTransformerType); + DECL_CONV_STUB(IfcTransportElement); + DECL_CONV_STUB(IfcTransportElementType); + DECL_CONV_STUB(IfcTrapeziumProfileDef); + DECL_CONV_STUB(IfcTrimmedCurve); + DECL_CONV_STUB(IfcTubeBundleType); + DECL_CONV_STUB(IfcTwoDirectionRepeatFactor); + DECL_CONV_STUB(IfcUShapeProfileDef); + DECL_CONV_STUB(IfcUnitAssignment); + DECL_CONV_STUB(IfcUnitaryEquipmentType); + DECL_CONV_STUB(IfcValveType); + DECL_CONV_STUB(IfcVector); + DECL_CONV_STUB(IfcVertex); + DECL_CONV_STUB(IfcVertexLoop); + DECL_CONV_STUB(IfcVertexPoint); + DECL_CONV_STUB(IfcVibrationIsolatorType); + DECL_CONV_STUB(IfcVirtualElement); + DECL_CONV_STUB(IfcWall); + DECL_CONV_STUB(IfcWallStandardCase); + DECL_CONV_STUB(IfcWallType); + DECL_CONV_STUB(IfcWasteTerminalType); + DECL_CONV_STUB(IfcWindow); + DECL_CONV_STUB(IfcWindowStyle); + 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 + +#ifdef _MSC_VER +# pragma warning(pop) +#endif // _MSC_VER + +#endif // INCLUDED_IFC_READER_GEN_H |