
// std lib related includes
#include <tuple>

// pybind 11 related includes
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace py = pybind11;

// Standard Handle
#include <Standard_Handle.hxx>


// includes to resolve forward declarations
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_AssemblyComponentUsage.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_CharacterizedObject.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <StepRepr_ProductDefinitionShape.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <StepBasic_DocumentFile.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_RepresentationContext.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_ConfigurationItem.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_ConfigurationDesign.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_ProductConcept.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_RepresentationMap.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_DataEnvironment.hxx>
#include <StepRepr_Representation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_MeasureValueMember.hxx>
#include <StepBasic_Unit.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_ProductDefinitionShape.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_ProductConceptContext.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_PropertyDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_Representation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_MeasureRepresentationItem.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepShape_QualifiedRepresentationItem.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_RepresentationContext.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_Representation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationReference.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_Representation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_Representation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_GeneralProperty.hxx>
#include <StepRepr_PropertyDefinition.hxx>
#include <StepRepr_PropertyDefinitionRelationship.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_ProductDefinitionShape.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_ProductDefinitionShape.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_NextAssemblyUsageOccurrence.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
#include <StepRepr_FunctionallyDefinedTransformation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepBasic_MeasureValueMember.hxx>
#include <TCollection_HAsciiString.hxx>

// module includes
#include <StepRepr_AllAroundShapeAspect.hxx>
#include <StepRepr_Apex.hxx>
#include <StepRepr_Array1OfMaterialPropertyRepresentation.hxx>
#include <StepRepr_Array1OfPropertyDefinitionRepresentation.hxx>
#include <StepRepr_Array1OfRepresentationItem.hxx>
#include <StepRepr_Array1OfShapeAspect.hxx>
#include <StepRepr_AssemblyComponentUsage.hxx>
#include <StepRepr_AssemblyComponentUsageSubstitute.hxx>
#include <StepRepr_BetweenShapeAspect.hxx>
#include <StepRepr_BooleanRepresentationItem.hxx>
#include <StepRepr_CentreOfSymmetry.hxx>
#include <StepRepr_CharacterizedDefinition.hxx>
#include <StepRepr_CharacterizedRepresentation.hxx>
#include <StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
#include <StepRepr_CompositeGroupShapeAspect.hxx>
#include <StepRepr_CompositeShapeAspect.hxx>
#include <StepRepr_CompoundRepresentationItem.hxx>
#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
#include <StepRepr_ConfigurationDesign.hxx>
#include <StepRepr_ConfigurationDesignItem.hxx>
#include <StepRepr_ConfigurationEffectivity.hxx>
#include <StepRepr_ConfigurationItem.hxx>
#include <StepRepr_ConstructiveGeometryRepresentation.hxx>
#include <StepRepr_ConstructiveGeometryRepresentationRelationship.hxx>
#include <StepRepr_ContinuosShapeAspect.hxx>
#include <StepRepr_DataEnvironment.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
#include <StepRepr_DerivedShapeAspect.hxx>
#include <StepRepr_DescriptiveRepresentationItem.hxx>
#include <StepRepr_Extension.hxx>
#include <StepRepr_ExternallyDefinedRepresentation.hxx>
#include <StepRepr_FeatureForDatumTargetRelationship.hxx>
#include <StepRepr_FunctionallyDefinedTransformation.hxx>
#include <StepRepr_GeometricAlignment.hxx>
#include <StepRepr_GlobalUncertaintyAssignedContext.hxx>
#include <StepRepr_GlobalUnitAssignedContext.hxx>
#include <StepRepr_HArray1OfMaterialPropertyRepresentation.hxx>
#include <StepRepr_HArray1OfPropertyDefinitionRepresentation.hxx>
#include <StepRepr_HArray1OfRepresentationItem.hxx>
#include <StepRepr_HArray1OfShapeAspect.hxx>
#include <StepRepr_HSequenceOfMaterialPropertyRepresentation.hxx>
#include <StepRepr_HSequenceOfRepresentationItem.hxx>
#include <StepRepr_IntegerRepresentationItem.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
#include <StepRepr_MakeFromUsageOption.hxx>
#include <StepRepr_MappedItem.hxx>
#include <StepRepr_MaterialDesignation.hxx>
#include <StepRepr_MaterialProperty.hxx>
#include <StepRepr_MaterialPropertyRepresentation.hxx>
#include <StepRepr_MeasureRepresentationItem.hxx>
#include <StepRepr_MechanicalDesignAndDraughtingRelationship.hxx>
#include <StepRepr_NextAssemblyUsageOccurrence.hxx>
#include <StepRepr_ParallelOffset.hxx>
#include <StepRepr_ParametricRepresentationContext.hxx>
#include <StepRepr_PerpendicularTo.hxx>
#include <StepRepr_ProductConcept.hxx>
#include <StepRepr_ProductDefinitionShape.hxx>
#include <StepRepr_ProductDefinitionUsage.hxx>
#include <StepRepr_PromissoryUsageOccurrence.hxx>
#include <StepRepr_PropertyDefinition.hxx>
#include <StepRepr_PropertyDefinitionRelationship.hxx>
#include <StepRepr_PropertyDefinitionRepresentation.hxx>
#include <StepRepr_QuantifiedAssemblyComponentUsage.hxx>
#include <StepRepr_RealRepresentationItem.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationContext.hxx>
#include <StepRepr_RepresentationContextReference.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_RepresentationMap.hxx>
#include <StepRepr_RepresentationOrRepresentationReference.hxx>
#include <StepRepr_RepresentationReference.hxx>
#include <StepRepr_RepresentationRelationship.hxx>
#include <StepRepr_RepresentationRelationshipWithTransformation.hxx>
#include <StepRepr_RepresentedDefinition.hxx>
#include <StepRepr_ReprItemAndLengthMeasureWithUnit.hxx>
#include <StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx>
#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
#include <StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx>
#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx>
#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
#include <StepRepr_SequenceOfMaterialPropertyRepresentation.hxx>
#include <StepRepr_SequenceOfRepresentationItem.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepRepr_ShapeAspectDerivingRelationship.hxx>
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <StepRepr_ShapeAspectTransition.hxx>
#include <StepRepr_ShapeDefinition.hxx>
#include <StepRepr_ShapeRepresentationRelationship.hxx>
#include <StepRepr_ShapeRepresentationRelationshipWithTransformation.hxx>
#include <StepRepr_SpecifiedHigherUsageOccurrence.hxx>
#include <StepRepr_StructuralResponseProperty.hxx>
#include <StepRepr_StructuralResponsePropertyDefinitionRepresentation.hxx>
#include <StepRepr_SuppliedPartRelationship.hxx>
#include <StepRepr_Tangent.hxx>
#include <StepRepr_Transformation.hxx>
#include <StepRepr_ValueRange.hxx>
#include <StepRepr_ValueRepresentationItem.hxx>

// template related includes

// ./opencascade/StepRepr_Array1OfMaterialPropertyRepresentation.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepRepr_Array1OfPropertyDefinitionRepresentation.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepRepr_Array1OfRepresentationItem.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepRepr_Array1OfShapeAspect.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepRepr_SequenceOfMaterialPropertyRepresentation.hxx
#include "NCollection_tmpl.hxx"

// ./opencascade/StepRepr_SequenceOfRepresentationItem.hxx
#include "NCollection_tmpl.hxx"


// user-defined pre
#include "OCP_specific.inc"

// user-defined inclusion per module

// Module definiiton
void register_StepRepr(py::module &main_module) {


py::module m = static_cast<py::module>(main_module.attr("StepRepr"));
py::object klass;

//Python trampoline classes

// classes

    // Class StepRepr_AssemblyComponentUsageSubstitute from ./opencascade/StepRepr_AssemblyComponentUsageSubstitute.hxx
    klass = m.attr("StepRepr_AssemblyComponentUsageSubstitute");


    // nested enums

    static_cast<py::class_<StepRepr_AssemblyComponentUsageSubstitute ,opencascade::handle<StepRepr_AssemblyComponentUsageSubstitute>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_AssemblyComponentUsage> & ,   const handle<StepRepr_AssemblyComponentUsage> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_AssemblyComponentUsage> & ,   const handle<StepRepr_AssemblyComponentUsage> &  ) >(&StepRepr_AssemblyComponentUsageSubstitute::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDef"),  py::arg("aBase"),  py::arg("aSubs")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_AssemblyComponentUsageSubstitute::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_AssemblyComponentUsageSubstitute::*)() const>(&StepRepr_AssemblyComponentUsageSubstitute::Name),
             R"#()#" 
          )
        .def("SetName",
             (void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_AssemblyComponentUsageSubstitute::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Definition",
             (handle<TCollection_HAsciiString> (StepRepr_AssemblyComponentUsageSubstitute::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_AssemblyComponentUsageSubstitute::*)() const>(&StepRepr_AssemblyComponentUsageSubstitute::Definition),
             R"#()#" 
          )
        .def("SetDefinition",
             (void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_AssemblyComponentUsageSubstitute::SetDefinition),
             R"#()#"  , py::arg("aDef")
          )
        .def("Base",
             (handle<StepRepr_AssemblyComponentUsage> (StepRepr_AssemblyComponentUsageSubstitute::*)() const) static_cast<handle<StepRepr_AssemblyComponentUsage> (StepRepr_AssemblyComponentUsageSubstitute::*)() const>(&StepRepr_AssemblyComponentUsageSubstitute::Base),
             R"#()#" 
          )
        .def("SetBase",
             (void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<StepRepr_AssemblyComponentUsage> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<StepRepr_AssemblyComponentUsage> &  ) >(&StepRepr_AssemblyComponentUsageSubstitute::SetBase),
             R"#()#"  , py::arg("aBase")
          )
        .def("Substitute",
             (handle<StepRepr_AssemblyComponentUsage> (StepRepr_AssemblyComponentUsageSubstitute::*)() const) static_cast<handle<StepRepr_AssemblyComponentUsage> (StepRepr_AssemblyComponentUsageSubstitute::*)() const>(&StepRepr_AssemblyComponentUsageSubstitute::Substitute),
             R"#()#" 
          )
        .def("SetSubstitute",
             (void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<StepRepr_AssemblyComponentUsage> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsageSubstitute::*)(  const handle<StepRepr_AssemblyComponentUsage> &  ) >(&StepRepr_AssemblyComponentUsageSubstitute::SetSubstitute),
             R"#()#"  , py::arg("aSubstitute")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_AssemblyComponentUsageSubstitute::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_AssemblyComponentUsageSubstitute::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_AssemblyComponentUsageSubstitute::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_AssemblyComponentUsageSubstitute::*)() const>(&StepRepr_AssemblyComponentUsageSubstitute::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CharacterizedDefinition from ./opencascade/StepRepr_CharacterizedDefinition.hxx
    klass = m.attr("StepRepr_CharacterizedDefinition");


    // nested enums

    static_cast<py::class_<StepRepr_CharacterizedDefinition , shared_ptr<StepRepr_CharacterizedDefinition>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepRepr_CharacterizedDefinition::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepRepr_CharacterizedDefinition::*)(  const handle<Standard_Transient> &  ) const>(&StepRepr_CharacterizedDefinition::CaseNum),
             R"#(Recognizes a kind of CharacterizedDefinition select type 1 -> CharacterizedObject from StepBasic 2 -> ProductDefinition from StepBasic 3 -> ProductDefinitionRelationship from StepBasic 4 -> ProductDefinitionShape from StepRepr 5 -> ShapeAspect from StepRepr 6 -> ShapeAspectRelationship from StepRepr 7 -> DocumentFile from StepBasic 0 else)#"  , py::arg("ent")
          )
        .def("CharacterizedObject",
             (handle<StepBasic_CharacterizedObject> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepBasic_CharacterizedObject> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::CharacterizedObject),
             R"#(Returns Value as CharacterizedObject (or Null if another type))#" 
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::ProductDefinition),
             R"#(Returns Value as ProductDefinition (or Null if another type))#" 
          )
        .def("ProductDefinitionRelationship",
             (handle<StepBasic_ProductDefinitionRelationship> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepBasic_ProductDefinitionRelationship> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::ProductDefinitionRelationship),
             R"#(Returns Value as ProductDefinitionRelationship (or Null if another type))#" 
          )
        .def("ProductDefinitionShape",
             (handle<StepRepr_ProductDefinitionShape> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepRepr_ProductDefinitionShape> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::ProductDefinitionShape),
             R"#(Returns Value as ProductDefinitionShape (or Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::ShapeAspect),
             R"#(Returns Value as ShapeAspect (or Null if another type))#" 
          )
        .def("ShapeAspectRelationship",
             (handle<StepRepr_ShapeAspectRelationship> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepRepr_ShapeAspectRelationship> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::ShapeAspectRelationship),
             R"#(Returns Value as ShapeAspectRelationship (or Null if another type))#" 
          )
        .def("DocumentFile",
             (handle<StepBasic_DocumentFile> (StepRepr_CharacterizedDefinition::*)() const) static_cast<handle<StepBasic_DocumentFile> (StepRepr_CharacterizedDefinition::*)() const>(&StepRepr_CharacterizedDefinition::DocumentFile),
             R"#(Returns Value as DocumentFile (or Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepRepr_ConfigurationDesign from ./opencascade/StepRepr_ConfigurationDesign.hxx
    klass = m.attr("StepRepr_ConfigurationDesign");


    // nested enums

    static_cast<py::class_<StepRepr_ConfigurationDesign ,opencascade::handle<StepRepr_ConfigurationDesign>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ConfigurationDesign::*)(  const handle<StepRepr_ConfigurationItem> & ,   const StepRepr_ConfigurationDesignItem &  ) ) static_cast<void (StepRepr_ConfigurationDesign::*)(  const handle<StepRepr_ConfigurationItem> & ,   const StepRepr_ConfigurationDesignItem &  ) >(&StepRepr_ConfigurationDesign::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aConfiguration"),  py::arg("aDesign")
          )
        .def("Configuration",
             (handle<StepRepr_ConfigurationItem> (StepRepr_ConfigurationDesign::*)() const) static_cast<handle<StepRepr_ConfigurationItem> (StepRepr_ConfigurationDesign::*)() const>(&StepRepr_ConfigurationDesign::Configuration),
             R"#(Returns field Configuration)#" 
          )
        .def("SetConfiguration",
             (void (StepRepr_ConfigurationDesign::*)(  const handle<StepRepr_ConfigurationItem> &  ) ) static_cast<void (StepRepr_ConfigurationDesign::*)(  const handle<StepRepr_ConfigurationItem> &  ) >(&StepRepr_ConfigurationDesign::SetConfiguration),
             R"#(Set field Configuration)#"  , py::arg("Configuration")
          )
        .def("Design",
             (StepRepr_ConfigurationDesignItem (StepRepr_ConfigurationDesign::*)() const) static_cast<StepRepr_ConfigurationDesignItem (StepRepr_ConfigurationDesign::*)() const>(&StepRepr_ConfigurationDesign::Design),
             R"#(Returns field Design)#" 
          )
        .def("SetDesign",
             (void (StepRepr_ConfigurationDesign::*)(  const StepRepr_ConfigurationDesignItem &  ) ) static_cast<void (StepRepr_ConfigurationDesign::*)(  const StepRepr_ConfigurationDesignItem &  ) >(&StepRepr_ConfigurationDesign::SetDesign),
             R"#(Set field Design)#"  , py::arg("Design")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ConfigurationDesign::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ConfigurationDesign::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ConfigurationDesign::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ConfigurationDesign::*)() const>(&StepRepr_ConfigurationDesign::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ConfigurationDesignItem from ./opencascade/StepRepr_ConfigurationDesignItem.hxx
    klass = m.attr("StepRepr_ConfigurationDesignItem");


    // nested enums

    static_cast<py::class_<StepRepr_ConfigurationDesignItem , shared_ptr<StepRepr_ConfigurationDesignItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepRepr_ConfigurationDesignItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepRepr_ConfigurationDesignItem::*)(  const handle<Standard_Transient> &  ) const>(&StepRepr_ConfigurationDesignItem::CaseNum),
             R"#(Recognizes a kind of ConfigurationDesignItem select type 1 -> ProductDefinition from StepBasic 2 -> ProductDefinitionFormation from StepBasic 0 else)#"  , py::arg("ent")
          )
        .def("ProductDefinition",
             (handle<StepBasic_ProductDefinition> (StepRepr_ConfigurationDesignItem::*)() const) static_cast<handle<StepBasic_ProductDefinition> (StepRepr_ConfigurationDesignItem::*)() const>(&StepRepr_ConfigurationDesignItem::ProductDefinition),
             R"#(Returns Value as ProductDefinition (or Null if another type))#" 
          )
        .def("ProductDefinitionFormation",
             (handle<StepBasic_ProductDefinitionFormation> (StepRepr_ConfigurationDesignItem::*)() const) static_cast<handle<StepBasic_ProductDefinitionFormation> (StepRepr_ConfigurationDesignItem::*)() const>(&StepRepr_ConfigurationDesignItem::ProductDefinitionFormation),
             R"#(Returns Value as ProductDefinitionFormation (or Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepRepr_ConfigurationEffectivity from ./opencascade/StepRepr_ConfigurationEffectivity.hxx
    klass = m.attr("StepRepr_ConfigurationEffectivity");


    // nested enums

    static_cast<py::class_<StepRepr_ConfigurationEffectivity ,opencascade::handle<StepRepr_ConfigurationEffectivity>  , StepBasic_ProductDefinitionEffectivity >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ConfigurationEffectivity::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinitionRelationship> & ,   const handle<StepRepr_ConfigurationDesign> &  ) ) static_cast<void (StepRepr_ConfigurationEffectivity::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinitionRelationship> & ,   const handle<StepRepr_ConfigurationDesign> &  ) >(&StepRepr_ConfigurationEffectivity::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aEffectivity_Id"),  py::arg("aProductDefinitionEffectivity_Usage"),  py::arg("aConfiguration")
          )
        .def("Configuration",
             (handle<StepRepr_ConfigurationDesign> (StepRepr_ConfigurationEffectivity::*)() const) static_cast<handle<StepRepr_ConfigurationDesign> (StepRepr_ConfigurationEffectivity::*)() const>(&StepRepr_ConfigurationEffectivity::Configuration),
             R"#(Returns field Configuration)#" 
          )
        .def("SetConfiguration",
             (void (StepRepr_ConfigurationEffectivity::*)(  const handle<StepRepr_ConfigurationDesign> &  ) ) static_cast<void (StepRepr_ConfigurationEffectivity::*)(  const handle<StepRepr_ConfigurationDesign> &  ) >(&StepRepr_ConfigurationEffectivity::SetConfiguration),
             R"#(Set field Configuration)#"  , py::arg("Configuration")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ConfigurationEffectivity::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ConfigurationEffectivity::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ConfigurationEffectivity::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ConfigurationEffectivity::*)() const>(&StepRepr_ConfigurationEffectivity::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ConfigurationItem from ./opencascade/StepRepr_ConfigurationItem.hxx
    klass = m.attr("StepRepr_ConfigurationItem");


    // nested enums

    static_cast<py::class_<StepRepr_ConfigurationItem ,opencascade::handle<StepRepr_ConfigurationItem>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ProductConcept> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ProductConcept> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ConfigurationItem::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aId"),  py::arg("aName"),  py::arg("hasDescription"),  py::arg("aDescription"),  py::arg("aItemConcept"),  py::arg("hasPurpose"),  py::arg("aPurpose")
          )
        .def("Id",
             (handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::Id),
             R"#(Returns field Id)#" 
          )
        .def("SetId",
             (void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ConfigurationItem::SetId),
             R"#(Set field Id)#"  , py::arg("Id")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::Name),
             R"#(Returns field Name)#" 
          )
        .def("SetName",
             (void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ConfigurationItem::SetName),
             R"#(Set field Name)#"  , py::arg("Name")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::Description),
             R"#(Returns field Description)#" 
          )
        .def("SetDescription",
             (void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ConfigurationItem::SetDescription),
             R"#(Set field Description)#"  , py::arg("Description")
          )
        .def("HasDescription",
             (Standard_Boolean (StepRepr_ConfigurationItem::*)() const) static_cast<Standard_Boolean (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::HasDescription),
             R"#(Returns True if optional field Description is defined)#" 
          )
        .def("ItemConcept",
             (handle<StepRepr_ProductConcept> (StepRepr_ConfigurationItem::*)() const) static_cast<handle<StepRepr_ProductConcept> (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::ItemConcept),
             R"#(Returns field ItemConcept)#" 
          )
        .def("SetItemConcept",
             (void (StepRepr_ConfigurationItem::*)(  const handle<StepRepr_ProductConcept> &  ) ) static_cast<void (StepRepr_ConfigurationItem::*)(  const handle<StepRepr_ProductConcept> &  ) >(&StepRepr_ConfigurationItem::SetItemConcept),
             R"#(Set field ItemConcept)#"  , py::arg("ItemConcept")
          )
        .def("Purpose",
             (handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::Purpose),
             R"#(Returns field Purpose)#" 
          )
        .def("SetPurpose",
             (void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ConfigurationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ConfigurationItem::SetPurpose),
             R"#(Set field Purpose)#"  , py::arg("Purpose")
          )
        .def("HasPurpose",
             (Standard_Boolean (StepRepr_ConfigurationItem::*)() const) static_cast<Standard_Boolean (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::HasPurpose),
             R"#(Returns True if optional field Purpose is defined)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ConfigurationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ConfigurationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ConfigurationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ConfigurationItem::*)() const>(&StepRepr_ConfigurationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_DataEnvironment from ./opencascade/StepRepr_DataEnvironment.hxx
    klass = m.attr("StepRepr_DataEnvironment");


    // nested enums

    static_cast<py::class_<StepRepr_DataEnvironment ,opencascade::handle<StepRepr_DataEnvironment>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_DataEnvironment::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfPropertyDefinitionRepresentation> &  ) ) static_cast<void (StepRepr_DataEnvironment::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfPropertyDefinitionRepresentation> &  ) >(&StepRepr_DataEnvironment::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aElements")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_DataEnvironment::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_DataEnvironment::*)() const>(&StepRepr_DataEnvironment::Name),
             R"#(Returns field Name)#" 
          )
        .def("SetName",
             (void (StepRepr_DataEnvironment::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_DataEnvironment::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_DataEnvironment::SetName),
             R"#(Set field Name)#"  , py::arg("Name")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_DataEnvironment::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_DataEnvironment::*)() const>(&StepRepr_DataEnvironment::Description),
             R"#(Returns field Description)#" 
          )
        .def("SetDescription",
             (void (StepRepr_DataEnvironment::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_DataEnvironment::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_DataEnvironment::SetDescription),
             R"#(Set field Description)#"  , py::arg("Description")
          )
        .def("Elements",
             (handle<StepRepr_HArray1OfPropertyDefinitionRepresentation> (StepRepr_DataEnvironment::*)() const) static_cast<handle<StepRepr_HArray1OfPropertyDefinitionRepresentation> (StepRepr_DataEnvironment::*)() const>(&StepRepr_DataEnvironment::Elements),
             R"#(Returns field Elements)#" 
          )
        .def("SetElements",
             (void (StepRepr_DataEnvironment::*)(  const handle<StepRepr_HArray1OfPropertyDefinitionRepresentation> &  ) ) static_cast<void (StepRepr_DataEnvironment::*)(  const handle<StepRepr_HArray1OfPropertyDefinitionRepresentation> &  ) >(&StepRepr_DataEnvironment::SetElements),
             R"#(Set field Elements)#"  , py::arg("Elements")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_DataEnvironment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_DataEnvironment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_DataEnvironment::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_DataEnvironment::*)() const>(&StepRepr_DataEnvironment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_FunctionallyDefinedTransformation from ./opencascade/StepRepr_FunctionallyDefinedTransformation.hxx
    klass = m.attr("StepRepr_FunctionallyDefinedTransformation");


    // nested enums

    static_cast<py::class_<StepRepr_FunctionallyDefinedTransformation ,opencascade::handle<StepRepr_FunctionallyDefinedTransformation>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_FunctionallyDefinedTransformation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_FunctionallyDefinedTransformation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) >(&StepRepr_FunctionallyDefinedTransformation::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription")
          )
        .def("SetName",
             (void (StepRepr_FunctionallyDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_FunctionallyDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_FunctionallyDefinedTransformation::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_FunctionallyDefinedTransformation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_FunctionallyDefinedTransformation::*)() const>(&StepRepr_FunctionallyDefinedTransformation::Name),
             R"#()#" 
          )
        .def("SetDescription",
             (void (StepRepr_FunctionallyDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_FunctionallyDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_FunctionallyDefinedTransformation::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_FunctionallyDefinedTransformation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_FunctionallyDefinedTransformation::*)() const>(&StepRepr_FunctionallyDefinedTransformation::Description),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_FunctionallyDefinedTransformation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_FunctionallyDefinedTransformation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_FunctionallyDefinedTransformation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_FunctionallyDefinedTransformation::*)() const>(&StepRepr_FunctionallyDefinedTransformation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_HArray1OfMaterialPropertyRepresentation from ./opencascade/StepRepr_HArray1OfMaterialPropertyRepresentation.hxx
    klass = m.attr("StepRepr_HArray1OfMaterialPropertyRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_HArray1OfMaterialPropertyRepresentation ,opencascade::handle<StepRepr_HArray1OfMaterialPropertyRepresentation>  , StepRepr_Array1OfMaterialPropertyRepresentation , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<opencascade::handle<StepRepr_MaterialPropertyRepresentation>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepRepr_MaterialPropertyRepresentation>>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepRepr_Array1OfMaterialPropertyRepresentation & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_HArray1OfMaterialPropertyRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_HArray1OfMaterialPropertyRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepRepr_Array1OfMaterialPropertyRepresentation & (StepRepr_HArray1OfMaterialPropertyRepresentation::*)() const) static_cast< const StepRepr_Array1OfMaterialPropertyRepresentation & (StepRepr_HArray1OfMaterialPropertyRepresentation::*)() const>(&StepRepr_HArray1OfMaterialPropertyRepresentation::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepRepr_Array1OfMaterialPropertyRepresentation & (StepRepr_HArray1OfMaterialPropertyRepresentation::*)() ) static_cast<StepRepr_Array1OfMaterialPropertyRepresentation & (StepRepr_HArray1OfMaterialPropertyRepresentation::*)() >(&StepRepr_HArray1OfMaterialPropertyRepresentation::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_HArray1OfMaterialPropertyRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_HArray1OfMaterialPropertyRepresentation::*)() const>(&StepRepr_HArray1OfMaterialPropertyRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_HArray1OfPropertyDefinitionRepresentation from ./opencascade/StepRepr_HArray1OfPropertyDefinitionRepresentation.hxx
    klass = m.attr("StepRepr_HArray1OfPropertyDefinitionRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_HArray1OfPropertyDefinitionRepresentation ,opencascade::handle<StepRepr_HArray1OfPropertyDefinitionRepresentation>  , StepRepr_Array1OfPropertyDefinitionRepresentation , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<opencascade::handle<StepRepr_PropertyDefinitionRepresentation>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepRepr_PropertyDefinitionRepresentation>>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepRepr_Array1OfPropertyDefinitionRepresentation & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_HArray1OfPropertyDefinitionRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_HArray1OfPropertyDefinitionRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepRepr_Array1OfPropertyDefinitionRepresentation & (StepRepr_HArray1OfPropertyDefinitionRepresentation::*)() const) static_cast< const StepRepr_Array1OfPropertyDefinitionRepresentation & (StepRepr_HArray1OfPropertyDefinitionRepresentation::*)() const>(&StepRepr_HArray1OfPropertyDefinitionRepresentation::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepRepr_Array1OfPropertyDefinitionRepresentation & (StepRepr_HArray1OfPropertyDefinitionRepresentation::*)() ) static_cast<StepRepr_Array1OfPropertyDefinitionRepresentation & (StepRepr_HArray1OfPropertyDefinitionRepresentation::*)() >(&StepRepr_HArray1OfPropertyDefinitionRepresentation::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_HArray1OfPropertyDefinitionRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_HArray1OfPropertyDefinitionRepresentation::*)() const>(&StepRepr_HArray1OfPropertyDefinitionRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_HArray1OfRepresentationItem from ./opencascade/StepRepr_HArray1OfRepresentationItem.hxx
    klass = m.attr("StepRepr_HArray1OfRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_HArray1OfRepresentationItem ,opencascade::handle<StepRepr_HArray1OfRepresentationItem>  , StepRepr_Array1OfRepresentationItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<opencascade::handle<StepRepr_RepresentationItem>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepRepr_RepresentationItem>>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepRepr_Array1OfRepresentationItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_HArray1OfRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_HArray1OfRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepRepr_Array1OfRepresentationItem & (StepRepr_HArray1OfRepresentationItem::*)() const) static_cast< const StepRepr_Array1OfRepresentationItem & (StepRepr_HArray1OfRepresentationItem::*)() const>(&StepRepr_HArray1OfRepresentationItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepRepr_Array1OfRepresentationItem & (StepRepr_HArray1OfRepresentationItem::*)() ) static_cast<StepRepr_Array1OfRepresentationItem & (StepRepr_HArray1OfRepresentationItem::*)() >(&StepRepr_HArray1OfRepresentationItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_HArray1OfRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_HArray1OfRepresentationItem::*)() const>(&StepRepr_HArray1OfRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_HArray1OfShapeAspect from ./opencascade/StepRepr_HArray1OfShapeAspect.hxx
    klass = m.attr("StepRepr_HArray1OfShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_HArray1OfShapeAspect ,opencascade::handle<StepRepr_HArray1OfShapeAspect>  , StepRepr_Array1OfShapeAspect , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("theLower"),  py::arg("theUpper") )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const typename NCollection_Array1<opencascade::handle<StepRepr_ShapeAspect>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepRepr_ShapeAspect>>::value_type &, const Standard_Integer, const Standard_Integer, const bool >()  , py::arg("theBegin"),  py::arg("theLower"),  py::arg("theUpper"),  py::arg("arg3") )
        .def(py::init<  const StepRepr_Array1OfShapeAspect & >()  , py::arg("theOther") )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_HArray1OfShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_HArray1OfShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Array1",
             ( const StepRepr_Array1OfShapeAspect & (StepRepr_HArray1OfShapeAspect::*)() const) static_cast< const StepRepr_Array1OfShapeAspect & (StepRepr_HArray1OfShapeAspect::*)() const>(&StepRepr_HArray1OfShapeAspect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepRepr_Array1OfShapeAspect & (StepRepr_HArray1OfShapeAspect::*)() ) static_cast<StepRepr_Array1OfShapeAspect & (StepRepr_HArray1OfShapeAspect::*)() >(&StepRepr_HArray1OfShapeAspect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_HArray1OfShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_HArray1OfShapeAspect::*)() const>(&StepRepr_HArray1OfShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_HSequenceOfMaterialPropertyRepresentation from ./opencascade/StepRepr_HSequenceOfMaterialPropertyRepresentation.hxx
    klass = m.attr("StepRepr_HSequenceOfMaterialPropertyRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_HSequenceOfMaterialPropertyRepresentation ,opencascade::handle<StepRepr_HSequenceOfMaterialPropertyRepresentation>  , StepRepr_SequenceOfMaterialPropertyRepresentation , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const StepRepr_SequenceOfMaterialPropertyRepresentation & >()  , py::arg("theOther") )
    // custom constructors
    // methods
        .def("Append",
             (void (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)(  const typename NCollection_Sequence<opencascade::handle<StepRepr_MaterialPropertyRepresentation>>::value_type &  ) ) static_cast<void (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)(  const typename NCollection_Sequence<opencascade::handle<StepRepr_MaterialPropertyRepresentation>>::value_type &  ) >(&StepRepr_HSequenceOfMaterialPropertyRepresentation::Append),
             R"#()#"  , py::arg("theItem")
          )
        .def("Append",
             (void (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)( StepRepr_SequenceOfMaterialPropertyRepresentation &  ) ) static_cast<void (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)( StepRepr_SequenceOfMaterialPropertyRepresentation &  ) >(&StepRepr_HSequenceOfMaterialPropertyRepresentation::Append),
             R"#()#"  , py::arg("theSequence")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_HSequenceOfMaterialPropertyRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_HSequenceOfMaterialPropertyRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Sequence",
             ( const StepRepr_SequenceOfMaterialPropertyRepresentation & (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)() const) static_cast< const StepRepr_SequenceOfMaterialPropertyRepresentation & (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)() const>(&StepRepr_HSequenceOfMaterialPropertyRepresentation::Sequence),
             R"#()#"
             
         )
       .def("ChangeSequence",
             (StepRepr_SequenceOfMaterialPropertyRepresentation & (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)() ) static_cast<StepRepr_SequenceOfMaterialPropertyRepresentation & (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)() >(&StepRepr_HSequenceOfMaterialPropertyRepresentation::ChangeSequence),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_HSequenceOfMaterialPropertyRepresentation::*)() const>(&StepRepr_HSequenceOfMaterialPropertyRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_HSequenceOfRepresentationItem from ./opencascade/StepRepr_HSequenceOfRepresentationItem.hxx
    klass = m.attr("StepRepr_HSequenceOfRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_HSequenceOfRepresentationItem ,opencascade::handle<StepRepr_HSequenceOfRepresentationItem>  , StepRepr_SequenceOfRepresentationItem , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const StepRepr_SequenceOfRepresentationItem & >()  , py::arg("theOther") )
    // custom constructors
    // methods
        .def("Append",
             (void (StepRepr_HSequenceOfRepresentationItem::*)(  const typename NCollection_Sequence<opencascade::handle<StepRepr_RepresentationItem>>::value_type &  ) ) static_cast<void (StepRepr_HSequenceOfRepresentationItem::*)(  const typename NCollection_Sequence<opencascade::handle<StepRepr_RepresentationItem>>::value_type &  ) >(&StepRepr_HSequenceOfRepresentationItem::Append),
             R"#()#"  , py::arg("theItem")
          )
        .def("Append",
             (void (StepRepr_HSequenceOfRepresentationItem::*)( StepRepr_SequenceOfRepresentationItem &  ) ) static_cast<void (StepRepr_HSequenceOfRepresentationItem::*)( StepRepr_SequenceOfRepresentationItem &  ) >(&StepRepr_HSequenceOfRepresentationItem::Append),
             R"#()#"  , py::arg("theSequence")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_HSequenceOfRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_HSequenceOfRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Sequence",
             ( const StepRepr_SequenceOfRepresentationItem & (StepRepr_HSequenceOfRepresentationItem::*)() const) static_cast< const StepRepr_SequenceOfRepresentationItem & (StepRepr_HSequenceOfRepresentationItem::*)() const>(&StepRepr_HSequenceOfRepresentationItem::Sequence),
             R"#()#"
             
         )
       .def("ChangeSequence",
             (StepRepr_SequenceOfRepresentationItem & (StepRepr_HSequenceOfRepresentationItem::*)() ) static_cast<StepRepr_SequenceOfRepresentationItem & (StepRepr_HSequenceOfRepresentationItem::*)() >(&StepRepr_HSequenceOfRepresentationItem::ChangeSequence),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_HSequenceOfRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_HSequenceOfRepresentationItem::*)() const>(&StepRepr_HSequenceOfRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ItemDefinedTransformation from ./opencascade/StepRepr_ItemDefinedTransformation.hxx
    klass = m.attr("StepRepr_ItemDefinedTransformation");


    // nested enums

    static_cast<py::class_<StepRepr_ItemDefinedTransformation ,opencascade::handle<StepRepr_ItemDefinedTransformation>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ItemDefinedTransformation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_RepresentationItem> & ,   const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_ItemDefinedTransformation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_RepresentationItem> & ,   const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_ItemDefinedTransformation::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aTransformItem1"),  py::arg("aTransformItem2")
          )
        .def("SetName",
             (void (StepRepr_ItemDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ItemDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ItemDefinedTransformation::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_ItemDefinedTransformation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ItemDefinedTransformation::*)() const>(&StepRepr_ItemDefinedTransformation::Name),
             R"#()#" 
          )
        .def("HasDescription",
             (Standard_Boolean (StepRepr_ItemDefinedTransformation::*)() const) static_cast<Standard_Boolean (StepRepr_ItemDefinedTransformation::*)() const>(&StepRepr_ItemDefinedTransformation::HasDescription),
             R"#()#" 
          )
        .def("SetDescription",
             (void (StepRepr_ItemDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ItemDefinedTransformation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ItemDefinedTransformation::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_ItemDefinedTransformation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ItemDefinedTransformation::*)() const>(&StepRepr_ItemDefinedTransformation::Description),
             R"#()#" 
          )
        .def("SetTransformItem1",
             (void (StepRepr_ItemDefinedTransformation::*)(  const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_ItemDefinedTransformation::*)(  const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_ItemDefinedTransformation::SetTransformItem1),
             R"#()#"  , py::arg("aItem")
          )
        .def("TransformItem1",
             (handle<StepRepr_RepresentationItem> (StepRepr_ItemDefinedTransformation::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_ItemDefinedTransformation::*)() const>(&StepRepr_ItemDefinedTransformation::TransformItem1),
             R"#()#" 
          )
        .def("SetTransformItem2",
             (void (StepRepr_ItemDefinedTransformation::*)(  const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_ItemDefinedTransformation::*)(  const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_ItemDefinedTransformation::SetTransformItem2),
             R"#()#"  , py::arg("aItem")
          )
        .def("TransformItem2",
             (handle<StepRepr_RepresentationItem> (StepRepr_ItemDefinedTransformation::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_ItemDefinedTransformation::*)() const>(&StepRepr_ItemDefinedTransformation::TransformItem2),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ItemDefinedTransformation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ItemDefinedTransformation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ItemDefinedTransformation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ItemDefinedTransformation::*)() const>(&StepRepr_ItemDefinedTransformation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MaterialDesignation from ./opencascade/StepRepr_MaterialDesignation.hxx
    klass = m.attr("StepRepr_MaterialDesignation");


    // nested enums

    static_cast<py::class_<StepRepr_MaterialDesignation ,opencascade::handle<StepRepr_MaterialDesignation>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_MaterialDesignation::*)(  const handle<TCollection_HAsciiString> & ,   const StepRepr_CharacterizedDefinition &  ) ) static_cast<void (StepRepr_MaterialDesignation::*)(  const handle<TCollection_HAsciiString> & ,   const StepRepr_CharacterizedDefinition &  ) >(&StepRepr_MaterialDesignation::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aOfDefinition")
          )
        .def("SetName",
             (void (StepRepr_MaterialDesignation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_MaterialDesignation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_MaterialDesignation::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_MaterialDesignation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_MaterialDesignation::*)() const>(&StepRepr_MaterialDesignation::Name),
             R"#()#" 
          )
        .def("SetOfDefinition",
             (void (StepRepr_MaterialDesignation::*)(  const StepRepr_CharacterizedDefinition &  ) ) static_cast<void (StepRepr_MaterialDesignation::*)(  const StepRepr_CharacterizedDefinition &  ) >(&StepRepr_MaterialDesignation::SetOfDefinition),
             R"#()#"  , py::arg("aOfDefinition")
          )
        .def("OfDefinition",
             (StepRepr_CharacterizedDefinition (StepRepr_MaterialDesignation::*)() const) static_cast<StepRepr_CharacterizedDefinition (StepRepr_MaterialDesignation::*)() const>(&StepRepr_MaterialDesignation::OfDefinition),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MaterialDesignation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MaterialDesignation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MaterialDesignation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MaterialDesignation::*)() const>(&StepRepr_MaterialDesignation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ProductConcept from ./opencascade/StepRepr_ProductConcept.hxx
    klass = m.attr("StepRepr_ProductConcept");


    // nested enums

    static_cast<py::class_<StepRepr_ProductConcept ,opencascade::handle<StepRepr_ProductConcept>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductConceptContext> &  ) ) static_cast<void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductConceptContext> &  ) >(&StepRepr_ProductConcept::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aId"),  py::arg("aName"),  py::arg("hasDescription"),  py::arg("aDescription"),  py::arg("aMarketContext")
          )
        .def("Id",
             (handle<TCollection_HAsciiString> (StepRepr_ProductConcept::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ProductConcept::*)() const>(&StepRepr_ProductConcept::Id),
             R"#(Returns field Id)#" 
          )
        .def("SetId",
             (void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ProductConcept::SetId),
             R"#(Set field Id)#"  , py::arg("Id")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_ProductConcept::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ProductConcept::*)() const>(&StepRepr_ProductConcept::Name),
             R"#(Returns field Name)#" 
          )
        .def("SetName",
             (void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ProductConcept::SetName),
             R"#(Set field Name)#"  , py::arg("Name")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_ProductConcept::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ProductConcept::*)() const>(&StepRepr_ProductConcept::Description),
             R"#(Returns field Description)#" 
          )
        .def("SetDescription",
             (void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ProductConcept::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ProductConcept::SetDescription),
             R"#(Set field Description)#"  , py::arg("Description")
          )
        .def("HasDescription",
             (Standard_Boolean (StepRepr_ProductConcept::*)() const) static_cast<Standard_Boolean (StepRepr_ProductConcept::*)() const>(&StepRepr_ProductConcept::HasDescription),
             R"#(Returns True if optional field Description is defined)#" 
          )
        .def("MarketContext",
             (handle<StepBasic_ProductConceptContext> (StepRepr_ProductConcept::*)() const) static_cast<handle<StepBasic_ProductConceptContext> (StepRepr_ProductConcept::*)() const>(&StepRepr_ProductConcept::MarketContext),
             R"#(Returns field MarketContext)#" 
          )
        .def("SetMarketContext",
             (void (StepRepr_ProductConcept::*)(  const handle<StepBasic_ProductConceptContext> &  ) ) static_cast<void (StepRepr_ProductConcept::*)(  const handle<StepBasic_ProductConceptContext> &  ) >(&StepRepr_ProductConcept::SetMarketContext),
             R"#(Set field MarketContext)#"  , py::arg("MarketContext")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ProductConcept::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ProductConcept::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ProductConcept::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ProductConcept::*)() const>(&StepRepr_ProductConcept::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ProductDefinitionUsage from ./opencascade/StepRepr_ProductDefinitionUsage.hxx
    klass = m.attr("StepRepr_ProductDefinitionUsage");


    // nested enums

    static_cast<py::class_<StepRepr_ProductDefinitionUsage ,opencascade::handle<StepRepr_ProductDefinitionUsage>  , StepBasic_ProductDefinitionRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ProductDefinitionUsage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ProductDefinitionUsage::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ProductDefinitionUsage::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ProductDefinitionUsage::*)() const>(&StepRepr_ProductDefinitionUsage::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_PropertyDefinition from ./opencascade/StepRepr_PropertyDefinition.hxx
    klass = m.attr("StepRepr_PropertyDefinition");


    // nested enums

    static_cast<py::class_<StepRepr_PropertyDefinition ,opencascade::handle<StepRepr_PropertyDefinition>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_PropertyDefinition::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepRepr_CharacterizedDefinition &  ) ) static_cast<void (StepRepr_PropertyDefinition::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepRepr_CharacterizedDefinition &  ) >(&StepRepr_PropertyDefinition::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aName"),  py::arg("hasDescription"),  py::arg("aDescription"),  py::arg("aDefinition")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_PropertyDefinition::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_PropertyDefinition::*)() const>(&StepRepr_PropertyDefinition::Name),
             R"#(Returns field Name)#" 
          )
        .def("SetName",
             (void (StepRepr_PropertyDefinition::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_PropertyDefinition::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_PropertyDefinition::SetName),
             R"#(Set field Name)#"  , py::arg("Name")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_PropertyDefinition::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_PropertyDefinition::*)() const>(&StepRepr_PropertyDefinition::Description),
             R"#(Returns field Description)#" 
          )
        .def("SetDescription",
             (void (StepRepr_PropertyDefinition::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_PropertyDefinition::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_PropertyDefinition::SetDescription),
             R"#(Set field Description)#"  , py::arg("Description")
          )
        .def("HasDescription",
             (Standard_Boolean (StepRepr_PropertyDefinition::*)() const) static_cast<Standard_Boolean (StepRepr_PropertyDefinition::*)() const>(&StepRepr_PropertyDefinition::HasDescription),
             R"#(Returns True if optional field Description is defined)#" 
          )
        .def("Definition",
             (StepRepr_CharacterizedDefinition (StepRepr_PropertyDefinition::*)() const) static_cast<StepRepr_CharacterizedDefinition (StepRepr_PropertyDefinition::*)() const>(&StepRepr_PropertyDefinition::Definition),
             R"#(Returns field Definition)#" 
          )
        .def("SetDefinition",
             (void (StepRepr_PropertyDefinition::*)(  const StepRepr_CharacterizedDefinition &  ) ) static_cast<void (StepRepr_PropertyDefinition::*)(  const StepRepr_CharacterizedDefinition &  ) >(&StepRepr_PropertyDefinition::SetDefinition),
             R"#(Set field Definition)#"  , py::arg("Definition")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_PropertyDefinition::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_PropertyDefinition::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_PropertyDefinition::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_PropertyDefinition::*)() const>(&StepRepr_PropertyDefinition::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_PropertyDefinitionRelationship from ./opencascade/StepRepr_PropertyDefinitionRelationship.hxx
    klass = m.attr("StepRepr_PropertyDefinitionRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_PropertyDefinitionRelationship ,opencascade::handle<StepRepr_PropertyDefinitionRelationship>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_PropertyDefinition> & ,   const handle<StepRepr_PropertyDefinition> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_PropertyDefinition> & ,   const handle<StepRepr_PropertyDefinition> &  ) >(&StepRepr_PropertyDefinitionRelationship::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aRelatingPropertyDefinition"),  py::arg("aRelatedPropertyDefinition")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_PropertyDefinitionRelationship::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_PropertyDefinitionRelationship::*)() const>(&StepRepr_PropertyDefinitionRelationship::Name),
             R"#(Returns field Name)#" 
          )
        .def("SetName",
             (void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_PropertyDefinitionRelationship::SetName),
             R"#(Set field Name)#"  , py::arg("Name")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_PropertyDefinitionRelationship::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_PropertyDefinitionRelationship::*)() const>(&StepRepr_PropertyDefinitionRelationship::Description),
             R"#(Returns field Description)#" 
          )
        .def("SetDescription",
             (void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_PropertyDefinitionRelationship::SetDescription),
             R"#(Set field Description)#"  , py::arg("Description")
          )
        .def("RelatingPropertyDefinition",
             (handle<StepRepr_PropertyDefinition> (StepRepr_PropertyDefinitionRelationship::*)() const) static_cast<handle<StepRepr_PropertyDefinition> (StepRepr_PropertyDefinitionRelationship::*)() const>(&StepRepr_PropertyDefinitionRelationship::RelatingPropertyDefinition),
             R"#(Returns field RelatingPropertyDefinition)#" 
          )
        .def("SetRelatingPropertyDefinition",
             (void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<StepRepr_PropertyDefinition> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<StepRepr_PropertyDefinition> &  ) >(&StepRepr_PropertyDefinitionRelationship::SetRelatingPropertyDefinition),
             R"#(Set field RelatingPropertyDefinition)#"  , py::arg("RelatingPropertyDefinition")
          )
        .def("RelatedPropertyDefinition",
             (handle<StepRepr_PropertyDefinition> (StepRepr_PropertyDefinitionRelationship::*)() const) static_cast<handle<StepRepr_PropertyDefinition> (StepRepr_PropertyDefinitionRelationship::*)() const>(&StepRepr_PropertyDefinitionRelationship::RelatedPropertyDefinition),
             R"#(Returns field RelatedPropertyDefinition)#" 
          )
        .def("SetRelatedPropertyDefinition",
             (void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<StepRepr_PropertyDefinition> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRelationship::*)(  const handle<StepRepr_PropertyDefinition> &  ) >(&StepRepr_PropertyDefinitionRelationship::SetRelatedPropertyDefinition),
             R"#(Set field RelatedPropertyDefinition)#"  , py::arg("RelatedPropertyDefinition")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_PropertyDefinitionRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_PropertyDefinitionRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_PropertyDefinitionRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_PropertyDefinitionRelationship::*)() const>(&StepRepr_PropertyDefinitionRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_PropertyDefinitionRepresentation from ./opencascade/StepRepr_PropertyDefinitionRepresentation.hxx
    klass = m.attr("StepRepr_PropertyDefinitionRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_PropertyDefinitionRepresentation ,opencascade::handle<StepRepr_PropertyDefinitionRepresentation>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_PropertyDefinitionRepresentation::*)(  const StepRepr_RepresentedDefinition & ,   const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRepresentation::*)(  const StepRepr_RepresentedDefinition & ,   const handle<StepRepr_Representation> &  ) >(&StepRepr_PropertyDefinitionRepresentation::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aDefinition"),  py::arg("aUsedRepresentation")
          )
        .def("Definition",
             (StepRepr_RepresentedDefinition (StepRepr_PropertyDefinitionRepresentation::*)() const) static_cast<StepRepr_RepresentedDefinition (StepRepr_PropertyDefinitionRepresentation::*)() const>(&StepRepr_PropertyDefinitionRepresentation::Definition),
             R"#(Returns field Definition)#" 
          )
        .def("SetDefinition",
             (void (StepRepr_PropertyDefinitionRepresentation::*)(  const StepRepr_RepresentedDefinition &  ) ) static_cast<void (StepRepr_PropertyDefinitionRepresentation::*)(  const StepRepr_RepresentedDefinition &  ) >(&StepRepr_PropertyDefinitionRepresentation::SetDefinition),
             R"#(Set field Definition)#"  , py::arg("Definition")
          )
        .def("UsedRepresentation",
             (handle<StepRepr_Representation> (StepRepr_PropertyDefinitionRepresentation::*)() const) static_cast<handle<StepRepr_Representation> (StepRepr_PropertyDefinitionRepresentation::*)() const>(&StepRepr_PropertyDefinitionRepresentation::UsedRepresentation),
             R"#(Returns field UsedRepresentation)#" 
          )
        .def("SetUsedRepresentation",
             (void (StepRepr_PropertyDefinitionRepresentation::*)(  const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_PropertyDefinitionRepresentation::*)(  const handle<StepRepr_Representation> &  ) >(&StepRepr_PropertyDefinitionRepresentation::SetUsedRepresentation),
             R"#(Set field UsedRepresentation)#"  , py::arg("UsedRepresentation")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_PropertyDefinitionRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_PropertyDefinitionRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_PropertyDefinitionRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_PropertyDefinitionRepresentation::*)() const>(&StepRepr_PropertyDefinitionRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_Representation from ./opencascade/StepRepr_Representation.hxx
    klass = m.attr("StepRepr_Representation");


    // nested enums

    static_cast<py::class_<StepRepr_Representation ,opencascade::handle<StepRepr_Representation>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_Representation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> & ,   const handle<StepRepr_RepresentationContext> &  ) ) static_cast<void (StepRepr_Representation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> & ,   const handle<StepRepr_RepresentationContext> &  ) >(&StepRepr_Representation::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aItems"),  py::arg("aContextOfItems")
          )
        .def("SetName",
             (void (StepRepr_Representation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_Representation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_Representation::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_Representation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_Representation::*)() const>(&StepRepr_Representation::Name),
             R"#()#" 
          )
        .def("SetItems",
             (void (StepRepr_Representation::*)(  const handle<StepRepr_HArray1OfRepresentationItem> &  ) ) static_cast<void (StepRepr_Representation::*)(  const handle<StepRepr_HArray1OfRepresentationItem> &  ) >(&StepRepr_Representation::SetItems),
             R"#()#"  , py::arg("aItems")
          )
        .def("Items",
             (handle<StepRepr_HArray1OfRepresentationItem> (StepRepr_Representation::*)() const) static_cast<handle<StepRepr_HArray1OfRepresentationItem> (StepRepr_Representation::*)() const>(&StepRepr_Representation::Items),
             R"#()#" 
          )
        .def("ItemsValue",
             (handle<StepRepr_RepresentationItem> (StepRepr_Representation::*)(  const Standard_Integer  ) const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_Representation::*)(  const Standard_Integer  ) const>(&StepRepr_Representation::ItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbItems",
             (Standard_Integer (StepRepr_Representation::*)() const) static_cast<Standard_Integer (StepRepr_Representation::*)() const>(&StepRepr_Representation::NbItems),
             R"#()#" 
          )
        .def("SetContextOfItems",
             (void (StepRepr_Representation::*)(  const handle<StepRepr_RepresentationContext> &  ) ) static_cast<void (StepRepr_Representation::*)(  const handle<StepRepr_RepresentationContext> &  ) >(&StepRepr_Representation::SetContextOfItems),
             R"#()#"  , py::arg("aContextOfItems")
          )
        .def("ContextOfItems",
             (handle<StepRepr_RepresentationContext> (StepRepr_Representation::*)() const) static_cast<handle<StepRepr_RepresentationContext> (StepRepr_Representation::*)() const>(&StepRepr_Representation::ContextOfItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_Representation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_Representation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_Representation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_Representation::*)() const>(&StepRepr_Representation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationContext from ./opencascade/StepRepr_RepresentationContext.hxx
    klass = m.attr("StepRepr_RepresentationContext");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationContext ,opencascade::handle<StepRepr_RepresentationContext>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationContext::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationContext::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationContext::Init),
             R"#()#"  , py::arg("aContextIdentifier"),  py::arg("aContextType")
          )
        .def("SetContextIdentifier",
             (void (StepRepr_RepresentationContext::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationContext::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationContext::SetContextIdentifier),
             R"#()#"  , py::arg("aContextIdentifier")
          )
        .def("ContextIdentifier",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationContext::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationContext::*)() const>(&StepRepr_RepresentationContext::ContextIdentifier),
             R"#()#" 
          )
        .def("SetContextType",
             (void (StepRepr_RepresentationContext::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationContext::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationContext::SetContextType),
             R"#()#"  , py::arg("aContextType")
          )
        .def("ContextType",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationContext::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationContext::*)() const>(&StepRepr_RepresentationContext::ContextType),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationContext::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationContext::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationContext::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationContext::*)() const>(&StepRepr_RepresentationContext::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationContextReference from ./opencascade/StepRepr_RepresentationContextReference.hxx
    klass = m.attr("StepRepr_RepresentationContextReference");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationContextReference ,opencascade::handle<StepRepr_RepresentationContextReference>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationContextReference::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationContextReference::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationContextReference::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theContextIdentifier")
          )
        .def("ContextIdentifier",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationContextReference::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationContextReference::*)() const>(&StepRepr_RepresentationContextReference::ContextIdentifier),
             R"#(Returns field ContextIdentifier)#" 
          )
        .def("SetContextIdentifier",
             (void (StepRepr_RepresentationContextReference::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationContextReference::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationContextReference::SetContextIdentifier),
             R"#(Sets field ContextIdentifier)#"  , py::arg("theContextIdentifier")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationContextReference::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationContextReference::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationContextReference::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationContextReference::*)() const>(&StepRepr_RepresentationContextReference::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationItem from ./opencascade/StepRepr_RepresentationItem.hxx
    klass = m.attr("StepRepr_RepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationItem ,opencascade::handle<StepRepr_RepresentationItem>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationItem::Init),
             R"#()#"  , py::arg("aName")
          )
        .def("SetName",
             (void (StepRepr_RepresentationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationItem::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationItem::*)() const>(&StepRepr_RepresentationItem::Name),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationItem::*)() const>(&StepRepr_RepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationMap from ./opencascade/StepRepr_RepresentationMap.hxx
    klass = m.attr("StepRepr_RepresentationMap");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationMap ,opencascade::handle<StepRepr_RepresentationMap>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationMap::*)(  const handle<StepRepr_RepresentationItem> & ,   const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_RepresentationMap::*)(  const handle<StepRepr_RepresentationItem> & ,   const handle<StepRepr_Representation> &  ) >(&StepRepr_RepresentationMap::Init),
             R"#()#"  , py::arg("aMappingOrigin"),  py::arg("aMappedRepresentation")
          )
        .def("SetMappingOrigin",
             (void (StepRepr_RepresentationMap::*)(  const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_RepresentationMap::*)(  const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_RepresentationMap::SetMappingOrigin),
             R"#()#"  , py::arg("aMappingOrigin")
          )
        .def("MappingOrigin",
             (handle<StepRepr_RepresentationItem> (StepRepr_RepresentationMap::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_RepresentationMap::*)() const>(&StepRepr_RepresentationMap::MappingOrigin),
             R"#()#" 
          )
        .def("SetMappedRepresentation",
             (void (StepRepr_RepresentationMap::*)(  const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_RepresentationMap::*)(  const handle<StepRepr_Representation> &  ) >(&StepRepr_RepresentationMap::SetMappedRepresentation),
             R"#()#"  , py::arg("aMappedRepresentation")
          )
        .def("MappedRepresentation",
             (handle<StepRepr_Representation> (StepRepr_RepresentationMap::*)() const) static_cast<handle<StepRepr_Representation> (StepRepr_RepresentationMap::*)() const>(&StepRepr_RepresentationMap::MappedRepresentation),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationMap::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationMap::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationMap::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationMap::*)() const>(&StepRepr_RepresentationMap::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationOrRepresentationReference from ./opencascade/StepRepr_RepresentationOrRepresentationReference.hxx
    klass = m.attr("StepRepr_RepresentationOrRepresentationReference");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationOrRepresentationReference , shared_ptr<StepRepr_RepresentationOrRepresentationReference>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepRepr_RepresentationOrRepresentationReference::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepRepr_RepresentationOrRepresentationReference::*)(  const handle<Standard_Transient> &  ) const>(&StepRepr_RepresentationOrRepresentationReference::CaseNum),
             R"#(Recognizes a kind of RepresentationOrRepresentationReference select type -- 1 -> Representation -- 2 -> RepresentationReference)#"  , py::arg("ent")
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepRepr_RepresentationOrRepresentationReference::*)() const) static_cast<handle<StepRepr_Representation> (StepRepr_RepresentationOrRepresentationReference::*)() const>(&StepRepr_RepresentationOrRepresentationReference::Representation),
             R"#(Returns Value as Representation (or Null if another type))#" 
          )
        .def("RepresentationReference",
             (handle<StepRepr_RepresentationReference> (StepRepr_RepresentationOrRepresentationReference::*)() const) static_cast<handle<StepRepr_RepresentationReference> (StepRepr_RepresentationOrRepresentationReference::*)() const>(&StepRepr_RepresentationOrRepresentationReference::RepresentationReference),
             R"#(Returns Value as RepresentationReference (or Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepRepr_RepresentationReference from ./opencascade/StepRepr_RepresentationReference.hxx
    klass = m.attr("StepRepr_RepresentationReference");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationReference ,opencascade::handle<StepRepr_RepresentationReference>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationReference::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_RepresentationContextReference> &  ) ) static_cast<void (StepRepr_RepresentationReference::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_RepresentationContextReference> &  ) >(&StepRepr_RepresentationReference::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theId"),  py::arg("theContextOfItems")
          )
        .def("Id",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationReference::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationReference::*)() const>(&StepRepr_RepresentationReference::Id),
             R"#(Returns field Id)#" 
          )
        .def("SetId",
             (void (StepRepr_RepresentationReference::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationReference::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationReference::SetId),
             R"#(Sets field Id)#"  , py::arg("theId")
          )
        .def("ContextOfItems",
             (handle<StepRepr_RepresentationContextReference> (StepRepr_RepresentationReference::*)() const) static_cast<handle<StepRepr_RepresentationContextReference> (StepRepr_RepresentationReference::*)() const>(&StepRepr_RepresentationReference::ContextOfItems),
             R"#(Returns field ContextOfItems)#" 
          )
        .def("SetContextOfItems",
             (void (StepRepr_RepresentationReference::*)(  const handle<StepRepr_RepresentationContextReference> &  ) ) static_cast<void (StepRepr_RepresentationReference::*)(  const handle<StepRepr_RepresentationContextReference> &  ) >(&StepRepr_RepresentationReference::SetContextOfItems),
             R"#(Sets field ContextOfItems)#"  , py::arg("theContextOfItems")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationReference::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationReference::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationReference::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationReference::*)() const>(&StepRepr_RepresentationReference::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationRelationship from ./opencascade/StepRepr_RepresentationRelationship.hxx
    klass = m.attr("StepRepr_RepresentationRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationRelationship ,opencascade::handle<StepRepr_RepresentationRelationship>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationRelationship::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_Representation> & ,   const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_RepresentationRelationship::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_Representation> & ,   const handle<StepRepr_Representation> &  ) >(&StepRepr_RepresentationRelationship::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aRep1"),  py::arg("aRep2")
          )
        .def("SetName",
             (void (StepRepr_RepresentationRelationship::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationRelationship::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationRelationship::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationRelationship::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationRelationship::*)() const>(&StepRepr_RepresentationRelationship::Name),
             R"#()#" 
          )
        .def("HasDescription",
             (Standard_Boolean (StepRepr_RepresentationRelationship::*)() ) static_cast<Standard_Boolean (StepRepr_RepresentationRelationship::*)() >(&StepRepr_RepresentationRelationship::HasDescription),
             R"#()#" 
          )
        .def("SetDescription",
             (void (StepRepr_RepresentationRelationship::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_RepresentationRelationship::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_RepresentationRelationship::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_RepresentationRelationship::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_RepresentationRelationship::*)() const>(&StepRepr_RepresentationRelationship::Description),
             R"#()#" 
          )
        .def("SetRep1",
             (void (StepRepr_RepresentationRelationship::*)(  const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_RepresentationRelationship::*)(  const handle<StepRepr_Representation> &  ) >(&StepRepr_RepresentationRelationship::SetRep1),
             R"#()#"  , py::arg("aRep1")
          )
        .def("Rep1",
             (handle<StepRepr_Representation> (StepRepr_RepresentationRelationship::*)() const) static_cast<handle<StepRepr_Representation> (StepRepr_RepresentationRelationship::*)() const>(&StepRepr_RepresentationRelationship::Rep1),
             R"#()#" 
          )
        .def("SetRep2",
             (void (StepRepr_RepresentationRelationship::*)(  const handle<StepRepr_Representation> &  ) ) static_cast<void (StepRepr_RepresentationRelationship::*)(  const handle<StepRepr_Representation> &  ) >(&StepRepr_RepresentationRelationship::SetRep2),
             R"#()#"  , py::arg("aRep2")
          )
        .def("Rep2",
             (handle<StepRepr_Representation> (StepRepr_RepresentationRelationship::*)() const) static_cast<handle<StepRepr_Representation> (StepRepr_RepresentationRelationship::*)() const>(&StepRepr_RepresentationRelationship::Rep2),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationRelationship::*)() const>(&StepRepr_RepresentationRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentedDefinition from ./opencascade/StepRepr_RepresentedDefinition.hxx
    klass = m.attr("StepRepr_RepresentedDefinition");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentedDefinition , shared_ptr<StepRepr_RepresentedDefinition>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepRepr_RepresentedDefinition::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepRepr_RepresentedDefinition::*)(  const handle<Standard_Transient> &  ) const>(&StepRepr_RepresentedDefinition::CaseNum),
             R"#(Recognizes a kind of RepresentedDefinition select type 1 -> GeneralProperty from StepBasic 2 -> PropertyDefinition from StepRepr 3 -> PropertyDefinitionRelationship from StepRepr 4 -> ShapeAspect from StepRepr 5 -> ShapeAspectRelationship from StepRepr 0 else)#"  , py::arg("ent")
          )
        .def("GeneralProperty",
             (handle<StepBasic_GeneralProperty> (StepRepr_RepresentedDefinition::*)() const) static_cast<handle<StepBasic_GeneralProperty> (StepRepr_RepresentedDefinition::*)() const>(&StepRepr_RepresentedDefinition::GeneralProperty),
             R"#(Returns Value as GeneralProperty (or Null if another type))#" 
          )
        .def("PropertyDefinition",
             (handle<StepRepr_PropertyDefinition> (StepRepr_RepresentedDefinition::*)() const) static_cast<handle<StepRepr_PropertyDefinition> (StepRepr_RepresentedDefinition::*)() const>(&StepRepr_RepresentedDefinition::PropertyDefinition),
             R"#(Returns Value as PropertyDefinition (or Null if another type))#" 
          )
        .def("PropertyDefinitionRelationship",
             (handle<StepRepr_PropertyDefinitionRelationship> (StepRepr_RepresentedDefinition::*)() const) static_cast<handle<StepRepr_PropertyDefinitionRelationship> (StepRepr_RepresentedDefinition::*)() const>(&StepRepr_RepresentedDefinition::PropertyDefinitionRelationship),
             R"#(Returns Value as PropertyDefinitionRelationship (or Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepRepr_RepresentedDefinition::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepRepr_RepresentedDefinition::*)() const>(&StepRepr_RepresentedDefinition::ShapeAspect),
             R"#(Returns Value as ShapeAspect (or Null if another type))#" 
          )
        .def("ShapeAspectRelationship",
             (handle<StepRepr_ShapeAspectRelationship> (StepRepr_RepresentedDefinition::*)() const) static_cast<handle<StepRepr_ShapeAspectRelationship> (StepRepr_RepresentedDefinition::*)() const>(&StepRepr_RepresentedDefinition::ShapeAspectRelationship),
             R"#(Returns Value as ShapeAspectRelationship (or Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepRepr_ShapeAspect from ./opencascade/StepRepr_ShapeAspect.hxx
    klass = m.attr("StepRepr_ShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeAspect ,opencascade::handle<StepRepr_ShapeAspect>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ShapeAspect::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ProductDefinitionShape> & ,   const StepData_Logical  ) ) static_cast<void (StepRepr_ShapeAspect::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ProductDefinitionShape> & ,   const StepData_Logical  ) >(&StepRepr_ShapeAspect::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aOfShape"),  py::arg("aProductDefinitional")
          )
        .def("SetName",
             (void (StepRepr_ShapeAspect::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ShapeAspect::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ShapeAspect::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_ShapeAspect::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ShapeAspect::*)() const>(&StepRepr_ShapeAspect::Name),
             R"#()#" 
          )
        .def("SetDescription",
             (void (StepRepr_ShapeAspect::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ShapeAspect::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ShapeAspect::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_ShapeAspect::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ShapeAspect::*)() const>(&StepRepr_ShapeAspect::Description),
             R"#()#" 
          )
        .def("SetOfShape",
             (void (StepRepr_ShapeAspect::*)(  const handle<StepRepr_ProductDefinitionShape> &  ) ) static_cast<void (StepRepr_ShapeAspect::*)(  const handle<StepRepr_ProductDefinitionShape> &  ) >(&StepRepr_ShapeAspect::SetOfShape),
             R"#()#"  , py::arg("aOfShape")
          )
        .def("OfShape",
             (handle<StepRepr_ProductDefinitionShape> (StepRepr_ShapeAspect::*)() const) static_cast<handle<StepRepr_ProductDefinitionShape> (StepRepr_ShapeAspect::*)() const>(&StepRepr_ShapeAspect::OfShape),
             R"#()#" 
          )
        .def("SetProductDefinitional",
             (void (StepRepr_ShapeAspect::*)(  const StepData_Logical  ) ) static_cast<void (StepRepr_ShapeAspect::*)(  const StepData_Logical  ) >(&StepRepr_ShapeAspect::SetProductDefinitional),
             R"#()#"  , py::arg("aProductDefinitional")
          )
        .def("ProductDefinitional",
             (StepData_Logical (StepRepr_ShapeAspect::*)() const) static_cast<StepData_Logical (StepRepr_ShapeAspect::*)() const>(&StepRepr_ShapeAspect::ProductDefinitional),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ShapeAspect::*)() const>(&StepRepr_ShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ShapeAspectRelationship from ./opencascade/StepRepr_ShapeAspectRelationship.hxx
    klass = m.attr("StepRepr_ShapeAspectRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeAspectRelationship ,opencascade::handle<StepRepr_ShapeAspectRelationship>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ShapeAspectRelationship::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ShapeAspect> & ,   const handle<StepRepr_ShapeAspect> &  ) ) static_cast<void (StepRepr_ShapeAspectRelationship::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ShapeAspect> & ,   const handle<StepRepr_ShapeAspect> &  ) >(&StepRepr_ShapeAspectRelationship::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aName"),  py::arg("hasDescription"),  py::arg("aDescription"),  py::arg("aRelatingShapeAspect"),  py::arg("aRelatedShapeAspect")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepRepr_ShapeAspectRelationship::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ShapeAspectRelationship::*)() const>(&StepRepr_ShapeAspectRelationship::Name),
             R"#(Returns field Name)#" 
          )
        .def("SetName",
             (void (StepRepr_ShapeAspectRelationship::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ShapeAspectRelationship::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ShapeAspectRelationship::SetName),
             R"#(Set field Name)#"  , py::arg("Name")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_ShapeAspectRelationship::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_ShapeAspectRelationship::*)() const>(&StepRepr_ShapeAspectRelationship::Description),
             R"#(Returns field Description)#" 
          )
        .def("SetDescription",
             (void (StepRepr_ShapeAspectRelationship::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_ShapeAspectRelationship::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_ShapeAspectRelationship::SetDescription),
             R"#(Set field Description)#"  , py::arg("Description")
          )
        .def("HasDescription",
             (Standard_Boolean (StepRepr_ShapeAspectRelationship::*)() const) static_cast<Standard_Boolean (StepRepr_ShapeAspectRelationship::*)() const>(&StepRepr_ShapeAspectRelationship::HasDescription),
             R"#(Returns True if optional field Description is defined)#" 
          )
        .def("RelatingShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepRepr_ShapeAspectRelationship::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepRepr_ShapeAspectRelationship::*)() const>(&StepRepr_ShapeAspectRelationship::RelatingShapeAspect),
             R"#(Returns field RelatingShapeAspect)#" 
          )
        .def("SetRelatingShapeAspect",
             (void (StepRepr_ShapeAspectRelationship::*)(  const handle<StepRepr_ShapeAspect> &  ) ) static_cast<void (StepRepr_ShapeAspectRelationship::*)(  const handle<StepRepr_ShapeAspect> &  ) >(&StepRepr_ShapeAspectRelationship::SetRelatingShapeAspect),
             R"#(Set field RelatingShapeAspect)#"  , py::arg("RelatingShapeAspect")
          )
        .def("RelatedShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepRepr_ShapeAspectRelationship::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepRepr_ShapeAspectRelationship::*)() const>(&StepRepr_ShapeAspectRelationship::RelatedShapeAspect),
             R"#(Returns field RelatedShapeAspect)#" 
          )
        .def("SetRelatedShapeAspect",
             (void (StepRepr_ShapeAspectRelationship::*)(  const handle<StepRepr_ShapeAspect> &  ) ) static_cast<void (StepRepr_ShapeAspectRelationship::*)(  const handle<StepRepr_ShapeAspect> &  ) >(&StepRepr_ShapeAspectRelationship::SetRelatedShapeAspect),
             R"#(Set field RelatedShapeAspect)#"  , py::arg("RelatedShapeAspect")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ShapeAspectRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ShapeAspectRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ShapeAspectRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ShapeAspectRelationship::*)() const>(&StepRepr_ShapeAspectRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ShapeDefinition from ./opencascade/StepRepr_ShapeDefinition.hxx
    klass = m.attr("StepRepr_ShapeDefinition");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeDefinition , shared_ptr<StepRepr_ShapeDefinition>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepRepr_ShapeDefinition::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepRepr_ShapeDefinition::*)(  const handle<Standard_Transient> &  ) const>(&StepRepr_ShapeDefinition::CaseNum),
             R"#(Recognizes a ShapeDefinition Kind Entity that is : 1 -> ProductDefinitionShape 2 -> ShapeAspect 3 -> ShapeAspectRelationship 0 else)#"  , py::arg("ent")
          )
        .def("ProductDefinitionShape",
             (handle<StepRepr_ProductDefinitionShape> (StepRepr_ShapeDefinition::*)() const) static_cast<handle<StepRepr_ProductDefinitionShape> (StepRepr_ShapeDefinition::*)() const>(&StepRepr_ShapeDefinition::ProductDefinitionShape),
             R"#(returns Value as a ProductDefinitionShape (Null if another type))#" 
          )
        .def("ShapeAspect",
             (handle<StepRepr_ShapeAspect> (StepRepr_ShapeDefinition::*)() const) static_cast<handle<StepRepr_ShapeAspect> (StepRepr_ShapeDefinition::*)() const>(&StepRepr_ShapeDefinition::ShapeAspect),
             R"#(returns Value as a ShapeAspect (Null if another type))#" 
          )
        .def("ShapeAspectRelationship",
             (handle<StepRepr_ShapeAspectRelationship> (StepRepr_ShapeDefinition::*)() const) static_cast<handle<StepRepr_ShapeAspectRelationship> (StepRepr_ShapeDefinition::*)() const>(&StepRepr_ShapeDefinition::ShapeAspectRelationship),
             R"#(returns Value as a ShapeAspectRelationship (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepRepr_SuppliedPartRelationship from ./opencascade/StepRepr_SuppliedPartRelationship.hxx
    klass = m.attr("StepRepr_SuppliedPartRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_SuppliedPartRelationship ,opencascade::handle<StepRepr_SuppliedPartRelationship>  , StepBasic_ProductDefinitionRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_SuppliedPartRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_SuppliedPartRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_SuppliedPartRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_SuppliedPartRelationship::*)() const>(&StepRepr_SuppliedPartRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_Transformation from ./opencascade/StepRepr_Transformation.hxx
    klass = m.attr("StepRepr_Transformation");


    // nested enums

    static_cast<py::class_<StepRepr_Transformation , shared_ptr<StepRepr_Transformation>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepRepr_Transformation::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepRepr_Transformation::*)(  const handle<Standard_Transient> &  ) const>(&StepRepr_Transformation::CaseNum),
             R"#(Recognizes a Transformation Kind Entity that is : 1 -> ItemDefinedTransformation 2 -> FunctionallyDefinedTransformation 0 else)#"  , py::arg("ent")
          )
        .def("ItemDefinedTransformation",
             (handle<StepRepr_ItemDefinedTransformation> (StepRepr_Transformation::*)() const) static_cast<handle<StepRepr_ItemDefinedTransformation> (StepRepr_Transformation::*)() const>(&StepRepr_Transformation::ItemDefinedTransformation),
             R"#(returns Value as a ItemDefinedTransformation (Null if another type))#" 
          )
        .def("FunctionallyDefinedTransformation",
             (handle<StepRepr_FunctionallyDefinedTransformation> (StepRepr_Transformation::*)() const) static_cast<handle<StepRepr_FunctionallyDefinedTransformation> (StepRepr_Transformation::*)() const>(&StepRepr_Transformation::FunctionallyDefinedTransformation),
             R"#(returns Value as a FunctionallyDefinedTransformation (Null if another type))#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class StepRepr_AssemblyComponentUsage from ./opencascade/StepRepr_AssemblyComponentUsage.hxx
    klass = m.attr("StepRepr_AssemblyComponentUsage");


    // nested enums

    static_cast<py::class_<StepRepr_AssemblyComponentUsage ,opencascade::handle<StepRepr_AssemblyComponentUsage>  , StepRepr_ProductDefinitionUsage >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_AssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> &  ) >(&StepRepr_AssemblyComponentUsage::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("hasReferenceDesignator"),  py::arg("aReferenceDesignator")
          )
        .def("Init",
             (void (StepRepr_AssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> &  ) >(&StepRepr_AssemblyComponentUsage::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("hasReferenceDesignator"),  py::arg("aReferenceDesignator")
          )
        .def("ReferenceDesignator",
             (handle<TCollection_HAsciiString> (StepRepr_AssemblyComponentUsage::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_AssemblyComponentUsage::*)() const>(&StepRepr_AssemblyComponentUsage::ReferenceDesignator),
             R"#(Returns field ReferenceDesignator)#" 
          )
        .def("SetReferenceDesignator",
             (void (StepRepr_AssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_AssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_AssemblyComponentUsage::SetReferenceDesignator),
             R"#(Set field ReferenceDesignator)#"  , py::arg("ReferenceDesignator")
          )
        .def("HasReferenceDesignator",
             (Standard_Boolean (StepRepr_AssemblyComponentUsage::*)() const) static_cast<Standard_Boolean (StepRepr_AssemblyComponentUsage::*)() const>(&StepRepr_AssemblyComponentUsage::HasReferenceDesignator),
             R"#(Returns True if optional field ReferenceDesignator is defined)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_AssemblyComponentUsage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_AssemblyComponentUsage::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_AssemblyComponentUsage::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_AssemblyComponentUsage::*)() const>(&StepRepr_AssemblyComponentUsage::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_BooleanRepresentationItem from ./opencascade/StepRepr_BooleanRepresentationItem.hxx
    klass = m.attr("StepRepr_BooleanRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_BooleanRepresentationItem ,opencascade::handle<StepRepr_BooleanRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_BooleanRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean  ) ) static_cast<void (StepRepr_BooleanRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Boolean  ) >(&StepRepr_BooleanRepresentationItem::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theValue")
          )
        .def("SetValue",
             (void (StepRepr_BooleanRepresentationItem::*)(  const Standard_Boolean  ) ) static_cast<void (StepRepr_BooleanRepresentationItem::*)(  const Standard_Boolean  ) >(&StepRepr_BooleanRepresentationItem::SetValue),
             R"#()#"  , py::arg("theValue")
          )
        .def("Value",
             (Standard_Boolean (StepRepr_BooleanRepresentationItem::*)() const) static_cast<Standard_Boolean (StepRepr_BooleanRepresentationItem::*)() const>(&StepRepr_BooleanRepresentationItem::Value),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_BooleanRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_BooleanRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_BooleanRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_BooleanRepresentationItem::*)() const>(&StepRepr_BooleanRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CharacterizedRepresentation from ./opencascade/StepRepr_CharacterizedRepresentation.hxx
    klass = m.attr("StepRepr_CharacterizedRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_CharacterizedRepresentation ,opencascade::handle<StepRepr_CharacterizedRepresentation>  , StepRepr_Representation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_CharacterizedRepresentation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> & ,   const handle<StepRepr_RepresentationContext> &  ) ) static_cast<void (StepRepr_CharacterizedRepresentation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> & ,   const handle<StepRepr_RepresentationContext> &  ) >(&StepRepr_CharacterizedRepresentation::Init),
             R"#(Returns a CharacterizedRepresentation)#"  , py::arg("theName"),  py::arg("theDescription"),  py::arg("theItems"),  py::arg("theContextOfItems")
          )
        .def("SetDescription",
             (void (StepRepr_CharacterizedRepresentation::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_CharacterizedRepresentation::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_CharacterizedRepresentation::SetDescription),
             R"#()#"  , py::arg("theDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_CharacterizedRepresentation::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_CharacterizedRepresentation::*)() const>(&StepRepr_CharacterizedRepresentation::Description),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CharacterizedRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CharacterizedRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CharacterizedRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CharacterizedRepresentation::*)() const>(&StepRepr_CharacterizedRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CompShAspAndDatumFeatAndShAsp from ./opencascade/StepRepr_CompShAspAndDatumFeatAndShAsp.hxx
    klass = m.attr("StepRepr_CompShAspAndDatumFeatAndShAsp");


    // nested enums

    static_cast<py::class_<StepRepr_CompShAspAndDatumFeatAndShAsp ,opencascade::handle<StepRepr_CompShAspAndDatumFeatAndShAsp>  , StepRepr_ShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CompShAspAndDatumFeatAndShAsp::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CompShAspAndDatumFeatAndShAsp::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CompShAspAndDatumFeatAndShAsp::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CompShAspAndDatumFeatAndShAsp::*)() const>(&StepRepr_CompShAspAndDatumFeatAndShAsp::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CompositeShapeAspect from ./opencascade/StepRepr_CompositeShapeAspect.hxx
    klass = m.attr("StepRepr_CompositeShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_CompositeShapeAspect ,opencascade::handle<StepRepr_CompositeShapeAspect>  , StepRepr_ShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CompositeShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CompositeShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CompositeShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CompositeShapeAspect::*)() const>(&StepRepr_CompositeShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CompoundRepresentationItem from ./opencascade/StepRepr_CompoundRepresentationItem.hxx
    klass = m.attr("StepRepr_CompoundRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_CompoundRepresentationItem ,opencascade::handle<StepRepr_CompoundRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_CompoundRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> &  ) ) static_cast<void (StepRepr_CompoundRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> &  ) >(&StepRepr_CompoundRepresentationItem::Init),
             R"#()#"  , py::arg("aName"),  py::arg("item_element")
          )
        .def("ItemElement",
             (handle<StepRepr_HArray1OfRepresentationItem> (StepRepr_CompoundRepresentationItem::*)() const) static_cast<handle<StepRepr_HArray1OfRepresentationItem> (StepRepr_CompoundRepresentationItem::*)() const>(&StepRepr_CompoundRepresentationItem::ItemElement),
             R"#()#" 
          )
        .def("NbItemElement",
             (Standard_Integer (StepRepr_CompoundRepresentationItem::*)() const) static_cast<Standard_Integer (StepRepr_CompoundRepresentationItem::*)() const>(&StepRepr_CompoundRepresentationItem::NbItemElement),
             R"#()#" 
          )
        .def("SetItemElement",
             (void (StepRepr_CompoundRepresentationItem::*)(  const handle<StepRepr_HArray1OfRepresentationItem> &  ) ) static_cast<void (StepRepr_CompoundRepresentationItem::*)(  const handle<StepRepr_HArray1OfRepresentationItem> &  ) >(&StepRepr_CompoundRepresentationItem::SetItemElement),
             R"#()#"  , py::arg("item_element")
          )
        .def("ItemElementValue",
             (handle<StepRepr_RepresentationItem> (StepRepr_CompoundRepresentationItem::*)(  const Standard_Integer  ) const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_CompoundRepresentationItem::*)(  const Standard_Integer  ) const>(&StepRepr_CompoundRepresentationItem::ItemElementValue),
             R"#()#"  , py::arg("num")
          )
        .def("SetItemElementValue",
             (void (StepRepr_CompoundRepresentationItem::*)(  const Standard_Integer ,   const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_CompoundRepresentationItem::*)(  const Standard_Integer ,   const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_CompoundRepresentationItem::SetItemElementValue),
             R"#()#"  , py::arg("num"),  py::arg("anelement")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CompoundRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CompoundRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CompoundRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CompoundRepresentationItem::*)() const>(&StepRepr_CompoundRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ConstructiveGeometryRepresentation from ./opencascade/StepRepr_ConstructiveGeometryRepresentation.hxx
    klass = m.attr("StepRepr_ConstructiveGeometryRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_ConstructiveGeometryRepresentation ,opencascade::handle<StepRepr_ConstructiveGeometryRepresentation>  , StepRepr_Representation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ConstructiveGeometryRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ConstructiveGeometryRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ConstructiveGeometryRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ConstructiveGeometryRepresentation::*)() const>(&StepRepr_ConstructiveGeometryRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ConstructiveGeometryRepresentationRelationship from ./opencascade/StepRepr_ConstructiveGeometryRepresentationRelationship.hxx
    klass = m.attr("StepRepr_ConstructiveGeometryRepresentationRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_ConstructiveGeometryRepresentationRelationship ,opencascade::handle<StepRepr_ConstructiveGeometryRepresentationRelationship>  , StepRepr_RepresentationRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ConstructiveGeometryRepresentationRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ConstructiveGeometryRepresentationRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ConstructiveGeometryRepresentationRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ConstructiveGeometryRepresentationRelationship::*)() const>(&StepRepr_ConstructiveGeometryRepresentationRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_DefinitionalRepresentation from ./opencascade/StepRepr_DefinitionalRepresentation.hxx
    klass = m.attr("StepRepr_DefinitionalRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_DefinitionalRepresentation ,opencascade::handle<StepRepr_DefinitionalRepresentation>  , StepRepr_Representation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_DefinitionalRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_DefinitionalRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_DefinitionalRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_DefinitionalRepresentation::*)() const>(&StepRepr_DefinitionalRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_DerivedShapeAspect from ./opencascade/StepRepr_DerivedShapeAspect.hxx
    klass = m.attr("StepRepr_DerivedShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_DerivedShapeAspect ,opencascade::handle<StepRepr_DerivedShapeAspect>  , StepRepr_ShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_DerivedShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_DerivedShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_DerivedShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_DerivedShapeAspect::*)() const>(&StepRepr_DerivedShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_DescriptiveRepresentationItem from ./opencascade/StepRepr_DescriptiveRepresentationItem.hxx
    klass = m.attr("StepRepr_DescriptiveRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_DescriptiveRepresentationItem ,opencascade::handle<StepRepr_DescriptiveRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_DescriptiveRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_DescriptiveRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> &  ) >(&StepRepr_DescriptiveRepresentationItem::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription")
          )
        .def("SetDescription",
             (void (StepRepr_DescriptiveRepresentationItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_DescriptiveRepresentationItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_DescriptiveRepresentationItem::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepRepr_DescriptiveRepresentationItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_DescriptiveRepresentationItem::*)() const>(&StepRepr_DescriptiveRepresentationItem::Description),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_DescriptiveRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_DescriptiveRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_DescriptiveRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_DescriptiveRepresentationItem::*)() const>(&StepRepr_DescriptiveRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ExternallyDefinedRepresentation from ./opencascade/StepRepr_ExternallyDefinedRepresentation.hxx
    klass = m.attr("StepRepr_ExternallyDefinedRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_ExternallyDefinedRepresentation ,opencascade::handle<StepRepr_ExternallyDefinedRepresentation>  , StepRepr_Representation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ExternallyDefinedRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ExternallyDefinedRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ExternallyDefinedRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ExternallyDefinedRepresentation::*)() const>(&StepRepr_ExternallyDefinedRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_FeatureForDatumTargetRelationship from ./opencascade/StepRepr_FeatureForDatumTargetRelationship.hxx
    klass = m.attr("StepRepr_FeatureForDatumTargetRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_FeatureForDatumTargetRelationship ,opencascade::handle<StepRepr_FeatureForDatumTargetRelationship>  , StepRepr_ShapeAspectRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_FeatureForDatumTargetRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_FeatureForDatumTargetRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_FeatureForDatumTargetRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_FeatureForDatumTargetRelationship::*)() const>(&StepRepr_FeatureForDatumTargetRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_GlobalUncertaintyAssignedContext from ./opencascade/StepRepr_GlobalUncertaintyAssignedContext.hxx
    klass = m.attr("StepRepr_GlobalUncertaintyAssignedContext");


    // nested enums

    static_cast<py::class_<StepRepr_GlobalUncertaintyAssignedContext ,opencascade::handle<StepRepr_GlobalUncertaintyAssignedContext>  , StepRepr_RepresentationContext >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_GlobalUncertaintyAssignedContext::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_HArray1OfUncertaintyMeasureWithUnit> &  ) ) static_cast<void (StepRepr_GlobalUncertaintyAssignedContext::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_HArray1OfUncertaintyMeasureWithUnit> &  ) >(&StepRepr_GlobalUncertaintyAssignedContext::Init),
             R"#()#"  , py::arg("aContextIdentifier"),  py::arg("aContextType"),  py::arg("aUncertainty")
          )
        .def("SetUncertainty",
             (void (StepRepr_GlobalUncertaintyAssignedContext::*)(  const handle<StepBasic_HArray1OfUncertaintyMeasureWithUnit> &  ) ) static_cast<void (StepRepr_GlobalUncertaintyAssignedContext::*)(  const handle<StepBasic_HArray1OfUncertaintyMeasureWithUnit> &  ) >(&StepRepr_GlobalUncertaintyAssignedContext::SetUncertainty),
             R"#()#"  , py::arg("aUncertainty")
          )
        .def("Uncertainty",
             (handle<StepBasic_HArray1OfUncertaintyMeasureWithUnit> (StepRepr_GlobalUncertaintyAssignedContext::*)() const) static_cast<handle<StepBasic_HArray1OfUncertaintyMeasureWithUnit> (StepRepr_GlobalUncertaintyAssignedContext::*)() const>(&StepRepr_GlobalUncertaintyAssignedContext::Uncertainty),
             R"#()#" 
          )
        .def("UncertaintyValue",
             (handle<StepBasic_UncertaintyMeasureWithUnit> (StepRepr_GlobalUncertaintyAssignedContext::*)(  const Standard_Integer  ) const) static_cast<handle<StepBasic_UncertaintyMeasureWithUnit> (StepRepr_GlobalUncertaintyAssignedContext::*)(  const Standard_Integer  ) const>(&StepRepr_GlobalUncertaintyAssignedContext::UncertaintyValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbUncertainty",
             (Standard_Integer (StepRepr_GlobalUncertaintyAssignedContext::*)() const) static_cast<Standard_Integer (StepRepr_GlobalUncertaintyAssignedContext::*)() const>(&StepRepr_GlobalUncertaintyAssignedContext::NbUncertainty),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_GlobalUncertaintyAssignedContext::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_GlobalUncertaintyAssignedContext::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_GlobalUncertaintyAssignedContext::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_GlobalUncertaintyAssignedContext::*)() const>(&StepRepr_GlobalUncertaintyAssignedContext::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_GlobalUnitAssignedContext from ./opencascade/StepRepr_GlobalUnitAssignedContext.hxx
    klass = m.attr("StepRepr_GlobalUnitAssignedContext");


    // nested enums

    static_cast<py::class_<StepRepr_GlobalUnitAssignedContext ,opencascade::handle<StepRepr_GlobalUnitAssignedContext>  , StepRepr_RepresentationContext >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_GlobalUnitAssignedContext::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_HArray1OfNamedUnit> &  ) ) static_cast<void (StepRepr_GlobalUnitAssignedContext::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_HArray1OfNamedUnit> &  ) >(&StepRepr_GlobalUnitAssignedContext::Init),
             R"#()#"  , py::arg("aContextIdentifier"),  py::arg("aContextType"),  py::arg("aUnits")
          )
        .def("SetUnits",
             (void (StepRepr_GlobalUnitAssignedContext::*)(  const handle<StepBasic_HArray1OfNamedUnit> &  ) ) static_cast<void (StepRepr_GlobalUnitAssignedContext::*)(  const handle<StepBasic_HArray1OfNamedUnit> &  ) >(&StepRepr_GlobalUnitAssignedContext::SetUnits),
             R"#()#"  , py::arg("aUnits")
          )
        .def("Units",
             (handle<StepBasic_HArray1OfNamedUnit> (StepRepr_GlobalUnitAssignedContext::*)() const) static_cast<handle<StepBasic_HArray1OfNamedUnit> (StepRepr_GlobalUnitAssignedContext::*)() const>(&StepRepr_GlobalUnitAssignedContext::Units),
             R"#()#" 
          )
        .def("UnitsValue",
             (handle<StepBasic_NamedUnit> (StepRepr_GlobalUnitAssignedContext::*)(  const Standard_Integer  ) const) static_cast<handle<StepBasic_NamedUnit> (StepRepr_GlobalUnitAssignedContext::*)(  const Standard_Integer  ) const>(&StepRepr_GlobalUnitAssignedContext::UnitsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbUnits",
             (Standard_Integer (StepRepr_GlobalUnitAssignedContext::*)() const) static_cast<Standard_Integer (StepRepr_GlobalUnitAssignedContext::*)() const>(&StepRepr_GlobalUnitAssignedContext::NbUnits),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_GlobalUnitAssignedContext::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_GlobalUnitAssignedContext::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_GlobalUnitAssignedContext::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_GlobalUnitAssignedContext::*)() const>(&StepRepr_GlobalUnitAssignedContext::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_IntegerRepresentationItem from ./opencascade/StepRepr_IntegerRepresentationItem.hxx
    klass = m.attr("StepRepr_IntegerRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_IntegerRepresentationItem ,opencascade::handle<StepRepr_IntegerRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_IntegerRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Integer  ) ) static_cast<void (StepRepr_IntegerRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Integer  ) >(&StepRepr_IntegerRepresentationItem::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theValue")
          )
        .def("SetValue",
             (void (StepRepr_IntegerRepresentationItem::*)(  const Standard_Integer  ) ) static_cast<void (StepRepr_IntegerRepresentationItem::*)(  const Standard_Integer  ) >(&StepRepr_IntegerRepresentationItem::SetValue),
             R"#()#"  , py::arg("theValue")
          )
        .def("Value",
             (Standard_Integer (StepRepr_IntegerRepresentationItem::*)() const) static_cast<Standard_Integer (StepRepr_IntegerRepresentationItem::*)() const>(&StepRepr_IntegerRepresentationItem::Value),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_IntegerRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_IntegerRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_IntegerRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_IntegerRepresentationItem::*)() const>(&StepRepr_IntegerRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MakeFromUsageOption from ./opencascade/StepRepr_MakeFromUsageOption.hxx
    klass = m.attr("StepRepr_MakeFromUsageOption");


    // nested enums

    static_cast<py::class_<StepRepr_MakeFromUsageOption ,opencascade::handle<StepRepr_MakeFromUsageOption>  , StepRepr_ProductDefinitionUsage >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_MakeFromUsageOption::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Integer ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_MakeFromUsageOption::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Integer ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_MakeFromUsageOption::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("aRanking"),  py::arg("aRankingRationale"),  py::arg("aQuantity")
          )
        .def("Init",
             (void (StepRepr_MakeFromUsageOption::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Integer ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_MakeFromUsageOption::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Integer ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_MakeFromUsageOption::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("aRanking"),  py::arg("aRankingRationale"),  py::arg("aQuantity")
          )
        .def("Ranking",
             (Standard_Integer (StepRepr_MakeFromUsageOption::*)() const) static_cast<Standard_Integer (StepRepr_MakeFromUsageOption::*)() const>(&StepRepr_MakeFromUsageOption::Ranking),
             R"#(Returns field Ranking)#" 
          )
        .def("SetRanking",
             (void (StepRepr_MakeFromUsageOption::*)(  const Standard_Integer  ) ) static_cast<void (StepRepr_MakeFromUsageOption::*)(  const Standard_Integer  ) >(&StepRepr_MakeFromUsageOption::SetRanking),
             R"#(Set field Ranking)#"  , py::arg("Ranking")
          )
        .def("RankingRationale",
             (handle<TCollection_HAsciiString> (StepRepr_MakeFromUsageOption::*)() const) static_cast<handle<TCollection_HAsciiString> (StepRepr_MakeFromUsageOption::*)() const>(&StepRepr_MakeFromUsageOption::RankingRationale),
             R"#(Returns field RankingRationale)#" 
          )
        .def("SetRankingRationale",
             (void (StepRepr_MakeFromUsageOption::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepRepr_MakeFromUsageOption::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepRepr_MakeFromUsageOption::SetRankingRationale),
             R"#(Set field RankingRationale)#"  , py::arg("RankingRationale")
          )
        .def("Quantity",
             (handle<StepBasic_MeasureWithUnit> (StepRepr_MakeFromUsageOption::*)() const) static_cast<handle<StepBasic_MeasureWithUnit> (StepRepr_MakeFromUsageOption::*)() const>(&StepRepr_MakeFromUsageOption::Quantity),
             R"#(Returns field Quantity)#" 
          )
        .def("SetQuantity",
             (void (StepRepr_MakeFromUsageOption::*)(  const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_MakeFromUsageOption::*)(  const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_MakeFromUsageOption::SetQuantity),
             R"#(Set field Quantity)#"  , py::arg("Quantity")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MakeFromUsageOption::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MakeFromUsageOption::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MakeFromUsageOption::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MakeFromUsageOption::*)() const>(&StepRepr_MakeFromUsageOption::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MappedItem from ./opencascade/StepRepr_MappedItem.hxx
    klass = m.attr("StepRepr_MappedItem");


    // nested enums

    static_cast<py::class_<StepRepr_MappedItem ,opencascade::handle<StepRepr_MappedItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_MappedItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_RepresentationMap> & ,   const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_MappedItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_RepresentationMap> & ,   const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_MappedItem::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aMappingSource"),  py::arg("aMappingTarget")
          )
        .def("SetMappingSource",
             (void (StepRepr_MappedItem::*)(  const handle<StepRepr_RepresentationMap> &  ) ) static_cast<void (StepRepr_MappedItem::*)(  const handle<StepRepr_RepresentationMap> &  ) >(&StepRepr_MappedItem::SetMappingSource),
             R"#()#"  , py::arg("aMappingSource")
          )
        .def("MappingSource",
             (handle<StepRepr_RepresentationMap> (StepRepr_MappedItem::*)() const) static_cast<handle<StepRepr_RepresentationMap> (StepRepr_MappedItem::*)() const>(&StepRepr_MappedItem::MappingSource),
             R"#()#" 
          )
        .def("SetMappingTarget",
             (void (StepRepr_MappedItem::*)(  const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_MappedItem::*)(  const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_MappedItem::SetMappingTarget),
             R"#()#"  , py::arg("aMappingTarget")
          )
        .def("MappingTarget",
             (handle<StepRepr_RepresentationItem> (StepRepr_MappedItem::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_MappedItem::*)() const>(&StepRepr_MappedItem::MappingTarget),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MappedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MappedItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MappedItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MappedItem::*)() const>(&StepRepr_MappedItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MaterialProperty from ./opencascade/StepRepr_MaterialProperty.hxx
    klass = m.attr("StepRepr_MaterialProperty");


    // nested enums

    static_cast<py::class_<StepRepr_MaterialProperty ,opencascade::handle<StepRepr_MaterialProperty>  , StepRepr_PropertyDefinition >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MaterialProperty::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MaterialProperty::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MaterialProperty::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MaterialProperty::*)() const>(&StepRepr_MaterialProperty::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MaterialPropertyRepresentation from ./opencascade/StepRepr_MaterialPropertyRepresentation.hxx
    klass = m.attr("StepRepr_MaterialPropertyRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_MaterialPropertyRepresentation ,opencascade::handle<StepRepr_MaterialPropertyRepresentation>  , StepRepr_PropertyDefinitionRepresentation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_MaterialPropertyRepresentation::*)(  const StepRepr_RepresentedDefinition & ,   const handle<StepRepr_Representation> & ,   const handle<StepRepr_DataEnvironment> &  ) ) static_cast<void (StepRepr_MaterialPropertyRepresentation::*)(  const StepRepr_RepresentedDefinition & ,   const handle<StepRepr_Representation> & ,   const handle<StepRepr_DataEnvironment> &  ) >(&StepRepr_MaterialPropertyRepresentation::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aPropertyDefinitionRepresentation_Definition"),  py::arg("aPropertyDefinitionRepresentation_UsedRepresentation"),  py::arg("aDependentEnvironment")
          )
        .def("DependentEnvironment",
             (handle<StepRepr_DataEnvironment> (StepRepr_MaterialPropertyRepresentation::*)() const) static_cast<handle<StepRepr_DataEnvironment> (StepRepr_MaterialPropertyRepresentation::*)() const>(&StepRepr_MaterialPropertyRepresentation::DependentEnvironment),
             R"#(Returns field DependentEnvironment)#" 
          )
        .def("SetDependentEnvironment",
             (void (StepRepr_MaterialPropertyRepresentation::*)(  const handle<StepRepr_DataEnvironment> &  ) ) static_cast<void (StepRepr_MaterialPropertyRepresentation::*)(  const handle<StepRepr_DataEnvironment> &  ) >(&StepRepr_MaterialPropertyRepresentation::SetDependentEnvironment),
             R"#(Set field DependentEnvironment)#"  , py::arg("DependentEnvironment")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MaterialPropertyRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MaterialPropertyRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MaterialPropertyRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MaterialPropertyRepresentation::*)() const>(&StepRepr_MaterialPropertyRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MeasureRepresentationItem from ./opencascade/StepRepr_MeasureRepresentationItem.hxx
    klass = m.attr("StepRepr_MeasureRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_MeasureRepresentationItem ,opencascade::handle<StepRepr_MeasureRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_MeasureRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureValueMember> & ,   const StepBasic_Unit &  ) ) static_cast<void (StepRepr_MeasureRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureValueMember> & ,   const StepBasic_Unit &  ) >(&StepRepr_MeasureRepresentationItem::Init),
             R"#(Init all fields)#"  , py::arg("aName"),  py::arg("aValueComponent"),  py::arg("aUnitComponent")
          )
        .def("SetMeasure",
             (void (StepRepr_MeasureRepresentationItem::*)(  const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_MeasureRepresentationItem::*)(  const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_MeasureRepresentationItem::SetMeasure),
             R"#()#"  , py::arg("Measure")
          )
        .def("Measure",
             (handle<StepBasic_MeasureWithUnit> (StepRepr_MeasureRepresentationItem::*)() const) static_cast<handle<StepBasic_MeasureWithUnit> (StepRepr_MeasureRepresentationItem::*)() const>(&StepRepr_MeasureRepresentationItem::Measure),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MeasureRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MeasureRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MeasureRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MeasureRepresentationItem::*)() const>(&StepRepr_MeasureRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_MechanicalDesignAndDraughtingRelationship from ./opencascade/StepRepr_MechanicalDesignAndDraughtingRelationship.hxx
    klass = m.attr("StepRepr_MechanicalDesignAndDraughtingRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_MechanicalDesignAndDraughtingRelationship ,opencascade::handle<StepRepr_MechanicalDesignAndDraughtingRelationship>  , StepRepr_RepresentationRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_MechanicalDesignAndDraughtingRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_MechanicalDesignAndDraughtingRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_MechanicalDesignAndDraughtingRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_MechanicalDesignAndDraughtingRelationship::*)() const>(&StepRepr_MechanicalDesignAndDraughtingRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ParametricRepresentationContext from ./opencascade/StepRepr_ParametricRepresentationContext.hxx
    klass = m.attr("StepRepr_ParametricRepresentationContext");


    // nested enums

    static_cast<py::class_<StepRepr_ParametricRepresentationContext ,opencascade::handle<StepRepr_ParametricRepresentationContext>  , StepRepr_RepresentationContext >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ParametricRepresentationContext::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ParametricRepresentationContext::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ParametricRepresentationContext::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ParametricRepresentationContext::*)() const>(&StepRepr_ParametricRepresentationContext::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ProductDefinitionShape from ./opencascade/StepRepr_ProductDefinitionShape.hxx
    klass = m.attr("StepRepr_ProductDefinitionShape");


    // nested enums

    static_cast<py::class_<StepRepr_ProductDefinitionShape ,opencascade::handle<StepRepr_ProductDefinitionShape>  , StepRepr_PropertyDefinition >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ProductDefinitionShape::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ProductDefinitionShape::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ProductDefinitionShape::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ProductDefinitionShape::*)() const>(&StepRepr_ProductDefinitionShape::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RealRepresentationItem from ./opencascade/StepRepr_RealRepresentationItem.hxx
    klass = m.attr("StepRepr_RealRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_RealRepresentationItem ,opencascade::handle<StepRepr_RealRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RealRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real  ) ) static_cast<void (StepRepr_RealRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real  ) >(&StepRepr_RealRepresentationItem::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theValue")
          )
        .def("SetValue",
             (void (StepRepr_RealRepresentationItem::*)(  const Standard_Real  ) ) static_cast<void (StepRepr_RealRepresentationItem::*)(  const Standard_Real  ) >(&StepRepr_RealRepresentationItem::SetValue),
             R"#()#"  , py::arg("theValue")
          )
        .def("Value",
             (Standard_Real (StepRepr_RealRepresentationItem::*)() const) static_cast<Standard_Real (StepRepr_RealRepresentationItem::*)() const>(&StepRepr_RealRepresentationItem::Value),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RealRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RealRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RealRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RealRepresentationItem::*)() const>(&StepRepr_RealRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ReprItemAndMeasureWithUnit from ./opencascade/StepRepr_ReprItemAndMeasureWithUnit.hxx
    klass = m.attr("StepRepr_ReprItemAndMeasureWithUnit");


    // nested enums

    static_cast<py::class_<StepRepr_ReprItemAndMeasureWithUnit ,opencascade::handle<StepRepr_ReprItemAndMeasureWithUnit>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ReprItemAndMeasureWithUnit::*)(  const handle<StepBasic_MeasureWithUnit> & ,   const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepRepr_ReprItemAndMeasureWithUnit::*)(  const handle<StepBasic_MeasureWithUnit> & ,   const handle<StepRepr_RepresentationItem> &  ) >(&StepRepr_ReprItemAndMeasureWithUnit::Init),
             R"#()#"  , py::arg("aMWU"),  py::arg("aRI")
          )
        .def("GetMeasureRepresentationItem",
             (handle<StepRepr_MeasureRepresentationItem> (StepRepr_ReprItemAndMeasureWithUnit::*)() const) static_cast<handle<StepRepr_MeasureRepresentationItem> (StepRepr_ReprItemAndMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndMeasureWithUnit::GetMeasureRepresentationItem),
             R"#()#" 
          )
        .def("SetMeasureWithUnit",
             (void (StepRepr_ReprItemAndMeasureWithUnit::*)(  const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_ReprItemAndMeasureWithUnit::*)(  const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_ReprItemAndMeasureWithUnit::SetMeasureWithUnit),
             R"#()#"  , py::arg("aMWU")
          )
        .def("GetMeasureWithUnit",
             (handle<StepBasic_MeasureWithUnit> (StepRepr_ReprItemAndMeasureWithUnit::*)() const) static_cast<handle<StepBasic_MeasureWithUnit> (StepRepr_ReprItemAndMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndMeasureWithUnit::GetMeasureWithUnit),
             R"#()#" 
          )
        .def("GetRepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepRepr_ReprItemAndMeasureWithUnit::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepRepr_ReprItemAndMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndMeasureWithUnit::GetRepresentationItem),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ReprItemAndMeasureWithUnit::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ReprItemAndMeasureWithUnit::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ReprItemAndMeasureWithUnit::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ReprItemAndMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndMeasureWithUnit::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ShapeAspectDerivingRelationship from ./opencascade/StepRepr_ShapeAspectDerivingRelationship.hxx
    klass = m.attr("StepRepr_ShapeAspectDerivingRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeAspectDerivingRelationship ,opencascade::handle<StepRepr_ShapeAspectDerivingRelationship>  , StepRepr_ShapeAspectRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ShapeAspectDerivingRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ShapeAspectDerivingRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ShapeAspectDerivingRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ShapeAspectDerivingRelationship::*)() const>(&StepRepr_ShapeAspectDerivingRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ShapeAspectTransition from ./opencascade/StepRepr_ShapeAspectTransition.hxx
    klass = m.attr("StepRepr_ShapeAspectTransition");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeAspectTransition ,opencascade::handle<StepRepr_ShapeAspectTransition>  , StepRepr_ShapeAspectRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ShapeAspectTransition::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ShapeAspectTransition::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ShapeAspectTransition::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ShapeAspectTransition::*)() const>(&StepRepr_ShapeAspectTransition::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ShapeRepresentationRelationship from ./opencascade/StepRepr_ShapeRepresentationRelationship.hxx
    klass = m.attr("StepRepr_ShapeRepresentationRelationship");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeRepresentationRelationship ,opencascade::handle<StepRepr_ShapeRepresentationRelationship>  , StepRepr_RepresentationRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ShapeRepresentationRelationship::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ShapeRepresentationRelationship::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ShapeRepresentationRelationship::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ShapeRepresentationRelationship::*)() const>(&StepRepr_ShapeRepresentationRelationship::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_StructuralResponseProperty from ./opencascade/StepRepr_StructuralResponseProperty.hxx
    klass = m.attr("StepRepr_StructuralResponseProperty");


    // nested enums

    static_cast<py::class_<StepRepr_StructuralResponseProperty ,opencascade::handle<StepRepr_StructuralResponseProperty>  , StepRepr_PropertyDefinition >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_StructuralResponseProperty::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_StructuralResponseProperty::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_StructuralResponseProperty::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_StructuralResponseProperty::*)() const>(&StepRepr_StructuralResponseProperty::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_StructuralResponsePropertyDefinitionRepresentation from ./opencascade/StepRepr_StructuralResponsePropertyDefinitionRepresentation.hxx
    klass = m.attr("StepRepr_StructuralResponsePropertyDefinitionRepresentation");


    // nested enums

    static_cast<py::class_<StepRepr_StructuralResponsePropertyDefinitionRepresentation ,opencascade::handle<StepRepr_StructuralResponsePropertyDefinitionRepresentation>  , StepRepr_PropertyDefinitionRepresentation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_StructuralResponsePropertyDefinitionRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_StructuralResponsePropertyDefinitionRepresentation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_StructuralResponsePropertyDefinitionRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_StructuralResponsePropertyDefinitionRepresentation::*)() const>(&StepRepr_StructuralResponsePropertyDefinitionRepresentation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ValueRepresentationItem from ./opencascade/StepRepr_ValueRepresentationItem.hxx
    klass = m.attr("StepRepr_ValueRepresentationItem");


    // nested enums

    static_cast<py::class_<StepRepr_ValueRepresentationItem ,opencascade::handle<StepRepr_ValueRepresentationItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ValueRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureValueMember> &  ) ) static_cast<void (StepRepr_ValueRepresentationItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureValueMember> &  ) >(&StepRepr_ValueRepresentationItem::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theValueComponentMember")
          )
        .def("SetValueComponentMember",
             (void (StepRepr_ValueRepresentationItem::*)(  const handle<StepBasic_MeasureValueMember> &  ) ) static_cast<void (StepRepr_ValueRepresentationItem::*)(  const handle<StepBasic_MeasureValueMember> &  ) >(&StepRepr_ValueRepresentationItem::SetValueComponentMember),
             R"#()#"  , py::arg("theValueComponentMember")
          )
        .def("ValueComponentMember",
             (handle<StepBasic_MeasureValueMember> (StepRepr_ValueRepresentationItem::*)() const) static_cast<handle<StepBasic_MeasureValueMember> (StepRepr_ValueRepresentationItem::*)() const>(&StepRepr_ValueRepresentationItem::ValueComponentMember),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ValueRepresentationItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ValueRepresentationItem::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ValueRepresentationItem::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ValueRepresentationItem::*)() const>(&StepRepr_ValueRepresentationItem::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_Apex from ./opencascade/StepRepr_Apex.hxx
    klass = m.attr("StepRepr_Apex");


    // nested enums

    static_cast<py::class_<StepRepr_Apex ,opencascade::handle<StepRepr_Apex>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_Apex::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_Apex::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_Apex::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_Apex::*)() const>(&StepRepr_Apex::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CentreOfSymmetry from ./opencascade/StepRepr_CentreOfSymmetry.hxx
    klass = m.attr("StepRepr_CentreOfSymmetry");


    // nested enums

    static_cast<py::class_<StepRepr_CentreOfSymmetry ,opencascade::handle<StepRepr_CentreOfSymmetry>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CentreOfSymmetry::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CentreOfSymmetry::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CentreOfSymmetry::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CentreOfSymmetry::*)() const>(&StepRepr_CentreOfSymmetry::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp from ./opencascade/StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx
    klass = m.attr("StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp");


    // nested enums

    static_cast<py::class_<StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp ,opencascade::handle<StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp>  , StepRepr_CompShAspAndDatumFeatAndShAsp >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp::*)() const>(&StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_CompositeGroupShapeAspect from ./opencascade/StepRepr_CompositeGroupShapeAspect.hxx
    klass = m.attr("StepRepr_CompositeGroupShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_CompositeGroupShapeAspect ,opencascade::handle<StepRepr_CompositeGroupShapeAspect>  , StepRepr_CompositeShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_CompositeGroupShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_CompositeGroupShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_CompositeGroupShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_CompositeGroupShapeAspect::*)() const>(&StepRepr_CompositeGroupShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ContinuosShapeAspect from ./opencascade/StepRepr_ContinuosShapeAspect.hxx
    klass = m.attr("StepRepr_ContinuosShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_ContinuosShapeAspect ,opencascade::handle<StepRepr_ContinuosShapeAspect>  , StepRepr_CompositeShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ContinuosShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ContinuosShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ContinuosShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ContinuosShapeAspect::*)() const>(&StepRepr_ContinuosShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_Extension from ./opencascade/StepRepr_Extension.hxx
    klass = m.attr("StepRepr_Extension");


    // nested enums

    static_cast<py::class_<StepRepr_Extension ,opencascade::handle<StepRepr_Extension>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_Extension::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_Extension::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_Extension::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_Extension::*)() const>(&StepRepr_Extension::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_GeometricAlignment from ./opencascade/StepRepr_GeometricAlignment.hxx
    klass = m.attr("StepRepr_GeometricAlignment");


    // nested enums

    static_cast<py::class_<StepRepr_GeometricAlignment ,opencascade::handle<StepRepr_GeometricAlignment>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_GeometricAlignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_GeometricAlignment::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_GeometricAlignment::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_GeometricAlignment::*)() const>(&StepRepr_GeometricAlignment::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_NextAssemblyUsageOccurrence from ./opencascade/StepRepr_NextAssemblyUsageOccurrence.hxx
    klass = m.attr("StepRepr_NextAssemblyUsageOccurrence");


    // nested enums

    static_cast<py::class_<StepRepr_NextAssemblyUsageOccurrence ,opencascade::handle<StepRepr_NextAssemblyUsageOccurrence>  , StepRepr_AssemblyComponentUsage >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_NextAssemblyUsageOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_NextAssemblyUsageOccurrence::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_NextAssemblyUsageOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_NextAssemblyUsageOccurrence::*)() const>(&StepRepr_NextAssemblyUsageOccurrence::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ParallelOffset from ./opencascade/StepRepr_ParallelOffset.hxx
    klass = m.attr("StepRepr_ParallelOffset");


    // nested enums

    static_cast<py::class_<StepRepr_ParallelOffset ,opencascade::handle<StepRepr_ParallelOffset>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ParallelOffset::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ProductDefinitionShape> & ,   const StepData_Logical ,   const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_ParallelOffset::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_ProductDefinitionShape> & ,   const StepData_Logical ,   const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_ParallelOffset::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theName"),  py::arg("theDescription"),  py::arg("theOfShape"),  py::arg("theProductDefinitional"),  py::arg("theOffset")
          )
        .def("Offset",
             (handle<StepBasic_MeasureWithUnit> (StepRepr_ParallelOffset::*)() const) static_cast<handle<StepBasic_MeasureWithUnit> (StepRepr_ParallelOffset::*)() const>(&StepRepr_ParallelOffset::Offset),
             R"#(Returns field Offset)#" 
          )
        .def("SetOffset",
             (void (StepRepr_ParallelOffset::*)(  const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_ParallelOffset::*)(  const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_ParallelOffset::SetOffset),
             R"#(Set field Offset)#"  , py::arg("theOffset")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ParallelOffset::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ParallelOffset::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ParallelOffset::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ParallelOffset::*)() const>(&StepRepr_ParallelOffset::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_PerpendicularTo from ./opencascade/StepRepr_PerpendicularTo.hxx
    klass = m.attr("StepRepr_PerpendicularTo");


    // nested enums

    static_cast<py::class_<StepRepr_PerpendicularTo ,opencascade::handle<StepRepr_PerpendicularTo>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_PerpendicularTo::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_PerpendicularTo::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_PerpendicularTo::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_PerpendicularTo::*)() const>(&StepRepr_PerpendicularTo::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_PromissoryUsageOccurrence from ./opencascade/StepRepr_PromissoryUsageOccurrence.hxx
    klass = m.attr("StepRepr_PromissoryUsageOccurrence");


    // nested enums

    static_cast<py::class_<StepRepr_PromissoryUsageOccurrence ,opencascade::handle<StepRepr_PromissoryUsageOccurrence>  , StepRepr_AssemblyComponentUsage >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_PromissoryUsageOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_PromissoryUsageOccurrence::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_PromissoryUsageOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_PromissoryUsageOccurrence::*)() const>(&StepRepr_PromissoryUsageOccurrence::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_QuantifiedAssemblyComponentUsage from ./opencascade/StepRepr_QuantifiedAssemblyComponentUsage.hxx
    klass = m.attr("StepRepr_QuantifiedAssemblyComponentUsage");


    // nested enums

    static_cast<py::class_<StepRepr_QuantifiedAssemblyComponentUsage ,opencascade::handle<StepRepr_QuantifiedAssemblyComponentUsage>  , StepRepr_AssemblyComponentUsage >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_QuantifiedAssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_QuantifiedAssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_QuantifiedAssemblyComponentUsage::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("hasAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aQuantity")
          )
        .def("Init",
             (void (StepRepr_QuantifiedAssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_QuantifiedAssemblyComponentUsage::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_QuantifiedAssemblyComponentUsage::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("hasAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aQuantity")
          )
        .def("Quantity",
             (handle<StepBasic_MeasureWithUnit> (StepRepr_QuantifiedAssemblyComponentUsage::*)() const) static_cast<handle<StepBasic_MeasureWithUnit> (StepRepr_QuantifiedAssemblyComponentUsage::*)() const>(&StepRepr_QuantifiedAssemblyComponentUsage::Quantity),
             R"#(Returns field Quantity)#" 
          )
        .def("SetQuantity",
             (void (StepRepr_QuantifiedAssemblyComponentUsage::*)(  const handle<StepBasic_MeasureWithUnit> &  ) ) static_cast<void (StepRepr_QuantifiedAssemblyComponentUsage::*)(  const handle<StepBasic_MeasureWithUnit> &  ) >(&StepRepr_QuantifiedAssemblyComponentUsage::SetQuantity),
             R"#(Set field Quantity)#"  , py::arg("Quantity")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_QuantifiedAssemblyComponentUsage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_QuantifiedAssemblyComponentUsage::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_QuantifiedAssemblyComponentUsage::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_QuantifiedAssemblyComponentUsage::*)() const>(&StepRepr_QuantifiedAssemblyComponentUsage::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ReprItemAndLengthMeasureWithUnit from ./opencascade/StepRepr_ReprItemAndLengthMeasureWithUnit.hxx
    klass = m.attr("StepRepr_ReprItemAndLengthMeasureWithUnit");


    // nested enums

    static_cast<py::class_<StepRepr_ReprItemAndLengthMeasureWithUnit ,opencascade::handle<StepRepr_ReprItemAndLengthMeasureWithUnit>  , StepRepr_ReprItemAndMeasureWithUnit >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetLengthMeasureWithUnit",
             (void (StepRepr_ReprItemAndLengthMeasureWithUnit::*)(  const handle<StepBasic_LengthMeasureWithUnit> &  ) ) static_cast<void (StepRepr_ReprItemAndLengthMeasureWithUnit::*)(  const handle<StepBasic_LengthMeasureWithUnit> &  ) >(&StepRepr_ReprItemAndLengthMeasureWithUnit::SetLengthMeasureWithUnit),
             R"#()#"  , py::arg("aLMWU")
          )
        .def("GetLengthMeasureWithUnit",
             (handle<StepBasic_LengthMeasureWithUnit> (StepRepr_ReprItemAndLengthMeasureWithUnit::*)() const) static_cast<handle<StepBasic_LengthMeasureWithUnit> (StepRepr_ReprItemAndLengthMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndLengthMeasureWithUnit::GetLengthMeasureWithUnit),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ReprItemAndLengthMeasureWithUnit::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ReprItemAndLengthMeasureWithUnit::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ReprItemAndLengthMeasureWithUnit::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ReprItemAndLengthMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndLengthMeasureWithUnit::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ReprItemAndMeasureWithUnitAndQRI from ./opencascade/StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx
    klass = m.attr("StepRepr_ReprItemAndMeasureWithUnitAndQRI");


    // nested enums

    static_cast<py::class_<StepRepr_ReprItemAndMeasureWithUnitAndQRI ,opencascade::handle<StepRepr_ReprItemAndMeasureWithUnitAndQRI>  , StepRepr_ReprItemAndMeasureWithUnit >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)(  const handle<StepBasic_MeasureWithUnit> & ,   const handle<StepRepr_RepresentationItem> & ,   const handle<StepShape_QualifiedRepresentationItem> &  ) ) static_cast<void (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)(  const handle<StepBasic_MeasureWithUnit> & ,   const handle<StepRepr_RepresentationItem> & ,   const handle<StepShape_QualifiedRepresentationItem> &  ) >(&StepRepr_ReprItemAndMeasureWithUnitAndQRI::Init),
             R"#()#"  , py::arg("aMWU"),  py::arg("aRI"),  py::arg("aQRI")
          )
        .def("SetQualifiedRepresentationItem",
             (void (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)(  const handle<StepShape_QualifiedRepresentationItem> &  ) ) static_cast<void (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)(  const handle<StepShape_QualifiedRepresentationItem> &  ) >(&StepRepr_ReprItemAndMeasureWithUnitAndQRI::SetQualifiedRepresentationItem),
             R"#()#"  , py::arg("aQRI")
          )
        .def("GetQualifiedRepresentationItem",
             (handle<StepShape_QualifiedRepresentationItem> (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)() const) static_cast<handle<StepShape_QualifiedRepresentationItem> (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)() const>(&StepRepr_ReprItemAndMeasureWithUnitAndQRI::GetQualifiedRepresentationItem),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ReprItemAndMeasureWithUnitAndQRI::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ReprItemAndMeasureWithUnitAndQRI::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ReprItemAndMeasureWithUnitAndQRI::*)() const>(&StepRepr_ReprItemAndMeasureWithUnitAndQRI::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ReprItemAndPlaneAngleMeasureWithUnit from ./opencascade/StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx
    klass = m.attr("StepRepr_ReprItemAndPlaneAngleMeasureWithUnit");


    // nested enums

    static_cast<py::class_<StepRepr_ReprItemAndPlaneAngleMeasureWithUnit ,opencascade::handle<StepRepr_ReprItemAndPlaneAngleMeasureWithUnit>  , StepRepr_ReprItemAndMeasureWithUnit >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetPlaneAngleMeasureWithUnit",
             (void (StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::*)(  const handle<StepBasic_PlaneAngleMeasureWithUnit> &  ) ) static_cast<void (StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::*)(  const handle<StepBasic_PlaneAngleMeasureWithUnit> &  ) >(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::SetPlaneAngleMeasureWithUnit),
             R"#()#"  , py::arg("aLMWU")
          )
        .def("GetPlaneAngleMeasureWithUnit",
             (handle<StepBasic_PlaneAngleMeasureWithUnit> (StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::*)() const) static_cast<handle<StepBasic_PlaneAngleMeasureWithUnit> (StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::GetPlaneAngleMeasureWithUnit),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::*)() const>(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_RepresentationRelationshipWithTransformation from ./opencascade/StepRepr_RepresentationRelationshipWithTransformation.hxx
    klass = m.attr("StepRepr_RepresentationRelationshipWithTransformation");


    // nested enums

    static_cast<py::class_<StepRepr_RepresentationRelationshipWithTransformation ,opencascade::handle<StepRepr_RepresentationRelationshipWithTransformation>  , StepRepr_ShapeRepresentationRelationship >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_RepresentationRelationshipWithTransformation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_Representation> & ,   const handle<StepRepr_Representation> & ,   const StepRepr_Transformation &  ) ) static_cast<void (StepRepr_RepresentationRelationshipWithTransformation::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_Representation> & ,   const handle<StepRepr_Representation> & ,   const StepRepr_Transformation &  ) >(&StepRepr_RepresentationRelationshipWithTransformation::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aRep1"),  py::arg("aRep2"),  py::arg("aTransf")
          )
        .def("TransformationOperator",
             (StepRepr_Transformation (StepRepr_RepresentationRelationshipWithTransformation::*)() const) static_cast<StepRepr_Transformation (StepRepr_RepresentationRelationshipWithTransformation::*)() const>(&StepRepr_RepresentationRelationshipWithTransformation::TransformationOperator),
             R"#()#" 
          )
        .def("SetTransformationOperator",
             (void (StepRepr_RepresentationRelationshipWithTransformation::*)(  const StepRepr_Transformation &  ) ) static_cast<void (StepRepr_RepresentationRelationshipWithTransformation::*)(  const StepRepr_Transformation &  ) >(&StepRepr_RepresentationRelationshipWithTransformation::SetTransformationOperator),
             R"#()#"  , py::arg("aTrans")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_RepresentationRelationshipWithTransformation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_RepresentationRelationshipWithTransformation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_RepresentationRelationshipWithTransformation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_RepresentationRelationshipWithTransformation::*)() const>(&StepRepr_RepresentationRelationshipWithTransformation::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_SpecifiedHigherUsageOccurrence from ./opencascade/StepRepr_SpecifiedHigherUsageOccurrence.hxx
    klass = m.attr("StepRepr_SpecifiedHigherUsageOccurrence");


    // nested enums

    static_cast<py::class_<StepRepr_SpecifiedHigherUsageOccurrence ,opencascade::handle<StepRepr_SpecifiedHigherUsageOccurrence>  , StepRepr_AssemblyComponentUsage >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_AssemblyComponentUsage> & ,   const handle<StepRepr_NextAssemblyUsageOccurrence> &  ) ) static_cast<void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepBasic_ProductDefinition> & ,   const handle<StepBasic_ProductDefinition> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_AssemblyComponentUsage> & ,   const handle<StepRepr_NextAssemblyUsageOccurrence> &  ) >(&StepRepr_SpecifiedHigherUsageOccurrence::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("hasAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aUpperUsage"),  py::arg("aNextUsage")
          )
        .def("Init",
             (void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_AssemblyComponentUsage> & ,   const handle<StepRepr_NextAssemblyUsageOccurrence> &  ) ) static_cast<void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const StepBasic_ProductDefinitionOrReference & ,   const StepBasic_ProductDefinitionOrReference & ,   const Standard_Boolean ,   const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_AssemblyComponentUsage> & ,   const handle<StepRepr_NextAssemblyUsageOccurrence> &  ) >(&StepRepr_SpecifiedHigherUsageOccurrence::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("aProductDefinitionRelationship_Id"),  py::arg("aProductDefinitionRelationship_Name"),  py::arg("hasProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_Description"),  py::arg("aProductDefinitionRelationship_RelatingProductDefinition"),  py::arg("aProductDefinitionRelationship_RelatedProductDefinition"),  py::arg("hasAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aAssemblyComponentUsage_ReferenceDesignator"),  py::arg("aUpperUsage"),  py::arg("aNextUsage")
          )
        .def("UpperUsage",
             (handle<StepRepr_AssemblyComponentUsage> (StepRepr_SpecifiedHigherUsageOccurrence::*)() const) static_cast<handle<StepRepr_AssemblyComponentUsage> (StepRepr_SpecifiedHigherUsageOccurrence::*)() const>(&StepRepr_SpecifiedHigherUsageOccurrence::UpperUsage),
             R"#(Returns field UpperUsage)#" 
          )
        .def("SetUpperUsage",
             (void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<StepRepr_AssemblyComponentUsage> &  ) ) static_cast<void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<StepRepr_AssemblyComponentUsage> &  ) >(&StepRepr_SpecifiedHigherUsageOccurrence::SetUpperUsage),
             R"#(Set field UpperUsage)#"  , py::arg("UpperUsage")
          )
        .def("NextUsage",
             (handle<StepRepr_NextAssemblyUsageOccurrence> (StepRepr_SpecifiedHigherUsageOccurrence::*)() const) static_cast<handle<StepRepr_NextAssemblyUsageOccurrence> (StepRepr_SpecifiedHigherUsageOccurrence::*)() const>(&StepRepr_SpecifiedHigherUsageOccurrence::NextUsage),
             R"#(Returns field NextUsage)#" 
          )
        .def("SetNextUsage",
             (void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<StepRepr_NextAssemblyUsageOccurrence> &  ) ) static_cast<void (StepRepr_SpecifiedHigherUsageOccurrence::*)(  const handle<StepRepr_NextAssemblyUsageOccurrence> &  ) >(&StepRepr_SpecifiedHigherUsageOccurrence::SetNextUsage),
             R"#(Set field NextUsage)#"  , py::arg("NextUsage")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_SpecifiedHigherUsageOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_SpecifiedHigherUsageOccurrence::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_SpecifiedHigherUsageOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_SpecifiedHigherUsageOccurrence::*)() const>(&StepRepr_SpecifiedHigherUsageOccurrence::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_Tangent from ./opencascade/StepRepr_Tangent.hxx
    klass = m.attr("StepRepr_Tangent");


    // nested enums

    static_cast<py::class_<StepRepr_Tangent ,opencascade::handle<StepRepr_Tangent>  , StepRepr_DerivedShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_Tangent::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_Tangent::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_Tangent::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_Tangent::*)() const>(&StepRepr_Tangent::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ValueRange from ./opencascade/StepRepr_ValueRange.hxx
    klass = m.attr("StepRepr_ValueRange");


    // nested enums

    static_cast<py::class_<StepRepr_ValueRange ,opencascade::handle<StepRepr_ValueRange>  , StepRepr_CompoundRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ValueRange::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ValueRange::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ValueRange::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ValueRange::*)() const>(&StepRepr_ValueRange::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_AllAroundShapeAspect from ./opencascade/StepRepr_AllAroundShapeAspect.hxx
    klass = m.attr("StepRepr_AllAroundShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_AllAroundShapeAspect ,opencascade::handle<StepRepr_AllAroundShapeAspect>  , StepRepr_ContinuosShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_AllAroundShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_AllAroundShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_AllAroundShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_AllAroundShapeAspect::*)() const>(&StepRepr_AllAroundShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_BetweenShapeAspect from ./opencascade/StepRepr_BetweenShapeAspect.hxx
    klass = m.attr("StepRepr_BetweenShapeAspect");


    // nested enums

    static_cast<py::class_<StepRepr_BetweenShapeAspect ,opencascade::handle<StepRepr_BetweenShapeAspect>  , StepRepr_ContinuosShapeAspect >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_BetweenShapeAspect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_BetweenShapeAspect::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_BetweenShapeAspect::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_BetweenShapeAspect::*)() const>(&StepRepr_BetweenShapeAspect::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI from ./opencascade/StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx
    klass = m.attr("StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI");


    // nested enums

    static_cast<py::class_<StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI ,opencascade::handle<StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI>  , StepRepr_ReprItemAndMeasureWithUnitAndQRI >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetLengthMeasureWithUnit",
             (void (StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::*)(  const handle<StepBasic_LengthMeasureWithUnit> &  ) ) static_cast<void (StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::*)(  const handle<StepBasic_LengthMeasureWithUnit> &  ) >(&StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::SetLengthMeasureWithUnit),
             R"#()#"  , py::arg("aLMWU")
          )
        .def("GetLengthMeasureWithUnit",
             (handle<StepBasic_LengthMeasureWithUnit> (StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::*)() const) static_cast<handle<StepBasic_LengthMeasureWithUnit> (StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::*)() const>(&StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::GetLengthMeasureWithUnit),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::*)() const>(&StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI from ./opencascade/StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx
    klass = m.attr("StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI");


    // nested enums

    static_cast<py::class_<StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI ,opencascade::handle<StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI>  , StepRepr_ReprItemAndMeasureWithUnitAndQRI >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetPlaneAngleMeasureWithUnit",
             (void (StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::*)(  const handle<StepBasic_PlaneAngleMeasureWithUnit> &  ) ) static_cast<void (StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::*)(  const handle<StepBasic_PlaneAngleMeasureWithUnit> &  ) >(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::SetPlaneAngleMeasureWithUnit),
             R"#()#"  , py::arg("aLMWU")
          )
        .def("GetPlaneAngleMeasureWithUnit",
             (handle<StepBasic_PlaneAngleMeasureWithUnit> (StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::*)() const) static_cast<handle<StepBasic_PlaneAngleMeasureWithUnit> (StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::*)() const>(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::GetPlaneAngleMeasureWithUnit),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::*)() const>(&StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::DynamicType),
             R"#()#"
             
         )
;

    // Class StepRepr_ShapeRepresentationRelationshipWithTransformation from ./opencascade/StepRepr_ShapeRepresentationRelationshipWithTransformation.hxx
    klass = m.attr("StepRepr_ShapeRepresentationRelationshipWithTransformation");


    // nested enums

    static_cast<py::class_<StepRepr_ShapeRepresentationRelationshipWithTransformation ,opencascade::handle<StepRepr_ShapeRepresentationRelationshipWithTransformation>  , StepRepr_RepresentationRelationshipWithTransformation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepRepr_ShapeRepresentationRelationshipWithTransformation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepRepr_ShapeRepresentationRelationshipWithTransformation::get_type_descriptor),
                    R"#()#" 
          )
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepRepr_ShapeRepresentationRelationshipWithTransformation::*)() const) static_cast< const handle<Standard_Type> & (StepRepr_ShapeRepresentationRelationshipWithTransformation::*)() const>(&StepRepr_ShapeRepresentationRelationshipWithTransformation::DynamicType),
             R"#()#"
             
         )
;

// functions

// ./opencascade/StepRepr_AllAroundShapeAspect.hxx
// ./opencascade/StepRepr_Apex.hxx
// ./opencascade/StepRepr_Array1OfMaterialPropertyRepresentation.hxx
// ./opencascade/StepRepr_Array1OfPropertyDefinitionRepresentation.hxx
// ./opencascade/StepRepr_Array1OfRepresentationItem.hxx
// ./opencascade/StepRepr_Array1OfShapeAspect.hxx
// ./opencascade/StepRepr_AssemblyComponentUsage.hxx
// ./opencascade/StepRepr_AssemblyComponentUsageSubstitute.hxx
// ./opencascade/StepRepr_BetweenShapeAspect.hxx
// ./opencascade/StepRepr_BooleanRepresentationItem.hxx
// ./opencascade/StepRepr_CentreOfSymmetry.hxx
// ./opencascade/StepRepr_CharacterizedDefinition.hxx
// ./opencascade/StepRepr_CharacterizedRepresentation.hxx
// ./opencascade/StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx
// ./opencascade/StepRepr_CompShAspAndDatumFeatAndShAsp.hxx
// ./opencascade/StepRepr_CompositeGroupShapeAspect.hxx
// ./opencascade/StepRepr_CompositeShapeAspect.hxx
// ./opencascade/StepRepr_CompoundRepresentationItem.hxx
// ./opencascade/StepRepr_ConfigurationDesign.hxx
// ./opencascade/StepRepr_ConfigurationDesignItem.hxx
// ./opencascade/StepRepr_ConfigurationEffectivity.hxx
// ./opencascade/StepRepr_ConfigurationItem.hxx
// ./opencascade/StepRepr_ConstructiveGeometryRepresentation.hxx
// ./opencascade/StepRepr_ConstructiveGeometryRepresentationRelationship.hxx
// ./opencascade/StepRepr_ContinuosShapeAspect.hxx
// ./opencascade/StepRepr_DataEnvironment.hxx
// ./opencascade/StepRepr_DefinitionalRepresentation.hxx
// ./opencascade/StepRepr_DerivedShapeAspect.hxx
// ./opencascade/StepRepr_DescriptiveRepresentationItem.hxx
// ./opencascade/StepRepr_Extension.hxx
// ./opencascade/StepRepr_ExternallyDefinedRepresentation.hxx
// ./opencascade/StepRepr_FeatureForDatumTargetRelationship.hxx
// ./opencascade/StepRepr_FunctionallyDefinedTransformation.hxx
// ./opencascade/StepRepr_GeometricAlignment.hxx
// ./opencascade/StepRepr_GlobalUncertaintyAssignedContext.hxx
// ./opencascade/StepRepr_GlobalUnitAssignedContext.hxx
// ./opencascade/StepRepr_HArray1OfMaterialPropertyRepresentation.hxx
// ./opencascade/StepRepr_HArray1OfPropertyDefinitionRepresentation.hxx
// ./opencascade/StepRepr_HArray1OfRepresentationItem.hxx
// ./opencascade/StepRepr_HArray1OfShapeAspect.hxx
// ./opencascade/StepRepr_HSequenceOfMaterialPropertyRepresentation.hxx
// ./opencascade/StepRepr_HSequenceOfRepresentationItem.hxx
// ./opencascade/StepRepr_IntegerRepresentationItem.hxx
// ./opencascade/StepRepr_ItemDefinedTransformation.hxx
// ./opencascade/StepRepr_MakeFromUsageOption.hxx
// ./opencascade/StepRepr_MappedItem.hxx
// ./opencascade/StepRepr_MaterialDesignation.hxx
// ./opencascade/StepRepr_MaterialProperty.hxx
// ./opencascade/StepRepr_MaterialPropertyRepresentation.hxx
// ./opencascade/StepRepr_MeasureRepresentationItem.hxx
// ./opencascade/StepRepr_MechanicalDesignAndDraughtingRelationship.hxx
// ./opencascade/StepRepr_NextAssemblyUsageOccurrence.hxx
// ./opencascade/StepRepr_ParallelOffset.hxx
// ./opencascade/StepRepr_ParametricRepresentationContext.hxx
// ./opencascade/StepRepr_PerpendicularTo.hxx
// ./opencascade/StepRepr_ProductConcept.hxx
// ./opencascade/StepRepr_ProductDefinitionShape.hxx
// ./opencascade/StepRepr_ProductDefinitionUsage.hxx
// ./opencascade/StepRepr_PromissoryUsageOccurrence.hxx
// ./opencascade/StepRepr_PropertyDefinition.hxx
// ./opencascade/StepRepr_PropertyDefinitionRelationship.hxx
// ./opencascade/StepRepr_PropertyDefinitionRepresentation.hxx
// ./opencascade/StepRepr_QuantifiedAssemblyComponentUsage.hxx
// ./opencascade/StepRepr_RealRepresentationItem.hxx
// ./opencascade/StepRepr_ReprItemAndLengthMeasureWithUnit.hxx
// ./opencascade/StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx
// ./opencascade/StepRepr_ReprItemAndMeasureWithUnit.hxx
// ./opencascade/StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx
// ./opencascade/StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx
// ./opencascade/StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx
// ./opencascade/StepRepr_Representation.hxx
// ./opencascade/StepRepr_RepresentationContext.hxx
// ./opencascade/StepRepr_RepresentationContextReference.hxx
// ./opencascade/StepRepr_RepresentationItem.hxx
// ./opencascade/StepRepr_RepresentationMap.hxx
// ./opencascade/StepRepr_RepresentationOrRepresentationReference.hxx
// ./opencascade/StepRepr_RepresentationReference.hxx
// ./opencascade/StepRepr_RepresentationRelationship.hxx
// ./opencascade/StepRepr_RepresentationRelationshipWithTransformation.hxx
// ./opencascade/StepRepr_RepresentedDefinition.hxx
// ./opencascade/StepRepr_SequenceOfMaterialPropertyRepresentation.hxx
// ./opencascade/StepRepr_SequenceOfRepresentationItem.hxx
// ./opencascade/StepRepr_ShapeAspect.hxx
// ./opencascade/StepRepr_ShapeAspectDerivingRelationship.hxx
// ./opencascade/StepRepr_ShapeAspectRelationship.hxx
// ./opencascade/StepRepr_ShapeAspectTransition.hxx
// ./opencascade/StepRepr_ShapeDefinition.hxx
// ./opencascade/StepRepr_ShapeRepresentationRelationship.hxx
// ./opencascade/StepRepr_ShapeRepresentationRelationshipWithTransformation.hxx
// ./opencascade/StepRepr_SpecifiedHigherUsageOccurrence.hxx
// ./opencascade/StepRepr_StructuralResponseProperty.hxx
// ./opencascade/StepRepr_StructuralResponsePropertyDefinitionRepresentation.hxx
// ./opencascade/StepRepr_SuppliedPartRelationship.hxx
// ./opencascade/StepRepr_Tangent.hxx
// ./opencascade/StepRepr_Transformation.hxx
// ./opencascade/StepRepr_ValueRange.hxx
// ./opencascade/StepRepr_ValueRepresentationItem.hxx

// Additional functions


// operators

// register typdefs
    register_template_NCollection_Array1<opencascade::handle<StepRepr_MaterialPropertyRepresentation>>(m,"StepRepr_Array1OfMaterialPropertyRepresentation");
    register_template_NCollection_Array1<opencascade::handle<StepRepr_PropertyDefinitionRepresentation>>(m,"StepRepr_Array1OfPropertyDefinitionRepresentation");
    register_template_NCollection_Array1<opencascade::handle<StepRepr_RepresentationItem>>(m,"StepRepr_Array1OfRepresentationItem");
    register_template_NCollection_Array1<opencascade::handle<StepRepr_ShapeAspect>>(m,"StepRepr_Array1OfShapeAspect");
    register_template_NCollection_Sequence<opencascade::handle<StepRepr_MaterialPropertyRepresentation>>(m,"StepRepr_SequenceOfMaterialPropertyRepresentation");
    register_template_NCollection_Sequence<opencascade::handle<StepRepr_RepresentationItem>>(m,"StepRepr_SequenceOfRepresentationItem");


// exceptions

// user-defined post-inclusion per module in the body

};

// user-defined post-inclusion per module

// user-defined post
