
// 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 <StepVisual_DraughtingCallout.hxx>
#include <StepVisual_StyledItem.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 <StepVisual_PresentationArea.hxx>
#include <StepVisual_PresentationSet.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_PresentationArea.hxx>
#include <StepVisual_PresentationView.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 <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 <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 <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 <StepVisual_PlanarBox.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepVisual_ViewVolume.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx>
#include <StepVisual_ViewVolume.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_Plane.hxx>
#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_Plane.hxx>
#include <StepVisual_CameraModelD3MultiClippingIntersection.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 <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 <StepVisual_PlanarExtent.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 <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 <StepVisual_Colour.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 <StepVisual_CurveStyleFont.hxx>
#include <StepVisual_PreDefinedCurveFont.hxx>
#include <StepVisual_ExternallyDefinedCurveFont.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 <StepVisual_AnnotationCurveOccurrence.hxx>
#include <StepVisual_AnnotationFillAreaOccurrence.hxx>
#include <StepVisual_AnnotationTextOccurrence.hxx>
#include <StepVisual_TessellatedAnnotationOccurrence.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 <StepGeom_Curve.hxx>
#include <StepShape_Edge.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 <StepShape_Face.hxx>
#include <StepGeom_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 <StepVisual_Colour.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_FillAreaStyleColour.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_PreDefinedTextFont.hxx>
#include <StepVisual_ExternallyDefinedTextFont.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 <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 <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 <StepVisual_DraughtingModel.hxx>
#include <StepVisual_PresentationRepresentation.hxx>
#include <StepVisual_PresentationSet.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_StyledItem.hxx>
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_PresentationRepresentation.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_PresentationRepresentation.hxx>
#include <StepRepr_RepresentationItem.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 <StepData_SelectMember.hxx>
#include <StepVisual_MarkerMember.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 <StepGeom_CompositeCurve.hxx>
#include <StepShape_Path.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 <TCollection_HAsciiString.hxx>
#include <StepVisual_Colour.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_PreDefinedItem.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 <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_PresentationRepresentation.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 <StepVisual_PresentationRepresentation.hxx>
#include <StepVisual_PresentationSet.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 <StepVisual_PlanarBox.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_PresentationView.hxx>
#include <StepVisual_PresentationArea.hxx>
#include <StepVisual_AreaInSet.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 <StepVisual_PointStyle.hxx>
#include <StepVisual_CurveStyle.hxx>
#include <StepVisual_NullStyleMember.hxx>
#include <StepVisual_SurfaceStyleUsage.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 <StepVisual_PresentedItem.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_SurfaceStyleReflectanceAmbient.hxx>
#include <StepVisual_SurfaceStyleTransparent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepGeom_Axis2Placement3d.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_Representation.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepVisual_PresentationSet.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 <StepGeom_GeometricRepresentationItem.hxx>
#include <StepRepr_MappedItem.hxx>
#include <StepRepr_Representation.hxx>
#include <StepShape_TopologicalRepresentationItem.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 <StepVisual_CurveStyle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_CurveStyle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_SurfaceStyleFillArea.hxx>
#include <StepVisual_SurfaceStyleBoundary.hxx>
#include <StepVisual_SurfaceStyleParameterLine.hxx>
#include <StepVisual_SurfaceStyleRendering.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_FillAreaStyle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_CurveStyle.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 <StepVisual_CurveStyle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_CurveStyle.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 <StepVisual_SurfaceSideStyle.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 <StepVisual_TessellatedEdge.hxx>
#include <StepVisual_TessellatedVertex.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 <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 <StepVisual_AnnotationText.hxx>
#include <StepVisual_CompositeText.hxx>
#include <StepVisual_TextLiteral.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 <StepVisual_TextStyleForDefinedFont.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <StepVisual_Colour.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_TextStyleForDefinedFont.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 <StepGeom_CartesianPoint.hxx>
#include <StepVisual_PlanarBox.hxx>

// module includes
#include <StepVisual_AnnotationCurveOccurrence.hxx>
#include <StepVisual_AnnotationCurveOccurrenceAndGeomReprItem.hxx>
#include <StepVisual_AnnotationFillArea.hxx>
#include <StepVisual_AnnotationFillAreaOccurrence.hxx>
#include <StepVisual_AnnotationOccurrence.hxx>
#include <StepVisual_AnnotationPlane.hxx>
#include <StepVisual_AnnotationPlaneElement.hxx>
#include <StepVisual_AnnotationText.hxx>
#include <StepVisual_AnnotationTextOccurrence.hxx>
#include <StepVisual_AreaInSet.hxx>
#include <StepVisual_AreaOrView.hxx>
#include <StepVisual_Array1OfAnnotationPlaneElement.hxx>
#include <StepVisual_Array1OfBoxCharacteristicSelect.hxx>
#include <StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect.hxx>
#include <StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect.hxx>
#include <StepVisual_Array1OfCurveStyleFontPattern.hxx>
#include <StepVisual_Array1OfDirectionCountSelect.hxx>
#include <StepVisual_Array1OfDraughtingCalloutElement.hxx>
#include <StepVisual_Array1OfFillStyleSelect.hxx>
#include <StepVisual_Array1OfInvisibleItem.hxx>
#include <StepVisual_Array1OfLayeredItem.hxx>
#include <StepVisual_Array1OfPresentationStyleAssignment.hxx>
#include <StepVisual_Array1OfPresentationStyleSelect.hxx>
#include <StepVisual_Array1OfRenderingPropertiesSelect.hxx>
#include <StepVisual_Array1OfStyleContextSelect.hxx>
#include <StepVisual_Array1OfSurfaceStyleElementSelect.hxx>
#include <StepVisual_Array1OfTessellatedEdgeOrVertex.hxx>
#include <StepVisual_Array1OfTessellatedStructuredItem.hxx>
#include <StepVisual_Array1OfTextOrCharacter.hxx>
#include <StepVisual_BackgroundColour.hxx>
#include <StepVisual_BoxCharacteristicSelect.hxx>
#include <StepVisual_CameraImage.hxx>
#include <StepVisual_CameraImage2dWithScale.hxx>
#include <StepVisual_CameraImage3dWithScale.hxx>
#include <StepVisual_CameraModel.hxx>
#include <StepVisual_CameraModelD2.hxx>
#include <StepVisual_CameraModelD3.hxx>
#include <StepVisual_CameraModelD3MultiClipping.hxx>
#include <StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx>
#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
#include <StepVisual_CameraModelD3MultiClippingUnionSelect.hxx>
#include <StepVisual_CameraUsage.hxx>
#include <StepVisual_CentralOrParallel.hxx>
#include <StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel.hxx>
#include <StepVisual_Colour.hxx>
#include <StepVisual_ColourRgb.hxx>
#include <StepVisual_ColourSpecification.hxx>
#include <StepVisual_ComplexTriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
#include <StepVisual_CompositeText.hxx>
#include <StepVisual_CompositeTextWithExtent.hxx>
#include <StepVisual_ContextDependentInvisibility.hxx>
#include <StepVisual_ContextDependentOverRidingStyledItem.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepVisual_CubicBezierTessellatedEdge.hxx>
#include <StepVisual_CubicBezierTriangulatedFace.hxx>
#include <StepVisual_CurveStyle.hxx>
#include <StepVisual_CurveStyleFont.hxx>
#include <StepVisual_CurveStyleFontPattern.hxx>
#include <StepVisual_CurveStyleFontSelect.hxx>
#include <StepVisual_DirectionCountSelect.hxx>
#include <StepVisual_DraughtingAnnotationOccurrence.hxx>
#include <StepVisual_DraughtingCallout.hxx>
#include <StepVisual_DraughtingCalloutElement.hxx>
#include <StepVisual_DraughtingModel.hxx>
#include <StepVisual_DraughtingPreDefinedColour.hxx>
#include <StepVisual_DraughtingPreDefinedCurveFont.hxx>
#include <StepVisual_EdgeOrCurve.hxx>
#include <StepVisual_ExternallyDefinedCurveFont.hxx>
#include <StepVisual_ExternallyDefinedTextFont.hxx>
#include <StepVisual_FaceOrSurface.hxx>
#include <StepVisual_FillAreaStyle.hxx>
#include <StepVisual_FillAreaStyleColour.hxx>
#include <StepVisual_FillStyleSelect.hxx>
#include <StepVisual_FontSelect.hxx>
#include <StepVisual_HArray1OfAnnotationPlaneElement.hxx>
#include <StepVisual_HArray1OfBoxCharacteristicSelect.hxx>
#include <StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx>
#include <StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx>
#include <StepVisual_HArray1OfCurveStyleFontPattern.hxx>
#include <StepVisual_HArray1OfDirectionCountSelect.hxx>
#include <StepVisual_HArray1OfDraughtingCalloutElement.hxx>
#include <StepVisual_HArray1OfFillStyleSelect.hxx>
#include <StepVisual_HArray1OfInvisibleItem.hxx>
#include <StepVisual_HArray1OfLayeredItem.hxx>
#include <StepVisual_HArray1OfPresentationStyleAssignment.hxx>
#include <StepVisual_HArray1OfPresentationStyleSelect.hxx>
#include <StepVisual_HArray1OfRenderingPropertiesSelect.hxx>
#include <StepVisual_HArray1OfStyleContextSelect.hxx>
#include <StepVisual_HArray1OfSurfaceStyleElementSelect.hxx>
#include <StepVisual_HArray1OfTessellatedEdgeOrVertex.hxx>
#include <StepVisual_HArray1OfTessellatedStructuredItem.hxx>
#include <StepVisual_HArray1OfTextOrCharacter.hxx>
#include <StepVisual_Invisibility.hxx>
#include <StepVisual_InvisibilityContext.hxx>
#include <StepVisual_InvisibleItem.hxx>
#include <StepVisual_LayeredItem.hxx>
#include <StepVisual_MarkerMember.hxx>
#include <StepVisual_MarkerSelect.hxx>
#include <StepVisual_MarkerType.hxx>
#include <StepVisual_MechanicalDesignGeometricPresentationArea.hxx>
#include <StepVisual_MechanicalDesignGeometricPresentationRepresentation.hxx>
#include <StepVisual_NullStyle.hxx>
#include <StepVisual_NullStyleMember.hxx>
#include <StepVisual_OverRidingStyledItem.hxx>
#include <StepVisual_PathOrCompositeCurve.hxx>
#include <StepVisual_PlanarBox.hxx>
#include <StepVisual_PlanarExtent.hxx>
#include <StepVisual_PointStyle.hxx>
#include <StepVisual_PreDefinedColour.hxx>
#include <StepVisual_PreDefinedCurveFont.hxx>
#include <StepVisual_PreDefinedItem.hxx>
#include <StepVisual_PreDefinedTextFont.hxx>
#include <StepVisual_PresentationArea.hxx>
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_PresentationLayerUsage.hxx>
#include <StepVisual_PresentationRepresentation.hxx>
#include <StepVisual_PresentationRepresentationSelect.hxx>
#include <StepVisual_PresentationSet.hxx>
#include <StepVisual_PresentationSize.hxx>
#include <StepVisual_PresentationSizeAssignmentSelect.hxx>
#include <StepVisual_PresentationStyleAssignment.hxx>
#include <StepVisual_PresentationStyleByContext.hxx>
#include <StepVisual_PresentationStyleSelect.hxx>
#include <StepVisual_PresentationView.hxx>
#include <StepVisual_PresentedItem.hxx>
#include <StepVisual_PresentedItemRepresentation.hxx>
#include <StepVisual_RenderingPropertiesSelect.hxx>
#include <StepVisual_RepositionedTessellatedGeometricSet.hxx>
#include <StepVisual_RepositionedTessellatedItem.hxx>
#include <StepVisual_ShadingSurfaceMethod.hxx>
#include <StepVisual_StyleContextSelect.hxx>
#include <StepVisual_StyledItem.hxx>
#include <StepVisual_StyledItemTarget.hxx>
#include <StepVisual_SurfaceSide.hxx>
#include <StepVisual_SurfaceSideStyle.hxx>
#include <StepVisual_SurfaceStyleBoundary.hxx>
#include <StepVisual_SurfaceStyleControlGrid.hxx>
#include <StepVisual_SurfaceStyleElementSelect.hxx>
#include <StepVisual_SurfaceStyleFillArea.hxx>
#include <StepVisual_SurfaceStyleParameterLine.hxx>
#include <StepVisual_SurfaceStyleReflectanceAmbient.hxx>
#include <StepVisual_SurfaceStyleRendering.hxx>
#include <StepVisual_SurfaceStyleRenderingWithProperties.hxx>
#include <StepVisual_SurfaceStyleSegmentationCurve.hxx>
#include <StepVisual_SurfaceStyleSilhouette.hxx>
#include <StepVisual_SurfaceStyleTransparent.hxx>
#include <StepVisual_SurfaceStyleUsage.hxx>
#include <StepVisual_Template.hxx>
#include <StepVisual_TemplateInstance.hxx>
#include <StepVisual_TessellatedAnnotationOccurrence.hxx>
#include <StepVisual_TessellatedConnectingEdge.hxx>
#include <StepVisual_TessellatedCurveSet.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <StepVisual_TessellatedEdgeOrVertex.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <StepVisual_TessellatedGeometricSet.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_TessellatedPointSet.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedSurfaceSet.hxx>
#include <StepVisual_TessellatedVertex.hxx>
#include <StepVisual_TessellatedWire.hxx>
#include <StepVisual_TextLiteral.hxx>
#include <StepVisual_TextOrCharacter.hxx>
#include <StepVisual_TextPath.hxx>
#include <StepVisual_TextStyle.hxx>
#include <StepVisual_TextStyleForDefinedFont.hxx>
#include <StepVisual_TextStyleWithBoxCharacteristics.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <StepVisual_TriangulatedSurfaceSet.hxx>
#include <StepVisual_ViewVolume.hxx>

// template related includes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

// user-defined inclusion per module
#include <StepRepr_RepresentationContext.hxx>

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


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

//Python trampoline classes

// classes

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationFillArea ,opencascade::handle<StepVisual_AnnotationFillArea>  , StepShape_GeometricCurveSet >>(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 * (*)() >(&StepVisual_AnnotationFillArea::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationFillArea::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> & (StepVisual_AnnotationFillArea::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationFillArea::*)() const>(&StepVisual_AnnotationFillArea::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationPlaneElement , shared_ptr<StepVisual_AnnotationPlaneElement>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_AnnotationPlaneElement::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_AnnotationPlaneElement::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_AnnotationPlaneElement::CaseNum),
             R"#(Recognizes a IdAttributeSelect Kind Entity that is : 1 -> DraughtingCallout 2 -> StyledItem 0 else)#"  , py::arg("ent")
          )
        .def("DraughtingCallout",
             (handle<StepVisual_DraughtingCallout> (StepVisual_AnnotationPlaneElement::*)() const) static_cast<handle<StepVisual_DraughtingCallout> (StepVisual_AnnotationPlaneElement::*)() const>(&StepVisual_AnnotationPlaneElement::DraughtingCallout),
             R"#(returns Value as a DraughtingCallout (Null if another type))#" 
          )
        .def("StyledItem",
             (handle<StepVisual_StyledItem> (StepVisual_AnnotationPlaneElement::*)() const) static_cast<handle<StepVisual_StyledItem> (StepVisual_AnnotationPlaneElement::*)() const>(&StepVisual_AnnotationPlaneElement::StyledItem),
             R"#(returns Value as a StyledItem (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 StepVisual_AnnotationText from ./opencascade/StepVisual_AnnotationText.hxx
    klass = m.attr("StepVisual_AnnotationText");


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationText ,opencascade::handle<StepVisual_AnnotationText>  , StepRepr_MappedItem >>(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 * (*)() >(&StepVisual_AnnotationText::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationText::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> & (StepVisual_AnnotationText::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationText::*)() const>(&StepVisual_AnnotationText::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AreaInSet ,opencascade::handle<StepVisual_AreaInSet>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_AreaInSet::*)(  const handle<StepVisual_PresentationArea> & ,   const handle<StepVisual_PresentationSet> &  ) ) static_cast<void (StepVisual_AreaInSet::*)(  const handle<StepVisual_PresentationArea> & ,   const handle<StepVisual_PresentationSet> &  ) >(&StepVisual_AreaInSet::Init),
             R"#()#"  , py::arg("aArea"),  py::arg("aInSet")
          )
        .def("SetArea",
             (void (StepVisual_AreaInSet::*)(  const handle<StepVisual_PresentationArea> &  ) ) static_cast<void (StepVisual_AreaInSet::*)(  const handle<StepVisual_PresentationArea> &  ) >(&StepVisual_AreaInSet::SetArea),
             R"#()#"  , py::arg("aArea")
          )
        .def("Area",
             (handle<StepVisual_PresentationArea> (StepVisual_AreaInSet::*)() const) static_cast<handle<StepVisual_PresentationArea> (StepVisual_AreaInSet::*)() const>(&StepVisual_AreaInSet::Area),
             R"#()#" 
          )
        .def("SetInSet",
             (void (StepVisual_AreaInSet::*)(  const handle<StepVisual_PresentationSet> &  ) ) static_cast<void (StepVisual_AreaInSet::*)(  const handle<StepVisual_PresentationSet> &  ) >(&StepVisual_AreaInSet::SetInSet),
             R"#()#"  , py::arg("aInSet")
          )
        .def("InSet",
             (handle<StepVisual_PresentationSet> (StepVisual_AreaInSet::*)() const) static_cast<handle<StepVisual_PresentationSet> (StepVisual_AreaInSet::*)() const>(&StepVisual_AreaInSet::InSet),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_AreaInSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AreaInSet::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> & (StepVisual_AreaInSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AreaInSet::*)() const>(&StepVisual_AreaInSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AreaOrView , shared_ptr<StepVisual_AreaOrView>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_AreaOrView::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_AreaOrView::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_AreaOrView::CaseNum),
             R"#(Recognizes a AreaOrView Kind Entity that is : 1 -> PresentationArea 2 -> PresentationView 0 else)#"  , py::arg("ent")
          )
        .def("PresentationArea",
             (handle<StepVisual_PresentationArea> (StepVisual_AreaOrView::*)() const) static_cast<handle<StepVisual_PresentationArea> (StepVisual_AreaOrView::*)() const>(&StepVisual_AreaOrView::PresentationArea),
             R"#(returns Value as a PresentationArea (Null if another type))#" 
          )
        .def("PresentationView",
             (handle<StepVisual_PresentationView> (StepVisual_AreaOrView::*)() const) static_cast<handle<StepVisual_PresentationView> (StepVisual_AreaOrView::*)() const>(&StepVisual_AreaOrView::PresentationView),
             R"#(returns Value as a PresentationView (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 StepVisual_BoxCharacteristicSelect from ./opencascade/StepVisual_BoxCharacteristicSelect.hxx
    klass = m.attr("StepVisual_BoxCharacteristicSelect");


    // nested enums

    static_cast<py::class_<StepVisual_BoxCharacteristicSelect , shared_ptr<StepVisual_BoxCharacteristicSelect>  >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("TypeOfContent",
             (Standard_Integer (StepVisual_BoxCharacteristicSelect::*)() const) static_cast<Standard_Integer (StepVisual_BoxCharacteristicSelect::*)() const>(&StepVisual_BoxCharacteristicSelect::TypeOfContent),
             R"#()#" 
          )
        .def("SetTypeOfContent",
             (void (StepVisual_BoxCharacteristicSelect::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_BoxCharacteristicSelect::*)(  const Standard_Integer  ) >(&StepVisual_BoxCharacteristicSelect::SetTypeOfContent),
             R"#()#"  , py::arg("aType")
          )
        .def("RealValue",
             (Standard_Real (StepVisual_BoxCharacteristicSelect::*)() const) static_cast<Standard_Real (StepVisual_BoxCharacteristicSelect::*)() const>(&StepVisual_BoxCharacteristicSelect::RealValue),
             R"#()#" 
          )
        .def("SetRealValue",
             (void (StepVisual_BoxCharacteristicSelect::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_BoxCharacteristicSelect::*)(  const Standard_Real  ) >(&StepVisual_BoxCharacteristicSelect::SetRealValue),
             R"#()#"  , py::arg("aValue")
          )
    // 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 StepVisual_CameraImage from ./opencascade/StepVisual_CameraImage.hxx
    klass = m.attr("StepVisual_CameraImage");


    // nested enums

    static_cast<py::class_<StepVisual_CameraImage ,opencascade::handle<StepVisual_CameraImage>  , StepRepr_MappedItem >>(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 * (*)() >(&StepVisual_CameraImage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraImage::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> & (StepVisual_CameraImage::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraImage::*)() const>(&StepVisual_CameraImage::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModel ,opencascade::handle<StepVisual_CameraModel>  , StepGeom_GeometricRepresentationItem >>(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 * (*)() >(&StepVisual_CameraModel::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraModel::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> & (StepVisual_CameraModel::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraModel::*)() const>(&StepVisual_CameraModel::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD3MultiClippingInterectionSelect , shared_ptr<StepVisual_CameraModelD3MultiClippingInterectionSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_CameraModelD3MultiClippingInterectionSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_CameraModelD3MultiClippingInterectionSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_CameraModelD3MultiClippingInterectionSelect::CaseNum),
             R"#(Recognizes a IdAttributeSelect Kind Entity that is : 1 -> Plane 2 -> CameraModelD3MultiClippingUnion 0 else)#"  , py::arg("ent")
          )
        .def("Plane",
             (handle<StepGeom_Plane> (StepVisual_CameraModelD3MultiClippingInterectionSelect::*)() const) static_cast<handle<StepGeom_Plane> (StepVisual_CameraModelD3MultiClippingInterectionSelect::*)() const>(&StepVisual_CameraModelD3MultiClippingInterectionSelect::Plane),
             R"#(returns Value as a Plane (Null if another type))#" 
          )
        .def("CameraModelD3MultiClippingUnion",
             (handle<StepVisual_CameraModelD3MultiClippingUnion> (StepVisual_CameraModelD3MultiClippingInterectionSelect::*)() const) static_cast<handle<StepVisual_CameraModelD3MultiClippingUnion> (StepVisual_CameraModelD3MultiClippingInterectionSelect::*)() const>(&StepVisual_CameraModelD3MultiClippingInterectionSelect::CameraModelD3MultiClippingUnion),
             R"#(returns Value as a CameraModelD3MultiClippingUnion (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 StepVisual_CameraModelD3MultiClippingIntersection from ./opencascade/StepVisual_CameraModelD3MultiClippingIntersection.hxx
    klass = m.attr("StepVisual_CameraModelD3MultiClippingIntersection");


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD3MultiClippingIntersection ,opencascade::handle<StepVisual_CameraModelD3MultiClippingIntersection>  , StepGeom_GeometricRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CameraModelD3MultiClippingIntersection::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) ) static_cast<void (StepVisual_CameraModelD3MultiClippingIntersection::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) >(&StepVisual_CameraModelD3MultiClippingIntersection::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theShapeClipping")
          )
        .def("SetShapeClipping",
             (void (StepVisual_CameraModelD3MultiClippingIntersection::*)(  const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) ) static_cast<void (StepVisual_CameraModelD3MultiClippingIntersection::*)(  const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) >(&StepVisual_CameraModelD3MultiClippingIntersection::SetShapeClipping),
             R"#()#"  , py::arg("theShapeClipping")
          )
        .def("ShapeClipping",
             ( const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> (StepVisual_CameraModelD3MultiClippingIntersection::*)() ) static_cast< const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> (StepVisual_CameraModelD3MultiClippingIntersection::*)() >(&StepVisual_CameraModelD3MultiClippingIntersection::ShapeClipping),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CameraModelD3MultiClippingIntersection::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraModelD3MultiClippingIntersection::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> & (StepVisual_CameraModelD3MultiClippingIntersection::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraModelD3MultiClippingIntersection::*)() const>(&StepVisual_CameraModelD3MultiClippingIntersection::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD3MultiClippingUnion ,opencascade::handle<StepVisual_CameraModelD3MultiClippingUnion>  , StepGeom_GeometricRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CameraModelD3MultiClippingUnion::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect> &  ) ) static_cast<void (StepVisual_CameraModelD3MultiClippingUnion::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect> &  ) >(&StepVisual_CameraModelD3MultiClippingUnion::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theShapeClipping")
          )
        .def("SetShapeClipping",
             (void (StepVisual_CameraModelD3MultiClippingUnion::*)(  const handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect> &  ) ) static_cast<void (StepVisual_CameraModelD3MultiClippingUnion::*)(  const handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect> &  ) >(&StepVisual_CameraModelD3MultiClippingUnion::SetShapeClipping),
             R"#()#"  , py::arg("theShapeClipping")
          )
        .def("ShapeClipping",
             ( const handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect> (StepVisual_CameraModelD3MultiClippingUnion::*)() ) static_cast< const handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect> (StepVisual_CameraModelD3MultiClippingUnion::*)() >(&StepVisual_CameraModelD3MultiClippingUnion::ShapeClipping),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CameraModelD3MultiClippingUnion::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraModelD3MultiClippingUnion::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> & (StepVisual_CameraModelD3MultiClippingUnion::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraModelD3MultiClippingUnion::*)() const>(&StepVisual_CameraModelD3MultiClippingUnion::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD3MultiClippingUnionSelect , shared_ptr<StepVisual_CameraModelD3MultiClippingUnionSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_CameraModelD3MultiClippingUnionSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_CameraModelD3MultiClippingUnionSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_CameraModelD3MultiClippingUnionSelect::CaseNum),
             R"#(Recognizes a IdAttributeSelect Kind Entity that is : 1 -> Plane 2 -> CameraModelD3MultiClippingIntersection 0 else)#"  , py::arg("ent")
          )
        .def("Plane",
             (handle<StepGeom_Plane> (StepVisual_CameraModelD3MultiClippingUnionSelect::*)() const) static_cast<handle<StepGeom_Plane> (StepVisual_CameraModelD3MultiClippingUnionSelect::*)() const>(&StepVisual_CameraModelD3MultiClippingUnionSelect::Plane),
             R"#(returns Value as a Plane (Null if another type))#" 
          )
        .def("CameraModelD3MultiClippingIntersection",
             (handle<StepVisual_CameraModelD3MultiClippingIntersection> (StepVisual_CameraModelD3MultiClippingUnionSelect::*)() const) static_cast<handle<StepVisual_CameraModelD3MultiClippingIntersection> (StepVisual_CameraModelD3MultiClippingUnionSelect::*)() const>(&StepVisual_CameraModelD3MultiClippingUnionSelect::CameraModelD3MultiClippingIntersection),
             R"#(returns Value as a CameraModelD3MultiClippingIntersection (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 StepVisual_CameraUsage from ./opencascade/StepVisual_CameraUsage.hxx
    klass = m.attr("StepVisual_CameraUsage");


    // nested enums

    static_cast<py::class_<StepVisual_CameraUsage ,opencascade::handle<StepVisual_CameraUsage>  , StepRepr_RepresentationMap >>(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 * (*)() >(&StepVisual_CameraUsage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraUsage::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> & (StepVisual_CameraUsage::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraUsage::*)() const>(&StepVisual_CameraUsage::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_Colour ,opencascade::handle<StepVisual_Colour>  , Standard_Transient >>(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 * (*)() >(&StepVisual_Colour::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_Colour::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> & (StepVisual_Colour::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_Colour::*)() const>(&StepVisual_Colour::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CompositeText ,opencascade::handle<StepVisual_CompositeText>  , StepGeom_GeometricRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CompositeText::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTextOrCharacter> &  ) ) static_cast<void (StepVisual_CompositeText::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTextOrCharacter> &  ) >(&StepVisual_CompositeText::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aCollectedText")
          )
        .def("SetCollectedText",
             (void (StepVisual_CompositeText::*)(  const handle<StepVisual_HArray1OfTextOrCharacter> &  ) ) static_cast<void (StepVisual_CompositeText::*)(  const handle<StepVisual_HArray1OfTextOrCharacter> &  ) >(&StepVisual_CompositeText::SetCollectedText),
             R"#()#"  , py::arg("aCollectedText")
          )
        .def("CollectedText",
             (handle<StepVisual_HArray1OfTextOrCharacter> (StepVisual_CompositeText::*)() const) static_cast<handle<StepVisual_HArray1OfTextOrCharacter> (StepVisual_CompositeText::*)() const>(&StepVisual_CompositeText::CollectedText),
             R"#()#" 
          )
        .def("CollectedTextValue",
             (StepVisual_TextOrCharacter (StepVisual_CompositeText::*)(  const Standard_Integer  ) const) static_cast<StepVisual_TextOrCharacter (StepVisual_CompositeText::*)(  const Standard_Integer  ) const>(&StepVisual_CompositeText::CollectedTextValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbCollectedText",
             (Standard_Integer (StepVisual_CompositeText::*)() const) static_cast<Standard_Integer (StepVisual_CompositeText::*)() const>(&StepVisual_CompositeText::NbCollectedText),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CompositeText::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CompositeText::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> & (StepVisual_CompositeText::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CompositeText::*)() const>(&StepVisual_CompositeText::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CurveStyle ,opencascade::handle<StepVisual_CurveStyle>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CurveStyle::*)(  const handle<TCollection_HAsciiString> & ,   const StepVisual_CurveStyleFontSelect & ,   const StepBasic_SizeSelect & ,   const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_CurveStyle::*)(  const handle<TCollection_HAsciiString> & ,   const StepVisual_CurveStyleFontSelect & ,   const StepBasic_SizeSelect & ,   const handle<StepVisual_Colour> &  ) >(&StepVisual_CurveStyle::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aCurveFont"),  py::arg("aCurveWidth"),  py::arg("aCurveColour")
          )
        .def("SetName",
             (void (StepVisual_CurveStyle::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_CurveStyle::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_CurveStyle::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_CurveStyle::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_CurveStyle::*)() const>(&StepVisual_CurveStyle::Name),
             R"#()#" 
          )
        .def("SetCurveFont",
             (void (StepVisual_CurveStyle::*)(  const StepVisual_CurveStyleFontSelect &  ) ) static_cast<void (StepVisual_CurveStyle::*)(  const StepVisual_CurveStyleFontSelect &  ) >(&StepVisual_CurveStyle::SetCurveFont),
             R"#()#"  , py::arg("aCurveFont")
          )
        .def("CurveFont",
             (StepVisual_CurveStyleFontSelect (StepVisual_CurveStyle::*)() const) static_cast<StepVisual_CurveStyleFontSelect (StepVisual_CurveStyle::*)() const>(&StepVisual_CurveStyle::CurveFont),
             R"#()#" 
          )
        .def("SetCurveWidth",
             (void (StepVisual_CurveStyle::*)(  const StepBasic_SizeSelect &  ) ) static_cast<void (StepVisual_CurveStyle::*)(  const StepBasic_SizeSelect &  ) >(&StepVisual_CurveStyle::SetCurveWidth),
             R"#()#"  , py::arg("aCurveWidth")
          )
        .def("CurveWidth",
             (StepBasic_SizeSelect (StepVisual_CurveStyle::*)() const) static_cast<StepBasic_SizeSelect (StepVisual_CurveStyle::*)() const>(&StepVisual_CurveStyle::CurveWidth),
             R"#()#" 
          )
        .def("SetCurveColour",
             (void (StepVisual_CurveStyle::*)(  const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_CurveStyle::*)(  const handle<StepVisual_Colour> &  ) >(&StepVisual_CurveStyle::SetCurveColour),
             R"#()#"  , py::arg("aCurveColour")
          )
        .def("CurveColour",
             (handle<StepVisual_Colour> (StepVisual_CurveStyle::*)() const) static_cast<handle<StepVisual_Colour> (StepVisual_CurveStyle::*)() const>(&StepVisual_CurveStyle::CurveColour),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CurveStyle::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CurveStyle::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> & (StepVisual_CurveStyle::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CurveStyle::*)() const>(&StepVisual_CurveStyle::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CurveStyleFont ,opencascade::handle<StepVisual_CurveStyleFont>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CurveStyleFont::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfCurveStyleFontPattern> &  ) ) static_cast<void (StepVisual_CurveStyleFont::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfCurveStyleFontPattern> &  ) >(&StepVisual_CurveStyleFont::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aPatternList")
          )
        .def("SetName",
             (void (StepVisual_CurveStyleFont::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_CurveStyleFont::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_CurveStyleFont::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_CurveStyleFont::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_CurveStyleFont::*)() const>(&StepVisual_CurveStyleFont::Name),
             R"#()#" 
          )
        .def("SetPatternList",
             (void (StepVisual_CurveStyleFont::*)(  const handle<StepVisual_HArray1OfCurveStyleFontPattern> &  ) ) static_cast<void (StepVisual_CurveStyleFont::*)(  const handle<StepVisual_HArray1OfCurveStyleFontPattern> &  ) >(&StepVisual_CurveStyleFont::SetPatternList),
             R"#()#"  , py::arg("aPatternList")
          )
        .def("PatternList",
             (handle<StepVisual_HArray1OfCurveStyleFontPattern> (StepVisual_CurveStyleFont::*)() const) static_cast<handle<StepVisual_HArray1OfCurveStyleFontPattern> (StepVisual_CurveStyleFont::*)() const>(&StepVisual_CurveStyleFont::PatternList),
             R"#()#" 
          )
        .def("PatternListValue",
             (handle<StepVisual_CurveStyleFontPattern> (StepVisual_CurveStyleFont::*)(  const Standard_Integer  ) const) static_cast<handle<StepVisual_CurveStyleFontPattern> (StepVisual_CurveStyleFont::*)(  const Standard_Integer  ) const>(&StepVisual_CurveStyleFont::PatternListValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbPatternList",
             (Standard_Integer (StepVisual_CurveStyleFont::*)() const) static_cast<Standard_Integer (StepVisual_CurveStyleFont::*)() const>(&StepVisual_CurveStyleFont::NbPatternList),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CurveStyleFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CurveStyleFont::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> & (StepVisual_CurveStyleFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CurveStyleFont::*)() const>(&StepVisual_CurveStyleFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CurveStyleFontPattern ,opencascade::handle<StepVisual_CurveStyleFontPattern>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CurveStyleFontPattern::*)(  const Standard_Real ,   const Standard_Real  ) ) static_cast<void (StepVisual_CurveStyleFontPattern::*)(  const Standard_Real ,   const Standard_Real  ) >(&StepVisual_CurveStyleFontPattern::Init),
             R"#()#"  , py::arg("aVisibleSegmentLength"),  py::arg("aInvisibleSegmentLength")
          )
        .def("SetVisibleSegmentLength",
             (void (StepVisual_CurveStyleFontPattern::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_CurveStyleFontPattern::*)(  const Standard_Real  ) >(&StepVisual_CurveStyleFontPattern::SetVisibleSegmentLength),
             R"#()#"  , py::arg("aVisibleSegmentLength")
          )
        .def("VisibleSegmentLength",
             (Standard_Real (StepVisual_CurveStyleFontPattern::*)() const) static_cast<Standard_Real (StepVisual_CurveStyleFontPattern::*)() const>(&StepVisual_CurveStyleFontPattern::VisibleSegmentLength),
             R"#()#" 
          )
        .def("SetInvisibleSegmentLength",
             (void (StepVisual_CurveStyleFontPattern::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_CurveStyleFontPattern::*)(  const Standard_Real  ) >(&StepVisual_CurveStyleFontPattern::SetInvisibleSegmentLength),
             R"#()#"  , py::arg("aInvisibleSegmentLength")
          )
        .def("InvisibleSegmentLength",
             (Standard_Real (StepVisual_CurveStyleFontPattern::*)() const) static_cast<Standard_Real (StepVisual_CurveStyleFontPattern::*)() const>(&StepVisual_CurveStyleFontPattern::InvisibleSegmentLength),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CurveStyleFontPattern::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CurveStyleFontPattern::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> & (StepVisual_CurveStyleFontPattern::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CurveStyleFontPattern::*)() const>(&StepVisual_CurveStyleFontPattern::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CurveStyleFontSelect , shared_ptr<StepVisual_CurveStyleFontSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_CurveStyleFontSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_CurveStyleFontSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_CurveStyleFontSelect::CaseNum),
             R"#(Recognizes a CurveStyleFontSelect Kind Entity that is : 1 -> CurveStyleFont 2 -> PreDefinedCurveFont 3 -> ExternallyDefinedCurveFont 0 else)#"  , py::arg("ent")
          )
        .def("CurveStyleFont",
             (handle<StepVisual_CurveStyleFont> (StepVisual_CurveStyleFontSelect::*)() const) static_cast<handle<StepVisual_CurveStyleFont> (StepVisual_CurveStyleFontSelect::*)() const>(&StepVisual_CurveStyleFontSelect::CurveStyleFont),
             R"#(returns Value as a CurveStyleFont (Null if another type))#" 
          )
        .def("PreDefinedCurveFont",
             (handle<StepVisual_PreDefinedCurveFont> (StepVisual_CurveStyleFontSelect::*)() const) static_cast<handle<StepVisual_PreDefinedCurveFont> (StepVisual_CurveStyleFontSelect::*)() const>(&StepVisual_CurveStyleFontSelect::PreDefinedCurveFont),
             R"#(returns Value as a PreDefinedCurveFont (Null if another type))#" 
          )
        .def("ExternallyDefinedCurveFont",
             (handle<StepVisual_ExternallyDefinedCurveFont> (StepVisual_CurveStyleFontSelect::*)() const) static_cast<handle<StepVisual_ExternallyDefinedCurveFont> (StepVisual_CurveStyleFontSelect::*)() const>(&StepVisual_CurveStyleFontSelect::ExternallyDefinedCurveFont),
             R"#(returns Value as a ExternallyDefinedCurveFont (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 StepVisual_DirectionCountSelect from ./opencascade/StepVisual_DirectionCountSelect.hxx
    klass = m.attr("StepVisual_DirectionCountSelect");


    // nested enums

    static_cast<py::class_<StepVisual_DirectionCountSelect , shared_ptr<StepVisual_DirectionCountSelect>  >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetTypeOfContent",
             (void (StepVisual_DirectionCountSelect::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_DirectionCountSelect::*)(  const Standard_Integer  ) >(&StepVisual_DirectionCountSelect::SetTypeOfContent),
             R"#()#"  , py::arg("aTypeOfContent")
          )
        .def("TypeOfContent",
             (Standard_Integer (StepVisual_DirectionCountSelect::*)() const) static_cast<Standard_Integer (StepVisual_DirectionCountSelect::*)() const>(&StepVisual_DirectionCountSelect::TypeOfContent),
             R"#()#" 
          )
        .def("UDirectionCount",
             (Standard_Integer (StepVisual_DirectionCountSelect::*)() const) static_cast<Standard_Integer (StepVisual_DirectionCountSelect::*)() const>(&StepVisual_DirectionCountSelect::UDirectionCount),
             R"#()#" 
          )
        .def("SetUDirectionCount",
             (void (StepVisual_DirectionCountSelect::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_DirectionCountSelect::*)(  const Standard_Integer  ) >(&StepVisual_DirectionCountSelect::SetUDirectionCount),
             R"#()#"  , py::arg("aUDirectionCount")
          )
        .def("VDirectionCount",
             (Standard_Integer (StepVisual_DirectionCountSelect::*)() const) static_cast<Standard_Integer (StepVisual_DirectionCountSelect::*)() const>(&StepVisual_DirectionCountSelect::VDirectionCount),
             R"#()#" 
          )
        .def("SetVDirectionCount",
             (void (StepVisual_DirectionCountSelect::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_DirectionCountSelect::*)(  const Standard_Integer  ) >(&StepVisual_DirectionCountSelect::SetVDirectionCount),
             R"#()#"  , py::arg("aUDirectionCount")
          )
    // 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 StepVisual_DraughtingCallout from ./opencascade/StepVisual_DraughtingCallout.hxx
    klass = m.attr("StepVisual_DraughtingCallout");


    // nested enums

    static_cast<py::class_<StepVisual_DraughtingCallout ,opencascade::handle<StepVisual_DraughtingCallout>  , StepGeom_GeometricRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_DraughtingCallout::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfDraughtingCalloutElement> &  ) ) static_cast<void (StepVisual_DraughtingCallout::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfDraughtingCalloutElement> &  ) >(&StepVisual_DraughtingCallout::Init),
             R"#(Init)#"  , py::arg("theName"),  py::arg("theContents")
          )
        .def("Contents",
             (handle<StepVisual_HArray1OfDraughtingCalloutElement> (StepVisual_DraughtingCallout::*)() const) static_cast<handle<StepVisual_HArray1OfDraughtingCalloutElement> (StepVisual_DraughtingCallout::*)() const>(&StepVisual_DraughtingCallout::Contents),
             R"#(Returns field Contents)#" 
          )
        .def("SetContents",
             (void (StepVisual_DraughtingCallout::*)(  const handle<StepVisual_HArray1OfDraughtingCalloutElement> &  ) ) static_cast<void (StepVisual_DraughtingCallout::*)(  const handle<StepVisual_HArray1OfDraughtingCalloutElement> &  ) >(&StepVisual_DraughtingCallout::SetContents),
             R"#(Set field Contents)#"  , py::arg("theContents")
          )
        .def("NbContents",
             (Standard_Integer (StepVisual_DraughtingCallout::*)() const) static_cast<Standard_Integer (StepVisual_DraughtingCallout::*)() const>(&StepVisual_DraughtingCallout::NbContents),
             R"#(Returns number of Contents)#" 
          )
        .def("ContentsValue",
             (StepVisual_DraughtingCalloutElement (StepVisual_DraughtingCallout::*)(  const Standard_Integer  ) const) static_cast<StepVisual_DraughtingCalloutElement (StepVisual_DraughtingCallout::*)(  const Standard_Integer  ) const>(&StepVisual_DraughtingCallout::ContentsValue),
             R"#(Returns Contents with the given number)#"  , py::arg("theNum")
          )
        .def("SetContentsValue",
             (void (StepVisual_DraughtingCallout::*)(  const Standard_Integer ,   const StepVisual_DraughtingCalloutElement &  ) ) static_cast<void (StepVisual_DraughtingCallout::*)(  const Standard_Integer ,   const StepVisual_DraughtingCalloutElement &  ) >(&StepVisual_DraughtingCallout::SetContentsValue),
             R"#(Sets Contents with given number)#"  , py::arg("theNum"),  py::arg("theItem")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_DraughtingCallout::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_DraughtingCallout::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> & (StepVisual_DraughtingCallout::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_DraughtingCallout::*)() const>(&StepVisual_DraughtingCallout::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_DraughtingCalloutElement , shared_ptr<StepVisual_DraughtingCalloutElement>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_DraughtingCalloutElement::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_DraughtingCalloutElement::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_DraughtingCalloutElement::CaseNum),
             R"#(Recognizes a IdAttributeSelect Kind Entity that is : 1 -> AnnotationCurveOccurrence 2 -> AnnotationTextOccurrence 3 -> TessellatedAnnotationOccurrence 4 -> AnnotationFillAreaOccurrence 0 else)#"  , py::arg("ent")
          )
        .def("AnnotationCurveOccurrence",
             (handle<StepVisual_AnnotationCurveOccurrence> (StepVisual_DraughtingCalloutElement::*)() const) static_cast<handle<StepVisual_AnnotationCurveOccurrence> (StepVisual_DraughtingCalloutElement::*)() const>(&StepVisual_DraughtingCalloutElement::AnnotationCurveOccurrence),
             R"#(returns Value as a AnnotationCurveOccurrence (Null if another type))#" 
          )
        .def("AnnotationTextOccurrence",
             (handle<StepVisual_AnnotationTextOccurrence> (StepVisual_DraughtingCalloutElement::*)() const) static_cast<handle<StepVisual_AnnotationTextOccurrence> (StepVisual_DraughtingCalloutElement::*)() const>(&StepVisual_DraughtingCalloutElement::AnnotationTextOccurrence),
             R"#(returns Value as a AnnotationTextOccurrence)#" 
          )
        .def("TessellatedAnnotationOccurrence",
             (handle<StepVisual_TessellatedAnnotationOccurrence> (StepVisual_DraughtingCalloutElement::*)() const) static_cast<handle<StepVisual_TessellatedAnnotationOccurrence> (StepVisual_DraughtingCalloutElement::*)() const>(&StepVisual_DraughtingCalloutElement::TessellatedAnnotationOccurrence),
             R"#(returns Value as a TessellatedAnnotationOccurrence)#" 
          )
        .def("AnnotationFillAreaOccurrence",
             (handle<StepVisual_AnnotationFillAreaOccurrence> (StepVisual_DraughtingCalloutElement::*)() const) static_cast<handle<StepVisual_AnnotationFillAreaOccurrence> (StepVisual_DraughtingCalloutElement::*)() const>(&StepVisual_DraughtingCalloutElement::AnnotationFillAreaOccurrence),
             R"#(returns Value as a AnnotationFillAreaOccurrence)#" 
          )
    // 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 StepVisual_DraughtingModel from ./opencascade/StepVisual_DraughtingModel.hxx
    klass = m.attr("StepVisual_DraughtingModel");


    // nested enums

    static_cast<py::class_<StepVisual_DraughtingModel ,opencascade::handle<StepVisual_DraughtingModel>  , 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 * (*)() >(&StepVisual_DraughtingModel::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_DraughtingModel::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> & (StepVisual_DraughtingModel::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_DraughtingModel::*)() const>(&StepVisual_DraughtingModel::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_EdgeOrCurve , shared_ptr<StepVisual_EdgeOrCurve>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_EdgeOrCurve::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_EdgeOrCurve::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_EdgeOrCurve::CaseNum),
             R"#(Recognizes a kind of EdgeOrCurve select type -- 1 -> Curve -- 2 -> Edge)#"  , py::arg("ent")
          )
        .def("Curve",
             (handle<StepGeom_Curve> (StepVisual_EdgeOrCurve::*)() const) static_cast<handle<StepGeom_Curve> (StepVisual_EdgeOrCurve::*)() const>(&StepVisual_EdgeOrCurve::Curve),
             R"#(Returns Value as Curve (or Null if another type))#" 
          )
        .def("Edge",
             (handle<StepShape_Edge> (StepVisual_EdgeOrCurve::*)() const) static_cast<handle<StepShape_Edge> (StepVisual_EdgeOrCurve::*)() const>(&StepVisual_EdgeOrCurve::Edge),
             R"#(Returns Value as Edge (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 StepVisual_ExternallyDefinedCurveFont from ./opencascade/StepVisual_ExternallyDefinedCurveFont.hxx
    klass = m.attr("StepVisual_ExternallyDefinedCurveFont");


    // nested enums

    static_cast<py::class_<StepVisual_ExternallyDefinedCurveFont ,opencascade::handle<StepVisual_ExternallyDefinedCurveFont>  , StepBasic_ExternallyDefinedItem >>(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 * (*)() >(&StepVisual_ExternallyDefinedCurveFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ExternallyDefinedCurveFont::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> & (StepVisual_ExternallyDefinedCurveFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ExternallyDefinedCurveFont::*)() const>(&StepVisual_ExternallyDefinedCurveFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ExternallyDefinedTextFont ,opencascade::handle<StepVisual_ExternallyDefinedTextFont>  , StepBasic_ExternallyDefinedItem >>(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 * (*)() >(&StepVisual_ExternallyDefinedTextFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ExternallyDefinedTextFont::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> & (StepVisual_ExternallyDefinedTextFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ExternallyDefinedTextFont::*)() const>(&StepVisual_ExternallyDefinedTextFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_FaceOrSurface , shared_ptr<StepVisual_FaceOrSurface>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_FaceOrSurface::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_FaceOrSurface::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_FaceOrSurface::CaseNum),
             R"#(Recognizes a kind of FaceOrSurface select type -- 1 -> Face -- 2 -> Surface)#"  , py::arg("ent")
          )
        .def("Face",
             (handle<StepShape_Face> (StepVisual_FaceOrSurface::*)() const) static_cast<handle<StepShape_Face> (StepVisual_FaceOrSurface::*)() const>(&StepVisual_FaceOrSurface::Face),
             R"#(Returns Value as Face (or Null if another type))#" 
          )
        .def("Surface",
             (handle<StepGeom_Surface> (StepVisual_FaceOrSurface::*)() const) static_cast<handle<StepGeom_Surface> (StepVisual_FaceOrSurface::*)() const>(&StepVisual_FaceOrSurface::Surface),
             R"#(Returns Value as Surface (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 StepVisual_FillAreaStyle from ./opencascade/StepVisual_FillAreaStyle.hxx
    klass = m.attr("StepVisual_FillAreaStyle");


    // nested enums

    static_cast<py::class_<StepVisual_FillAreaStyle ,opencascade::handle<StepVisual_FillAreaStyle>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_FillAreaStyle::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfFillStyleSelect> &  ) ) static_cast<void (StepVisual_FillAreaStyle::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfFillStyleSelect> &  ) >(&StepVisual_FillAreaStyle::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aFillStyles")
          )
        .def("SetName",
             (void (StepVisual_FillAreaStyle::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_FillAreaStyle::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_FillAreaStyle::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_FillAreaStyle::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_FillAreaStyle::*)() const>(&StepVisual_FillAreaStyle::Name),
             R"#()#" 
          )
        .def("SetFillStyles",
             (void (StepVisual_FillAreaStyle::*)(  const handle<StepVisual_HArray1OfFillStyleSelect> &  ) ) static_cast<void (StepVisual_FillAreaStyle::*)(  const handle<StepVisual_HArray1OfFillStyleSelect> &  ) >(&StepVisual_FillAreaStyle::SetFillStyles),
             R"#()#"  , py::arg("aFillStyles")
          )
        .def("FillStyles",
             (handle<StepVisual_HArray1OfFillStyleSelect> (StepVisual_FillAreaStyle::*)() const) static_cast<handle<StepVisual_HArray1OfFillStyleSelect> (StepVisual_FillAreaStyle::*)() const>(&StepVisual_FillAreaStyle::FillStyles),
             R"#()#" 
          )
        .def("FillStylesValue",
             (StepVisual_FillStyleSelect (StepVisual_FillAreaStyle::*)(  const Standard_Integer  ) const) static_cast<StepVisual_FillStyleSelect (StepVisual_FillAreaStyle::*)(  const Standard_Integer  ) const>(&StepVisual_FillAreaStyle::FillStylesValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbFillStyles",
             (Standard_Integer (StepVisual_FillAreaStyle::*)() const) static_cast<Standard_Integer (StepVisual_FillAreaStyle::*)() const>(&StepVisual_FillAreaStyle::NbFillStyles),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_FillAreaStyle::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_FillAreaStyle::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> & (StepVisual_FillAreaStyle::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_FillAreaStyle::*)() const>(&StepVisual_FillAreaStyle::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_FillAreaStyleColour ,opencascade::handle<StepVisual_FillAreaStyleColour>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_FillAreaStyleColour::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_FillAreaStyleColour::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_Colour> &  ) >(&StepVisual_FillAreaStyleColour::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aFillColour")
          )
        .def("SetName",
             (void (StepVisual_FillAreaStyleColour::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_FillAreaStyleColour::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_FillAreaStyleColour::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_FillAreaStyleColour::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_FillAreaStyleColour::*)() const>(&StepVisual_FillAreaStyleColour::Name),
             R"#()#" 
          )
        .def("SetFillColour",
             (void (StepVisual_FillAreaStyleColour::*)(  const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_FillAreaStyleColour::*)(  const handle<StepVisual_Colour> &  ) >(&StepVisual_FillAreaStyleColour::SetFillColour),
             R"#()#"  , py::arg("aFillColour")
          )
        .def("FillColour",
             (handle<StepVisual_Colour> (StepVisual_FillAreaStyleColour::*)() const) static_cast<handle<StepVisual_Colour> (StepVisual_FillAreaStyleColour::*)() const>(&StepVisual_FillAreaStyleColour::FillColour),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_FillAreaStyleColour::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_FillAreaStyleColour::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> & (StepVisual_FillAreaStyleColour::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_FillAreaStyleColour::*)() const>(&StepVisual_FillAreaStyleColour::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_FillStyleSelect , shared_ptr<StepVisual_FillStyleSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_FillStyleSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_FillStyleSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_FillStyleSelect::CaseNum),
             R"#(Recognizes a FillStyleSelect Kind Entity that is : 1 -> FillAreaStyleColour 2 -> ExternallyDefinedTileStyle 3 -> FillAreaStyleTiles 4 -> ExternallyDefinedHatchStyle 5 -> FillAreaStyleHatching 0 else)#"  , py::arg("ent")
          )
        .def("FillAreaStyleColour",
             (handle<StepVisual_FillAreaStyleColour> (StepVisual_FillStyleSelect::*)() const) static_cast<handle<StepVisual_FillAreaStyleColour> (StepVisual_FillStyleSelect::*)() const>(&StepVisual_FillStyleSelect::FillAreaStyleColour),
             R"#(returns Value as a FillAreaStyleColour (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 StepVisual_FontSelect from ./opencascade/StepVisual_FontSelect.hxx
    klass = m.attr("StepVisual_FontSelect");


    // nested enums

    static_cast<py::class_<StepVisual_FontSelect , shared_ptr<StepVisual_FontSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_FontSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_FontSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_FontSelect::CaseNum),
             R"#(Recognizes a FontSelect Kind Entity that is : 1 -> PreDefinedTextFont 2 -> ExternallyDefinedTextFont 0 else)#"  , py::arg("ent")
          )
        .def("PreDefinedTextFont",
             (handle<StepVisual_PreDefinedTextFont> (StepVisual_FontSelect::*)() const) static_cast<handle<StepVisual_PreDefinedTextFont> (StepVisual_FontSelect::*)() const>(&StepVisual_FontSelect::PreDefinedTextFont),
             R"#(returns Value as a PreDefinedTextFont (Null if another type))#" 
          )
        .def("ExternallyDefinedTextFont",
             (handle<StepVisual_ExternallyDefinedTextFont> (StepVisual_FontSelect::*)() const) static_cast<handle<StepVisual_ExternallyDefinedTextFont> (StepVisual_FontSelect::*)() const>(&StepVisual_FontSelect::ExternallyDefinedTextFont),
             R"#(returns Value as a ExternallyDefinedTextFont (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 StepVisual_HArray1OfAnnotationPlaneElement from ./opencascade/StepVisual_HArray1OfAnnotationPlaneElement.hxx
    klass = m.attr("StepVisual_HArray1OfAnnotationPlaneElement");


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfAnnotationPlaneElement ,opencascade::handle<StepVisual_HArray1OfAnnotationPlaneElement>  , StepVisual_Array1OfAnnotationPlaneElement , 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<StepVisual_AnnotationPlaneElement>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_AnnotationPlaneElement>::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 StepVisual_Array1OfAnnotationPlaneElement & >()  , 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 * (*)() >(&StepVisual_HArray1OfAnnotationPlaneElement::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfAnnotationPlaneElement::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 StepVisual_Array1OfAnnotationPlaneElement & (StepVisual_HArray1OfAnnotationPlaneElement::*)() const) static_cast< const StepVisual_Array1OfAnnotationPlaneElement & (StepVisual_HArray1OfAnnotationPlaneElement::*)() const>(&StepVisual_HArray1OfAnnotationPlaneElement::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfAnnotationPlaneElement & (StepVisual_HArray1OfAnnotationPlaneElement::*)() ) static_cast<StepVisual_Array1OfAnnotationPlaneElement & (StepVisual_HArray1OfAnnotationPlaneElement::*)() >(&StepVisual_HArray1OfAnnotationPlaneElement::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfAnnotationPlaneElement::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfAnnotationPlaneElement::*)() const>(&StepVisual_HArray1OfAnnotationPlaneElement::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfBoxCharacteristicSelect ,opencascade::handle<StepVisual_HArray1OfBoxCharacteristicSelect>  , StepVisual_Array1OfBoxCharacteristicSelect , 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<StepVisual_BoxCharacteristicSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_BoxCharacteristicSelect>::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 StepVisual_Array1OfBoxCharacteristicSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfBoxCharacteristicSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfBoxCharacteristicSelect::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 StepVisual_Array1OfBoxCharacteristicSelect & (StepVisual_HArray1OfBoxCharacteristicSelect::*)() const) static_cast< const StepVisual_Array1OfBoxCharacteristicSelect & (StepVisual_HArray1OfBoxCharacteristicSelect::*)() const>(&StepVisual_HArray1OfBoxCharacteristicSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfBoxCharacteristicSelect & (StepVisual_HArray1OfBoxCharacteristicSelect::*)() ) static_cast<StepVisual_Array1OfBoxCharacteristicSelect & (StepVisual_HArray1OfBoxCharacteristicSelect::*)() >(&StepVisual_HArray1OfBoxCharacteristicSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfBoxCharacteristicSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfBoxCharacteristicSelect::*)() const>(&StepVisual_HArray1OfBoxCharacteristicSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect ,opencascade::handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect>  , StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect , 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<StepVisual_CameraModelD3MultiClippingInterectionSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_CameraModelD3MultiClippingInterectionSelect>::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 StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::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 StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::*)() const) static_cast< const StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::*)() const>(&StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::*)() ) static_cast<StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::*)() >(&StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::*)() const>(&StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect ,opencascade::handle<StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect>  , StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect , 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<StepVisual_CameraModelD3MultiClippingUnionSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_CameraModelD3MultiClippingUnionSelect>::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 StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::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 StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::*)() const) static_cast< const StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::*)() const>(&StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::*)() ) static_cast<StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect & (StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::*)() >(&StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::*)() const>(&StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfCurveStyleFontPattern ,opencascade::handle<StepVisual_HArray1OfCurveStyleFontPattern>  , StepVisual_Array1OfCurveStyleFontPattern , 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<StepVisual_CurveStyleFontPattern>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepVisual_CurveStyleFontPattern>>::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 StepVisual_Array1OfCurveStyleFontPattern & >()  , 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 * (*)() >(&StepVisual_HArray1OfCurveStyleFontPattern::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfCurveStyleFontPattern::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 StepVisual_Array1OfCurveStyleFontPattern & (StepVisual_HArray1OfCurveStyleFontPattern::*)() const) static_cast< const StepVisual_Array1OfCurveStyleFontPattern & (StepVisual_HArray1OfCurveStyleFontPattern::*)() const>(&StepVisual_HArray1OfCurveStyleFontPattern::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfCurveStyleFontPattern & (StepVisual_HArray1OfCurveStyleFontPattern::*)() ) static_cast<StepVisual_Array1OfCurveStyleFontPattern & (StepVisual_HArray1OfCurveStyleFontPattern::*)() >(&StepVisual_HArray1OfCurveStyleFontPattern::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfCurveStyleFontPattern::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfCurveStyleFontPattern::*)() const>(&StepVisual_HArray1OfCurveStyleFontPattern::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfDirectionCountSelect ,opencascade::handle<StepVisual_HArray1OfDirectionCountSelect>  , StepVisual_Array1OfDirectionCountSelect , 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<StepVisual_DirectionCountSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_DirectionCountSelect>::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 StepVisual_Array1OfDirectionCountSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfDirectionCountSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfDirectionCountSelect::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 StepVisual_Array1OfDirectionCountSelect & (StepVisual_HArray1OfDirectionCountSelect::*)() const) static_cast< const StepVisual_Array1OfDirectionCountSelect & (StepVisual_HArray1OfDirectionCountSelect::*)() const>(&StepVisual_HArray1OfDirectionCountSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfDirectionCountSelect & (StepVisual_HArray1OfDirectionCountSelect::*)() ) static_cast<StepVisual_Array1OfDirectionCountSelect & (StepVisual_HArray1OfDirectionCountSelect::*)() >(&StepVisual_HArray1OfDirectionCountSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfDirectionCountSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfDirectionCountSelect::*)() const>(&StepVisual_HArray1OfDirectionCountSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfDraughtingCalloutElement ,opencascade::handle<StepVisual_HArray1OfDraughtingCalloutElement>  , StepVisual_Array1OfDraughtingCalloutElement , 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<StepVisual_DraughtingCalloutElement>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_DraughtingCalloutElement>::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 StepVisual_Array1OfDraughtingCalloutElement & >()  , 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 * (*)() >(&StepVisual_HArray1OfDraughtingCalloutElement::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfDraughtingCalloutElement::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 StepVisual_Array1OfDraughtingCalloutElement & (StepVisual_HArray1OfDraughtingCalloutElement::*)() const) static_cast< const StepVisual_Array1OfDraughtingCalloutElement & (StepVisual_HArray1OfDraughtingCalloutElement::*)() const>(&StepVisual_HArray1OfDraughtingCalloutElement::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfDraughtingCalloutElement & (StepVisual_HArray1OfDraughtingCalloutElement::*)() ) static_cast<StepVisual_Array1OfDraughtingCalloutElement & (StepVisual_HArray1OfDraughtingCalloutElement::*)() >(&StepVisual_HArray1OfDraughtingCalloutElement::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfDraughtingCalloutElement::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfDraughtingCalloutElement::*)() const>(&StepVisual_HArray1OfDraughtingCalloutElement::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfFillStyleSelect ,opencascade::handle<StepVisual_HArray1OfFillStyleSelect>  , StepVisual_Array1OfFillStyleSelect , 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<StepVisual_FillStyleSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_FillStyleSelect>::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 StepVisual_Array1OfFillStyleSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfFillStyleSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfFillStyleSelect::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 StepVisual_Array1OfFillStyleSelect & (StepVisual_HArray1OfFillStyleSelect::*)() const) static_cast< const StepVisual_Array1OfFillStyleSelect & (StepVisual_HArray1OfFillStyleSelect::*)() const>(&StepVisual_HArray1OfFillStyleSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfFillStyleSelect & (StepVisual_HArray1OfFillStyleSelect::*)() ) static_cast<StepVisual_Array1OfFillStyleSelect & (StepVisual_HArray1OfFillStyleSelect::*)() >(&StepVisual_HArray1OfFillStyleSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfFillStyleSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfFillStyleSelect::*)() const>(&StepVisual_HArray1OfFillStyleSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfInvisibleItem ,opencascade::handle<StepVisual_HArray1OfInvisibleItem>  , StepVisual_Array1OfInvisibleItem , 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<StepVisual_InvisibleItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_InvisibleItem>::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 StepVisual_Array1OfInvisibleItem & >()  , 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 * (*)() >(&StepVisual_HArray1OfInvisibleItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfInvisibleItem::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 StepVisual_Array1OfInvisibleItem & (StepVisual_HArray1OfInvisibleItem::*)() const) static_cast< const StepVisual_Array1OfInvisibleItem & (StepVisual_HArray1OfInvisibleItem::*)() const>(&StepVisual_HArray1OfInvisibleItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfInvisibleItem & (StepVisual_HArray1OfInvisibleItem::*)() ) static_cast<StepVisual_Array1OfInvisibleItem & (StepVisual_HArray1OfInvisibleItem::*)() >(&StepVisual_HArray1OfInvisibleItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfInvisibleItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfInvisibleItem::*)() const>(&StepVisual_HArray1OfInvisibleItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfLayeredItem ,opencascade::handle<StepVisual_HArray1OfLayeredItem>  , StepVisual_Array1OfLayeredItem , 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<StepVisual_LayeredItem>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_LayeredItem>::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 StepVisual_Array1OfLayeredItem & >()  , 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 * (*)() >(&StepVisual_HArray1OfLayeredItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfLayeredItem::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 StepVisual_Array1OfLayeredItem & (StepVisual_HArray1OfLayeredItem::*)() const) static_cast< const StepVisual_Array1OfLayeredItem & (StepVisual_HArray1OfLayeredItem::*)() const>(&StepVisual_HArray1OfLayeredItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfLayeredItem & (StepVisual_HArray1OfLayeredItem::*)() ) static_cast<StepVisual_Array1OfLayeredItem & (StepVisual_HArray1OfLayeredItem::*)() >(&StepVisual_HArray1OfLayeredItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfLayeredItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfLayeredItem::*)() const>(&StepVisual_HArray1OfLayeredItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfPresentationStyleAssignment ,opencascade::handle<StepVisual_HArray1OfPresentationStyleAssignment>  , StepVisual_Array1OfPresentationStyleAssignment , 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<StepVisual_PresentationStyleAssignment>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepVisual_PresentationStyleAssignment>>::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 StepVisual_Array1OfPresentationStyleAssignment & >()  , 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 * (*)() >(&StepVisual_HArray1OfPresentationStyleAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfPresentationStyleAssignment::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 StepVisual_Array1OfPresentationStyleAssignment & (StepVisual_HArray1OfPresentationStyleAssignment::*)() const) static_cast< const StepVisual_Array1OfPresentationStyleAssignment & (StepVisual_HArray1OfPresentationStyleAssignment::*)() const>(&StepVisual_HArray1OfPresentationStyleAssignment::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfPresentationStyleAssignment & (StepVisual_HArray1OfPresentationStyleAssignment::*)() ) static_cast<StepVisual_Array1OfPresentationStyleAssignment & (StepVisual_HArray1OfPresentationStyleAssignment::*)() >(&StepVisual_HArray1OfPresentationStyleAssignment::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfPresentationStyleAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfPresentationStyleAssignment::*)() const>(&StepVisual_HArray1OfPresentationStyleAssignment::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfPresentationStyleSelect ,opencascade::handle<StepVisual_HArray1OfPresentationStyleSelect>  , StepVisual_Array1OfPresentationStyleSelect , 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<StepVisual_PresentationStyleSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_PresentationStyleSelect>::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 StepVisual_Array1OfPresentationStyleSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfPresentationStyleSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfPresentationStyleSelect::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 StepVisual_Array1OfPresentationStyleSelect & (StepVisual_HArray1OfPresentationStyleSelect::*)() const) static_cast< const StepVisual_Array1OfPresentationStyleSelect & (StepVisual_HArray1OfPresentationStyleSelect::*)() const>(&StepVisual_HArray1OfPresentationStyleSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfPresentationStyleSelect & (StepVisual_HArray1OfPresentationStyleSelect::*)() ) static_cast<StepVisual_Array1OfPresentationStyleSelect & (StepVisual_HArray1OfPresentationStyleSelect::*)() >(&StepVisual_HArray1OfPresentationStyleSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfPresentationStyleSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfPresentationStyleSelect::*)() const>(&StepVisual_HArray1OfPresentationStyleSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfRenderingPropertiesSelect ,opencascade::handle<StepVisual_HArray1OfRenderingPropertiesSelect>  , StepVisual_Array1OfRenderingPropertiesSelect , 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<StepVisual_RenderingPropertiesSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_RenderingPropertiesSelect>::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 StepVisual_Array1OfRenderingPropertiesSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfRenderingPropertiesSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfRenderingPropertiesSelect::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 StepVisual_Array1OfRenderingPropertiesSelect & (StepVisual_HArray1OfRenderingPropertiesSelect::*)() const) static_cast< const StepVisual_Array1OfRenderingPropertiesSelect & (StepVisual_HArray1OfRenderingPropertiesSelect::*)() const>(&StepVisual_HArray1OfRenderingPropertiesSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfRenderingPropertiesSelect & (StepVisual_HArray1OfRenderingPropertiesSelect::*)() ) static_cast<StepVisual_Array1OfRenderingPropertiesSelect & (StepVisual_HArray1OfRenderingPropertiesSelect::*)() >(&StepVisual_HArray1OfRenderingPropertiesSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfRenderingPropertiesSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfRenderingPropertiesSelect::*)() const>(&StepVisual_HArray1OfRenderingPropertiesSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfStyleContextSelect ,opencascade::handle<StepVisual_HArray1OfStyleContextSelect>  , StepVisual_Array1OfStyleContextSelect , 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<StepVisual_StyleContextSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_StyleContextSelect>::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 StepVisual_Array1OfStyleContextSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfStyleContextSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfStyleContextSelect::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 StepVisual_Array1OfStyleContextSelect & (StepVisual_HArray1OfStyleContextSelect::*)() const) static_cast< const StepVisual_Array1OfStyleContextSelect & (StepVisual_HArray1OfStyleContextSelect::*)() const>(&StepVisual_HArray1OfStyleContextSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfStyleContextSelect & (StepVisual_HArray1OfStyleContextSelect::*)() ) static_cast<StepVisual_Array1OfStyleContextSelect & (StepVisual_HArray1OfStyleContextSelect::*)() >(&StepVisual_HArray1OfStyleContextSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfStyleContextSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfStyleContextSelect::*)() const>(&StepVisual_HArray1OfStyleContextSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfSurfaceStyleElementSelect ,opencascade::handle<StepVisual_HArray1OfSurfaceStyleElementSelect>  , StepVisual_Array1OfSurfaceStyleElementSelect , 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<StepVisual_SurfaceStyleElementSelect>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_SurfaceStyleElementSelect>::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 StepVisual_Array1OfSurfaceStyleElementSelect & >()  , 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 * (*)() >(&StepVisual_HArray1OfSurfaceStyleElementSelect::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfSurfaceStyleElementSelect::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 StepVisual_Array1OfSurfaceStyleElementSelect & (StepVisual_HArray1OfSurfaceStyleElementSelect::*)() const) static_cast< const StepVisual_Array1OfSurfaceStyleElementSelect & (StepVisual_HArray1OfSurfaceStyleElementSelect::*)() const>(&StepVisual_HArray1OfSurfaceStyleElementSelect::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfSurfaceStyleElementSelect & (StepVisual_HArray1OfSurfaceStyleElementSelect::*)() ) static_cast<StepVisual_Array1OfSurfaceStyleElementSelect & (StepVisual_HArray1OfSurfaceStyleElementSelect::*)() >(&StepVisual_HArray1OfSurfaceStyleElementSelect::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfSurfaceStyleElementSelect::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfSurfaceStyleElementSelect::*)() const>(&StepVisual_HArray1OfSurfaceStyleElementSelect::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfTessellatedEdgeOrVertex ,opencascade::handle<StepVisual_HArray1OfTessellatedEdgeOrVertex>  , StepVisual_Array1OfTessellatedEdgeOrVertex , 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<StepVisual_TessellatedEdgeOrVertex>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_TessellatedEdgeOrVertex>::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 StepVisual_Array1OfTessellatedEdgeOrVertex & >()  , 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 * (*)() >(&StepVisual_HArray1OfTessellatedEdgeOrVertex::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfTessellatedEdgeOrVertex::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 StepVisual_Array1OfTessellatedEdgeOrVertex & (StepVisual_HArray1OfTessellatedEdgeOrVertex::*)() const) static_cast< const StepVisual_Array1OfTessellatedEdgeOrVertex & (StepVisual_HArray1OfTessellatedEdgeOrVertex::*)() const>(&StepVisual_HArray1OfTessellatedEdgeOrVertex::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfTessellatedEdgeOrVertex & (StepVisual_HArray1OfTessellatedEdgeOrVertex::*)() ) static_cast<StepVisual_Array1OfTessellatedEdgeOrVertex & (StepVisual_HArray1OfTessellatedEdgeOrVertex::*)() >(&StepVisual_HArray1OfTessellatedEdgeOrVertex::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfTessellatedEdgeOrVertex::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfTessellatedEdgeOrVertex::*)() const>(&StepVisual_HArray1OfTessellatedEdgeOrVertex::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfTessellatedStructuredItem ,opencascade::handle<StepVisual_HArray1OfTessellatedStructuredItem>  , StepVisual_Array1OfTessellatedStructuredItem , 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<StepVisual_TessellatedStructuredItem>>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<opencascade::handle<StepVisual_TessellatedStructuredItem>>::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 StepVisual_Array1OfTessellatedStructuredItem & >()  , 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 * (*)() >(&StepVisual_HArray1OfTessellatedStructuredItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfTessellatedStructuredItem::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 StepVisual_Array1OfTessellatedStructuredItem & (StepVisual_HArray1OfTessellatedStructuredItem::*)() const) static_cast< const StepVisual_Array1OfTessellatedStructuredItem & (StepVisual_HArray1OfTessellatedStructuredItem::*)() const>(&StepVisual_HArray1OfTessellatedStructuredItem::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfTessellatedStructuredItem & (StepVisual_HArray1OfTessellatedStructuredItem::*)() ) static_cast<StepVisual_Array1OfTessellatedStructuredItem & (StepVisual_HArray1OfTessellatedStructuredItem::*)() >(&StepVisual_HArray1OfTessellatedStructuredItem::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfTessellatedStructuredItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfTessellatedStructuredItem::*)() const>(&StepVisual_HArray1OfTessellatedStructuredItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_HArray1OfTextOrCharacter ,opencascade::handle<StepVisual_HArray1OfTextOrCharacter>  , StepVisual_Array1OfTextOrCharacter , 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<StepVisual_TextOrCharacter>::value_type & >()  , py::arg("theLower"),  py::arg("theUpper"),  py::arg("theValue") )
        .def(py::init<  const typename NCollection_Array1<StepVisual_TextOrCharacter>::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 StepVisual_Array1OfTextOrCharacter & >()  , 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 * (*)() >(&StepVisual_HArray1OfTextOrCharacter::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_HArray1OfTextOrCharacter::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 StepVisual_Array1OfTextOrCharacter & (StepVisual_HArray1OfTextOrCharacter::*)() const) static_cast< const StepVisual_Array1OfTextOrCharacter & (StepVisual_HArray1OfTextOrCharacter::*)() const>(&StepVisual_HArray1OfTextOrCharacter::Array1),
             R"#()#"
             
         )
       .def("ChangeArray1",
             (StepVisual_Array1OfTextOrCharacter & (StepVisual_HArray1OfTextOrCharacter::*)() ) static_cast<StepVisual_Array1OfTextOrCharacter & (StepVisual_HArray1OfTextOrCharacter::*)() >(&StepVisual_HArray1OfTextOrCharacter::ChangeArray1),
             R"#()#"
             
             , py::return_value_policy::reference_internal
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_HArray1OfTextOrCharacter::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_HArray1OfTextOrCharacter::*)() const>(&StepVisual_HArray1OfTextOrCharacter::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_Invisibility ,opencascade::handle<StepVisual_Invisibility>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_Invisibility::*)(  const handle<StepVisual_HArray1OfInvisibleItem> &  ) ) static_cast<void (StepVisual_Invisibility::*)(  const handle<StepVisual_HArray1OfInvisibleItem> &  ) >(&StepVisual_Invisibility::Init),
             R"#()#"  , py::arg("aInvisibleItems")
          )
        .def("SetInvisibleItems",
             (void (StepVisual_Invisibility::*)(  const handle<StepVisual_HArray1OfInvisibleItem> &  ) ) static_cast<void (StepVisual_Invisibility::*)(  const handle<StepVisual_HArray1OfInvisibleItem> &  ) >(&StepVisual_Invisibility::SetInvisibleItems),
             R"#()#"  , py::arg("aInvisibleItems")
          )
        .def("InvisibleItems",
             (handle<StepVisual_HArray1OfInvisibleItem> (StepVisual_Invisibility::*)() const) static_cast<handle<StepVisual_HArray1OfInvisibleItem> (StepVisual_Invisibility::*)() const>(&StepVisual_Invisibility::InvisibleItems),
             R"#()#" 
          )
        .def("InvisibleItemsValue",
             (StepVisual_InvisibleItem (StepVisual_Invisibility::*)(  const Standard_Integer  ) const) static_cast<StepVisual_InvisibleItem (StepVisual_Invisibility::*)(  const Standard_Integer  ) const>(&StepVisual_Invisibility::InvisibleItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbInvisibleItems",
             (Standard_Integer (StepVisual_Invisibility::*)() const) static_cast<Standard_Integer (StepVisual_Invisibility::*)() const>(&StepVisual_Invisibility::NbInvisibleItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_Invisibility::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_Invisibility::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> & (StepVisual_Invisibility::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_Invisibility::*)() const>(&StepVisual_Invisibility::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_InvisibilityContext , shared_ptr<StepVisual_InvisibilityContext>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_InvisibilityContext::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_InvisibilityContext::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_InvisibilityContext::CaseNum),
             R"#(Recognizes a InvisibilityContext Kind Entity that is : 1 -> PresentationRepresentation 2 -> PresentationSet 2 -> DraughtingModel 0 else)#"  , py::arg("ent")
          )
        .def("PresentationRepresentation",
             (handle<StepVisual_PresentationRepresentation> (StepVisual_InvisibilityContext::*)() const) static_cast<handle<StepVisual_PresentationRepresentation> (StepVisual_InvisibilityContext::*)() const>(&StepVisual_InvisibilityContext::PresentationRepresentation),
             R"#(returns Value as a PresentationRepresentation (Null if another type))#" 
          )
        .def("PresentationSet",
             (handle<StepVisual_PresentationSet> (StepVisual_InvisibilityContext::*)() const) static_cast<handle<StepVisual_PresentationSet> (StepVisual_InvisibilityContext::*)() const>(&StepVisual_InvisibilityContext::PresentationSet),
             R"#(returns Value as a PresentationSet (Null if another type))#" 
          )
        .def("DraughtingModel",
             (handle<StepVisual_DraughtingModel> (StepVisual_InvisibilityContext::*)() const) static_cast<handle<StepVisual_DraughtingModel> (StepVisual_InvisibilityContext::*)() const>(&StepVisual_InvisibilityContext::DraughtingModel),
             R"#(returns Value as a PresentationSet (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 StepVisual_InvisibleItem from ./opencascade/StepVisual_InvisibleItem.hxx
    klass = m.attr("StepVisual_InvisibleItem");


    // nested enums

    static_cast<py::class_<StepVisual_InvisibleItem , shared_ptr<StepVisual_InvisibleItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_InvisibleItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_InvisibleItem::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_InvisibleItem::CaseNum),
             R"#(Recognizes a InvisibleItem Kind Entity that is : 1 -> StyledItem 2 -> PresentationLayerAssignment 3 -> PresentationRepresentation 0 else)#"  , py::arg("ent")
          )
        .def("StyledItem",
             (handle<StepVisual_StyledItem> (StepVisual_InvisibleItem::*)() const) static_cast<handle<StepVisual_StyledItem> (StepVisual_InvisibleItem::*)() const>(&StepVisual_InvisibleItem::StyledItem),
             R"#(returns Value as a StyledItem (Null if another type))#" 
          )
        .def("PresentationLayerAssignment",
             (handle<StepVisual_PresentationLayerAssignment> (StepVisual_InvisibleItem::*)() const) static_cast<handle<StepVisual_PresentationLayerAssignment> (StepVisual_InvisibleItem::*)() const>(&StepVisual_InvisibleItem::PresentationLayerAssignment),
             R"#(returns Value as a PresentationLayerAssignment (Null if another type))#" 
          )
        .def("PresentationRepresentation",
             (handle<StepVisual_PresentationRepresentation> (StepVisual_InvisibleItem::*)() const) static_cast<handle<StepVisual_PresentationRepresentation> (StepVisual_InvisibleItem::*)() const>(&StepVisual_InvisibleItem::PresentationRepresentation),
             R"#(returns Value as a PresentationRepresentation (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 StepVisual_LayeredItem from ./opencascade/StepVisual_LayeredItem.hxx
    klass = m.attr("StepVisual_LayeredItem");


    // nested enums

    static_cast<py::class_<StepVisual_LayeredItem , shared_ptr<StepVisual_LayeredItem>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_LayeredItem::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_LayeredItem::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_LayeredItem::CaseNum),
             R"#(Recognizes a LayeredItem Kind Entity that is : 1 -> PresentationRepresentation 2 -> RepresentationItem 0 else)#"  , py::arg("ent")
          )
        .def("PresentationRepresentation",
             (handle<StepVisual_PresentationRepresentation> (StepVisual_LayeredItem::*)() const) static_cast<handle<StepVisual_PresentationRepresentation> (StepVisual_LayeredItem::*)() const>(&StepVisual_LayeredItem::PresentationRepresentation),
             R"#(returns Value as a PresentationRepresentation (Null if another type))#" 
          )
        .def("RepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepVisual_LayeredItem::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepVisual_LayeredItem::*)() const>(&StepVisual_LayeredItem::RepresentationItem),
             R"#(returns Value as a RepresentationItem (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 StepVisual_MarkerMember from ./opencascade/StepVisual_MarkerMember.hxx
    klass = m.attr("StepVisual_MarkerMember");


    // nested enums

    static_cast<py::class_<StepVisual_MarkerMember ,opencascade::handle<StepVisual_MarkerMember>  , StepData_SelectInt >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("HasName",
             (Standard_Boolean (StepVisual_MarkerMember::*)() const) static_cast<Standard_Boolean (StepVisual_MarkerMember::*)() const>(&StepVisual_MarkerMember::HasName),
             R"#()#" 
          )
        .def("Name",
             (Standard_CString (StepVisual_MarkerMember::*)() const) static_cast<Standard_CString (StepVisual_MarkerMember::*)() const>(&StepVisual_MarkerMember::Name),
             R"#()#" 
          )
        .def("SetName",
             (Standard_Boolean (StepVisual_MarkerMember::*)(  const Standard_CString  ) ) static_cast<Standard_Boolean (StepVisual_MarkerMember::*)(  const Standard_CString  ) >(&StepVisual_MarkerMember::SetName),
             R"#()#"  , py::arg("name")
          )
        .def("EnumText",
             (Standard_CString (StepVisual_MarkerMember::*)() const) static_cast<Standard_CString (StepVisual_MarkerMember::*)() const>(&StepVisual_MarkerMember::EnumText),
             R"#()#" 
          )
        .def("SetEnumText",
             (void (StepVisual_MarkerMember::*)(  const Standard_Integer ,   const Standard_CString  ) ) static_cast<void (StepVisual_MarkerMember::*)(  const Standard_Integer ,   const Standard_CString  ) >(&StepVisual_MarkerMember::SetEnumText),
             R"#()#"  , py::arg("val"),  py::arg("text")
          )
        .def("SetValue",
             (void (StepVisual_MarkerMember::*)(  const StepVisual_MarkerType  ) ) static_cast<void (StepVisual_MarkerMember::*)(  const StepVisual_MarkerType  ) >(&StepVisual_MarkerMember::SetValue),
             R"#()#"  , py::arg("val")
          )
        .def("Value",
             (StepVisual_MarkerType (StepVisual_MarkerMember::*)() const) static_cast<StepVisual_MarkerType (StepVisual_MarkerMember::*)() const>(&StepVisual_MarkerMember::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 * (*)() >(&StepVisual_MarkerMember::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_MarkerMember::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> & (StepVisual_MarkerMember::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_MarkerMember::*)() const>(&StepVisual_MarkerMember::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_MarkerSelect , shared_ptr<StepVisual_MarkerSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_MarkerSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_MarkerSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_MarkerSelect::CaseNum),
             R"#(Recognizes a MarkerSelect Kind Entity that is : 0 else)#"  , py::arg("ent")
          )
        .def("NewMember",
             (handle<StepData_SelectMember> (StepVisual_MarkerSelect::*)() const) static_cast<handle<StepData_SelectMember> (StepVisual_MarkerSelect::*)() const>(&StepVisual_MarkerSelect::NewMember),
             R"#(Returns a new MarkerMember)#" 
          )
        .def("CaseMem",
             (Standard_Integer (StepVisual_MarkerSelect::*)(  const handle<StepData_SelectMember> &  ) const) static_cast<Standard_Integer (StepVisual_MarkerSelect::*)(  const handle<StepData_SelectMember> &  ) const>(&StepVisual_MarkerSelect::CaseMem),
             R"#(Returns 1 for a SelectMember enum, named MARKER_TYPE)#"  , py::arg("sm")
          )
        .def("MarkerMember",
             (handle<StepVisual_MarkerMember> (StepVisual_MarkerSelect::*)() const) static_cast<handle<StepVisual_MarkerMember> (StepVisual_MarkerSelect::*)() const>(&StepVisual_MarkerSelect::MarkerMember),
             R"#(Gives access to the MarkerMember in order to get/set its value)#" 
          )
    // 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 StepVisual_NullStyleMember from ./opencascade/StepVisual_NullStyleMember.hxx
    klass = m.attr("StepVisual_NullStyleMember");


    // nested enums

    static_cast<py::class_<StepVisual_NullStyleMember ,opencascade::handle<StepVisual_NullStyleMember>  , StepData_SelectInt >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("HasName",
             (Standard_Boolean (StepVisual_NullStyleMember::*)() const) static_cast<Standard_Boolean (StepVisual_NullStyleMember::*)() const>(&StepVisual_NullStyleMember::HasName),
             R"#()#" 
          )
        .def("Name",
             (Standard_CString (StepVisual_NullStyleMember::*)() const) static_cast<Standard_CString (StepVisual_NullStyleMember::*)() const>(&StepVisual_NullStyleMember::Name),
             R"#()#" 
          )
        .def("SetName",
             (Standard_Boolean (StepVisual_NullStyleMember::*)(  const Standard_CString  ) ) static_cast<Standard_Boolean (StepVisual_NullStyleMember::*)(  const Standard_CString  ) >(&StepVisual_NullStyleMember::SetName),
             R"#()#"  , py::arg("arg0")
          )
        .def("Kind",
             (Standard_Integer (StepVisual_NullStyleMember::*)() const) static_cast<Standard_Integer (StepVisual_NullStyleMember::*)() const>(&StepVisual_NullStyleMember::Kind),
             R"#()#" 
          )
        .def("EnumText",
             (Standard_CString (StepVisual_NullStyleMember::*)() const) static_cast<Standard_CString (StepVisual_NullStyleMember::*)() const>(&StepVisual_NullStyleMember::EnumText),
             R"#()#" 
          )
        .def("SetEnumText",
             (void (StepVisual_NullStyleMember::*)(  const Standard_Integer ,   const Standard_CString  ) ) static_cast<void (StepVisual_NullStyleMember::*)(  const Standard_Integer ,   const Standard_CString  ) >(&StepVisual_NullStyleMember::SetEnumText),
             R"#()#"  , py::arg("theValue"),  py::arg("theText")
          )
        .def("SetValue",
             (void (StepVisual_NullStyleMember::*)(  const StepVisual_NullStyle  ) ) static_cast<void (StepVisual_NullStyleMember::*)(  const StepVisual_NullStyle  ) >(&StepVisual_NullStyleMember::SetValue),
             R"#()#"  , py::arg("theValue")
          )
        .def("Value",
             (StepVisual_NullStyle (StepVisual_NullStyleMember::*)() const) static_cast<StepVisual_NullStyle (StepVisual_NullStyleMember::*)() const>(&StepVisual_NullStyleMember::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 * (*)() >(&StepVisual_NullStyleMember::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_NullStyleMember::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> & (StepVisual_NullStyleMember::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_NullStyleMember::*)() const>(&StepVisual_NullStyleMember::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PathOrCompositeCurve , shared_ptr<StepVisual_PathOrCompositeCurve>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_PathOrCompositeCurve::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_PathOrCompositeCurve::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_PathOrCompositeCurve::CaseNum),
             R"#(Recognizes a kind of PathOrCompositeCurve select type -- 1 -> CompositeCurve -- 2 -> Path)#"  , py::arg("ent")
          )
        .def("CompositeCurve",
             (handle<StepGeom_CompositeCurve> (StepVisual_PathOrCompositeCurve::*)() const) static_cast<handle<StepGeom_CompositeCurve> (StepVisual_PathOrCompositeCurve::*)() const>(&StepVisual_PathOrCompositeCurve::CompositeCurve),
             R"#(Returns Value as CompositeCurve (or Null if another type))#" 
          )
        .def("Path",
             (handle<StepShape_Path> (StepVisual_PathOrCompositeCurve::*)() const) static_cast<handle<StepShape_Path> (StepVisual_PathOrCompositeCurve::*)() const>(&StepVisual_PathOrCompositeCurve::Path),
             R"#(Returns Value as Path (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 StepVisual_PlanarExtent from ./opencascade/StepVisual_PlanarExtent.hxx
    klass = m.attr("StepVisual_PlanarExtent");


    // nested enums

    static_cast<py::class_<StepVisual_PlanarExtent ,opencascade::handle<StepVisual_PlanarExtent>  , StepGeom_GeometricRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PlanarExtent::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real ,   const Standard_Real  ) ) static_cast<void (StepVisual_PlanarExtent::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real ,   const Standard_Real  ) >(&StepVisual_PlanarExtent::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aSizeInX"),  py::arg("aSizeInY")
          )
        .def("SetSizeInX",
             (void (StepVisual_PlanarExtent::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_PlanarExtent::*)(  const Standard_Real  ) >(&StepVisual_PlanarExtent::SetSizeInX),
             R"#()#"  , py::arg("aSizeInX")
          )
        .def("SizeInX",
             (Standard_Real (StepVisual_PlanarExtent::*)() const) static_cast<Standard_Real (StepVisual_PlanarExtent::*)() const>(&StepVisual_PlanarExtent::SizeInX),
             R"#()#" 
          )
        .def("SetSizeInY",
             (void (StepVisual_PlanarExtent::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_PlanarExtent::*)(  const Standard_Real  ) >(&StepVisual_PlanarExtent::SetSizeInY),
             R"#()#"  , py::arg("aSizeInY")
          )
        .def("SizeInY",
             (Standard_Real (StepVisual_PlanarExtent::*)() const) static_cast<Standard_Real (StepVisual_PlanarExtent::*)() const>(&StepVisual_PlanarExtent::SizeInY),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PlanarExtent::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PlanarExtent::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> & (StepVisual_PlanarExtent::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PlanarExtent::*)() const>(&StepVisual_PlanarExtent::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PointStyle ,opencascade::handle<StepVisual_PointStyle>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PointStyle::*)(  const handle<TCollection_HAsciiString> & ,   const StepVisual_MarkerSelect & ,   const StepBasic_SizeSelect & ,   const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_PointStyle::*)(  const handle<TCollection_HAsciiString> & ,   const StepVisual_MarkerSelect & ,   const StepBasic_SizeSelect & ,   const handle<StepVisual_Colour> &  ) >(&StepVisual_PointStyle::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aMarker"),  py::arg("aMarkerSize"),  py::arg("aMarkerColour")
          )
        .def("SetName",
             (void (StepVisual_PointStyle::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_PointStyle::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_PointStyle::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_PointStyle::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_PointStyle::*)() const>(&StepVisual_PointStyle::Name),
             R"#()#" 
          )
        .def("SetMarker",
             (void (StepVisual_PointStyle::*)(  const StepVisual_MarkerSelect &  ) ) static_cast<void (StepVisual_PointStyle::*)(  const StepVisual_MarkerSelect &  ) >(&StepVisual_PointStyle::SetMarker),
             R"#()#"  , py::arg("aMarker")
          )
        .def("Marker",
             (StepVisual_MarkerSelect (StepVisual_PointStyle::*)() const) static_cast<StepVisual_MarkerSelect (StepVisual_PointStyle::*)() const>(&StepVisual_PointStyle::Marker),
             R"#()#" 
          )
        .def("SetMarkerSize",
             (void (StepVisual_PointStyle::*)(  const StepBasic_SizeSelect &  ) ) static_cast<void (StepVisual_PointStyle::*)(  const StepBasic_SizeSelect &  ) >(&StepVisual_PointStyle::SetMarkerSize),
             R"#()#"  , py::arg("aMarkerSize")
          )
        .def("MarkerSize",
             (StepBasic_SizeSelect (StepVisual_PointStyle::*)() const) static_cast<StepBasic_SizeSelect (StepVisual_PointStyle::*)() const>(&StepVisual_PointStyle::MarkerSize),
             R"#()#" 
          )
        .def("SetMarkerColour",
             (void (StepVisual_PointStyle::*)(  const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_PointStyle::*)(  const handle<StepVisual_Colour> &  ) >(&StepVisual_PointStyle::SetMarkerColour),
             R"#()#"  , py::arg("aMarkerColour")
          )
        .def("MarkerColour",
             (handle<StepVisual_Colour> (StepVisual_PointStyle::*)() const) static_cast<handle<StepVisual_Colour> (StepVisual_PointStyle::*)() const>(&StepVisual_PointStyle::MarkerColour),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PointStyle::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PointStyle::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> & (StepVisual_PointStyle::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PointStyle::*)() const>(&StepVisual_PointStyle::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PreDefinedItem ,opencascade::handle<StepVisual_PreDefinedItem>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PreDefinedItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_PreDefinedItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_PreDefinedItem::Init),
             R"#()#"  , py::arg("aName")
          )
        .def("SetName",
             (void (StepVisual_PreDefinedItem::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_PreDefinedItem::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_PreDefinedItem::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_PreDefinedItem::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_PreDefinedItem::*)() const>(&StepVisual_PreDefinedItem::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 * (*)() >(&StepVisual_PreDefinedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PreDefinedItem::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> & (StepVisual_PreDefinedItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PreDefinedItem::*)() const>(&StepVisual_PreDefinedItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationLayerAssignment ,opencascade::handle<StepVisual_PresentationLayerAssignment>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PresentationLayerAssignment::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfLayeredItem> &  ) ) static_cast<void (StepVisual_PresentationLayerAssignment::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfLayeredItem> &  ) >(&StepVisual_PresentationLayerAssignment::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aDescription"),  py::arg("aAssignedItems")
          )
        .def("SetName",
             (void (StepVisual_PresentationLayerAssignment::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_PresentationLayerAssignment::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_PresentationLayerAssignment::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_PresentationLayerAssignment::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_PresentationLayerAssignment::*)() const>(&StepVisual_PresentationLayerAssignment::Name),
             R"#()#" 
          )
        .def("SetDescription",
             (void (StepVisual_PresentationLayerAssignment::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_PresentationLayerAssignment::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_PresentationLayerAssignment::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (handle<TCollection_HAsciiString> (StepVisual_PresentationLayerAssignment::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_PresentationLayerAssignment::*)() const>(&StepVisual_PresentationLayerAssignment::Description),
             R"#()#" 
          )
        .def("SetAssignedItems",
             (void (StepVisual_PresentationLayerAssignment::*)(  const handle<StepVisual_HArray1OfLayeredItem> &  ) ) static_cast<void (StepVisual_PresentationLayerAssignment::*)(  const handle<StepVisual_HArray1OfLayeredItem> &  ) >(&StepVisual_PresentationLayerAssignment::SetAssignedItems),
             R"#()#"  , py::arg("aAssignedItems")
          )
        .def("AssignedItems",
             (handle<StepVisual_HArray1OfLayeredItem> (StepVisual_PresentationLayerAssignment::*)() const) static_cast<handle<StepVisual_HArray1OfLayeredItem> (StepVisual_PresentationLayerAssignment::*)() const>(&StepVisual_PresentationLayerAssignment::AssignedItems),
             R"#()#" 
          )
        .def("AssignedItemsValue",
             (StepVisual_LayeredItem (StepVisual_PresentationLayerAssignment::*)(  const Standard_Integer  ) const) static_cast<StepVisual_LayeredItem (StepVisual_PresentationLayerAssignment::*)(  const Standard_Integer  ) const>(&StepVisual_PresentationLayerAssignment::AssignedItemsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbAssignedItems",
             (Standard_Integer (StepVisual_PresentationLayerAssignment::*)() const) static_cast<Standard_Integer (StepVisual_PresentationLayerAssignment::*)() const>(&StepVisual_PresentationLayerAssignment::NbAssignedItems),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PresentationLayerAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationLayerAssignment::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> & (StepVisual_PresentationLayerAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationLayerAssignment::*)() const>(&StepVisual_PresentationLayerAssignment::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationLayerUsage ,opencascade::handle<StepVisual_PresentationLayerUsage>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PresentationLayerUsage::*)(  const handle<StepVisual_PresentationLayerAssignment> & ,   const handle<StepVisual_PresentationRepresentation> &  ) ) static_cast<void (StepVisual_PresentationLayerUsage::*)(  const handle<StepVisual_PresentationLayerAssignment> & ,   const handle<StepVisual_PresentationRepresentation> &  ) >(&StepVisual_PresentationLayerUsage::Init),
             R"#()#"  , py::arg("aAssignment"),  py::arg("aPresentation")
          )
        .def("SetAssignment",
             (void (StepVisual_PresentationLayerUsage::*)(  const handle<StepVisual_PresentationLayerAssignment> &  ) ) static_cast<void (StepVisual_PresentationLayerUsage::*)(  const handle<StepVisual_PresentationLayerAssignment> &  ) >(&StepVisual_PresentationLayerUsage::SetAssignment),
             R"#()#"  , py::arg("aAssignment")
          )
        .def("Assignment",
             (handle<StepVisual_PresentationLayerAssignment> (StepVisual_PresentationLayerUsage::*)() const) static_cast<handle<StepVisual_PresentationLayerAssignment> (StepVisual_PresentationLayerUsage::*)() const>(&StepVisual_PresentationLayerUsage::Assignment),
             R"#()#" 
          )
        .def("SetPresentation",
             (void (StepVisual_PresentationLayerUsage::*)(  const handle<StepVisual_PresentationRepresentation> &  ) ) static_cast<void (StepVisual_PresentationLayerUsage::*)(  const handle<StepVisual_PresentationRepresentation> &  ) >(&StepVisual_PresentationLayerUsage::SetPresentation),
             R"#()#"  , py::arg("aPresentation")
          )
        .def("Presentation",
             (handle<StepVisual_PresentationRepresentation> (StepVisual_PresentationLayerUsage::*)() const) static_cast<handle<StepVisual_PresentationRepresentation> (StepVisual_PresentationLayerUsage::*)() const>(&StepVisual_PresentationLayerUsage::Presentation),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PresentationLayerUsage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationLayerUsage::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> & (StepVisual_PresentationLayerUsage::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationLayerUsage::*)() const>(&StepVisual_PresentationLayerUsage::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationRepresentation ,opencascade::handle<StepVisual_PresentationRepresentation>  , 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 * (*)() >(&StepVisual_PresentationRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationRepresentation::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> & (StepVisual_PresentationRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationRepresentation::*)() const>(&StepVisual_PresentationRepresentation::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationRepresentationSelect , shared_ptr<StepVisual_PresentationRepresentationSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_PresentationRepresentationSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_PresentationRepresentationSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_PresentationRepresentationSelect::CaseNum),
             R"#(Recognizes a PresentationRepresentationSelect Kind Entity that is : 1 -> PresentationRepresentation 2 -> PresentationSet 0 else)#"  , py::arg("ent")
          )
        .def("PresentationRepresentation",
             (handle<StepVisual_PresentationRepresentation> (StepVisual_PresentationRepresentationSelect::*)() const) static_cast<handle<StepVisual_PresentationRepresentation> (StepVisual_PresentationRepresentationSelect::*)() const>(&StepVisual_PresentationRepresentationSelect::PresentationRepresentation),
             R"#(returns Value as a PresentationRepresentation (Null if another type))#" 
          )
        .def("PresentationSet",
             (handle<StepVisual_PresentationSet> (StepVisual_PresentationRepresentationSelect::*)() const) static_cast<handle<StepVisual_PresentationSet> (StepVisual_PresentationRepresentationSelect::*)() const>(&StepVisual_PresentationRepresentationSelect::PresentationSet),
             R"#(returns Value as a PresentationSet (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 StepVisual_PresentationSet from ./opencascade/StepVisual_PresentationSet.hxx
    klass = m.attr("StepVisual_PresentationSet");


    // nested enums

    static_cast<py::class_<StepVisual_PresentationSet ,opencascade::handle<StepVisual_PresentationSet>  , Standard_Transient >>(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 * (*)() >(&StepVisual_PresentationSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationSet::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> & (StepVisual_PresentationSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationSet::*)() const>(&StepVisual_PresentationSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationSize ,opencascade::handle<StepVisual_PresentationSize>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PresentationSize::*)(  const StepVisual_PresentationSizeAssignmentSelect & ,   const handle<StepVisual_PlanarBox> &  ) ) static_cast<void (StepVisual_PresentationSize::*)(  const StepVisual_PresentationSizeAssignmentSelect & ,   const handle<StepVisual_PlanarBox> &  ) >(&StepVisual_PresentationSize::Init),
             R"#()#"  , py::arg("aUnit"),  py::arg("aSize")
          )
        .def("SetUnit",
             (void (StepVisual_PresentationSize::*)(  const StepVisual_PresentationSizeAssignmentSelect &  ) ) static_cast<void (StepVisual_PresentationSize::*)(  const StepVisual_PresentationSizeAssignmentSelect &  ) >(&StepVisual_PresentationSize::SetUnit),
             R"#()#"  , py::arg("aUnit")
          )
        .def("Unit",
             (StepVisual_PresentationSizeAssignmentSelect (StepVisual_PresentationSize::*)() const) static_cast<StepVisual_PresentationSizeAssignmentSelect (StepVisual_PresentationSize::*)() const>(&StepVisual_PresentationSize::Unit),
             R"#()#" 
          )
        .def("SetSize",
             (void (StepVisual_PresentationSize::*)(  const handle<StepVisual_PlanarBox> &  ) ) static_cast<void (StepVisual_PresentationSize::*)(  const handle<StepVisual_PlanarBox> &  ) >(&StepVisual_PresentationSize::SetSize),
             R"#()#"  , py::arg("aSize")
          )
        .def("Size",
             (handle<StepVisual_PlanarBox> (StepVisual_PresentationSize::*)() const) static_cast<handle<StepVisual_PlanarBox> (StepVisual_PresentationSize::*)() const>(&StepVisual_PresentationSize::Size),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PresentationSize::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationSize::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> & (StepVisual_PresentationSize::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationSize::*)() const>(&StepVisual_PresentationSize::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationSizeAssignmentSelect , shared_ptr<StepVisual_PresentationSizeAssignmentSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_PresentationSizeAssignmentSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_PresentationSizeAssignmentSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_PresentationSizeAssignmentSelect::CaseNum),
             R"#(Recognizes a PresentationSizeAssignmentSelect Kind Entity that is : 1 -> PresentationView 2 -> PresentationArea 3 -> AreaInSet 0 else)#"  , py::arg("ent")
          )
        .def("PresentationView",
             (handle<StepVisual_PresentationView> (StepVisual_PresentationSizeAssignmentSelect::*)() const) static_cast<handle<StepVisual_PresentationView> (StepVisual_PresentationSizeAssignmentSelect::*)() const>(&StepVisual_PresentationSizeAssignmentSelect::PresentationView),
             R"#(returns Value as a PresentationView (Null if another type))#" 
          )
        .def("PresentationArea",
             (handle<StepVisual_PresentationArea> (StepVisual_PresentationSizeAssignmentSelect::*)() const) static_cast<handle<StepVisual_PresentationArea> (StepVisual_PresentationSizeAssignmentSelect::*)() const>(&StepVisual_PresentationSizeAssignmentSelect::PresentationArea),
             R"#(returns Value as a PresentationArea (Null if another type))#" 
          )
        .def("AreaInSet",
             (handle<StepVisual_AreaInSet> (StepVisual_PresentationSizeAssignmentSelect::*)() const) static_cast<handle<StepVisual_AreaInSet> (StepVisual_PresentationSizeAssignmentSelect::*)() const>(&StepVisual_PresentationSizeAssignmentSelect::AreaInSet),
             R"#(returns Value as a AreaInSet (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 StepVisual_PresentationStyleAssignment from ./opencascade/StepVisual_PresentationStyleAssignment.hxx
    klass = m.attr("StepVisual_PresentationStyleAssignment");


    // nested enums

    static_cast<py::class_<StepVisual_PresentationStyleAssignment ,opencascade::handle<StepVisual_PresentationStyleAssignment>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PresentationStyleAssignment::*)(  const handle<StepVisual_HArray1OfPresentationStyleSelect> &  ) ) static_cast<void (StepVisual_PresentationStyleAssignment::*)(  const handle<StepVisual_HArray1OfPresentationStyleSelect> &  ) >(&StepVisual_PresentationStyleAssignment::Init),
             R"#()#"  , py::arg("aStyles")
          )
        .def("SetStyles",
             (void (StepVisual_PresentationStyleAssignment::*)(  const handle<StepVisual_HArray1OfPresentationStyleSelect> &  ) ) static_cast<void (StepVisual_PresentationStyleAssignment::*)(  const handle<StepVisual_HArray1OfPresentationStyleSelect> &  ) >(&StepVisual_PresentationStyleAssignment::SetStyles),
             R"#()#"  , py::arg("aStyles")
          )
        .def("Styles",
             (handle<StepVisual_HArray1OfPresentationStyleSelect> (StepVisual_PresentationStyleAssignment::*)() const) static_cast<handle<StepVisual_HArray1OfPresentationStyleSelect> (StepVisual_PresentationStyleAssignment::*)() const>(&StepVisual_PresentationStyleAssignment::Styles),
             R"#()#" 
          )
        .def("StylesValue",
             (StepVisual_PresentationStyleSelect (StepVisual_PresentationStyleAssignment::*)(  const Standard_Integer  ) const) static_cast<StepVisual_PresentationStyleSelect (StepVisual_PresentationStyleAssignment::*)(  const Standard_Integer  ) const>(&StepVisual_PresentationStyleAssignment::StylesValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbStyles",
             (Standard_Integer (StepVisual_PresentationStyleAssignment::*)() const) static_cast<Standard_Integer (StepVisual_PresentationStyleAssignment::*)() const>(&StepVisual_PresentationStyleAssignment::NbStyles),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PresentationStyleAssignment::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationStyleAssignment::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> & (StepVisual_PresentationStyleAssignment::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationStyleAssignment::*)() const>(&StepVisual_PresentationStyleAssignment::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationStyleSelect , shared_ptr<StepVisual_PresentationStyleSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_PresentationStyleSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_PresentationStyleSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_PresentationStyleSelect::CaseNum),
             R"#(Recognizes a PresentationStyleSelect Kind Entity that is : 1 -> PointStyle 2 -> CurveStyle 3 -> SurfaceStyleUsage 4 -> SymbolStyle 5 -> FillAreaStyle 6 -> TextStyle 7 -> NullStyle 0 else)#"  , py::arg("ent")
          )
        .def("PointStyle",
             (handle<StepVisual_PointStyle> (StepVisual_PresentationStyleSelect::*)() const) static_cast<handle<StepVisual_PointStyle> (StepVisual_PresentationStyleSelect::*)() const>(&StepVisual_PresentationStyleSelect::PointStyle),
             R"#(returns Value as a PointStyle (Null if another type))#" 
          )
        .def("CurveStyle",
             (handle<StepVisual_CurveStyle> (StepVisual_PresentationStyleSelect::*)() const) static_cast<handle<StepVisual_CurveStyle> (StepVisual_PresentationStyleSelect::*)() const>(&StepVisual_PresentationStyleSelect::CurveStyle),
             R"#(returns Value as a CurveStyle (Null if another type))#" 
          )
        .def("NullStyle",
             (handle<StepVisual_NullStyleMember> (StepVisual_PresentationStyleSelect::*)() const) static_cast<handle<StepVisual_NullStyleMember> (StepVisual_PresentationStyleSelect::*)() const>(&StepVisual_PresentationStyleSelect::NullStyle),
             R"#(returns Value as a NullStyleMember (Null if another type))#" 
          )
        .def("SurfaceStyleUsage",
             (handle<StepVisual_SurfaceStyleUsage> (StepVisual_PresentationStyleSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleUsage> (StepVisual_PresentationStyleSelect::*)() const>(&StepVisual_PresentationStyleSelect::SurfaceStyleUsage),
             R"#(returns Value as a SurfaceStyleUsage (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 StepVisual_PresentedItem from ./opencascade/StepVisual_PresentedItem.hxx
    klass = m.attr("StepVisual_PresentedItem");

    // default constructor
    register_default_constructor<StepVisual_PresentedItem ,opencascade::handle<StepVisual_PresentedItem>>(m,"StepVisual_PresentedItem");

    // nested enums

    static_cast<py::class_<StepVisual_PresentedItem ,opencascade::handle<StepVisual_PresentedItem>  , Standard_Transient >>(klass)
    // constructors
    // 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 * (*)() >(&StepVisual_PresentedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentedItem::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> & (StepVisual_PresentedItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentedItem::*)() const>(&StepVisual_PresentedItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentedItemRepresentation ,opencascade::handle<StepVisual_PresentedItemRepresentation>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PresentedItemRepresentation::*)(  const StepVisual_PresentationRepresentationSelect & ,   const handle<StepVisual_PresentedItem> &  ) ) static_cast<void (StepVisual_PresentedItemRepresentation::*)(  const StepVisual_PresentationRepresentationSelect & ,   const handle<StepVisual_PresentedItem> &  ) >(&StepVisual_PresentedItemRepresentation::Init),
             R"#()#"  , py::arg("aPresentation"),  py::arg("aItem")
          )
        .def("SetPresentation",
             (void (StepVisual_PresentedItemRepresentation::*)(  const StepVisual_PresentationRepresentationSelect &  ) ) static_cast<void (StepVisual_PresentedItemRepresentation::*)(  const StepVisual_PresentationRepresentationSelect &  ) >(&StepVisual_PresentedItemRepresentation::SetPresentation),
             R"#()#"  , py::arg("aPresentation")
          )
        .def("Presentation",
             (StepVisual_PresentationRepresentationSelect (StepVisual_PresentedItemRepresentation::*)() const) static_cast<StepVisual_PresentationRepresentationSelect (StepVisual_PresentedItemRepresentation::*)() const>(&StepVisual_PresentedItemRepresentation::Presentation),
             R"#()#" 
          )
        .def("SetItem",
             (void (StepVisual_PresentedItemRepresentation::*)(  const handle<StepVisual_PresentedItem> &  ) ) static_cast<void (StepVisual_PresentedItemRepresentation::*)(  const handle<StepVisual_PresentedItem> &  ) >(&StepVisual_PresentedItemRepresentation::SetItem),
             R"#()#"  , py::arg("aItem")
          )
        .def("Item",
             (handle<StepVisual_PresentedItem> (StepVisual_PresentedItemRepresentation::*)() const) static_cast<handle<StepVisual_PresentedItem> (StepVisual_PresentedItemRepresentation::*)() const>(&StepVisual_PresentedItemRepresentation::Item),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PresentedItemRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentedItemRepresentation::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> & (StepVisual_PresentedItemRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentedItemRepresentation::*)() const>(&StepVisual_PresentedItemRepresentation::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_RenderingPropertiesSelect , shared_ptr<StepVisual_RenderingPropertiesSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_RenderingPropertiesSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_RenderingPropertiesSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_RenderingPropertiesSelect::CaseNum),
             R"#(Recognizes a kind of RenderingPropertiesSelect select type -- 1 -> SurfaceStyleReflectanceAmbient -- 2 -> SurfaceStyleTransparent)#"  , py::arg("ent")
          )
        .def("SurfaceStyleReflectanceAmbient",
             (handle<StepVisual_SurfaceStyleReflectanceAmbient> (StepVisual_RenderingPropertiesSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleReflectanceAmbient> (StepVisual_RenderingPropertiesSelect::*)() const>(&StepVisual_RenderingPropertiesSelect::SurfaceStyleReflectanceAmbient),
             R"#(Returns Value as SurfaceStyleReflectanceAmbient (or Null if another type))#" 
          )
        .def("SurfaceStyleTransparent",
             (handle<StepVisual_SurfaceStyleTransparent> (StepVisual_RenderingPropertiesSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleTransparent> (StepVisual_RenderingPropertiesSelect::*)() const>(&StepVisual_RenderingPropertiesSelect::SurfaceStyleTransparent),
             R"#(Returns Value as SurfaceStyleTransparent (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 StepVisual_StyleContextSelect from ./opencascade/StepVisual_StyleContextSelect.hxx
    klass = m.attr("StepVisual_StyleContextSelect");


    // nested enums

    static_cast<py::class_<StepVisual_StyleContextSelect , shared_ptr<StepVisual_StyleContextSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_StyleContextSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_StyleContextSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_StyleContextSelect::CaseNum),
             R"#(Recognizes a StyleContextSelect Kind Entity that is : 1 -> Representation 2 -> RepresentationItem 3 -> PresentationSet 0 else)#"  , py::arg("ent")
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepVisual_StyleContextSelect::*)() const) static_cast<handle<StepRepr_Representation> (StepVisual_StyleContextSelect::*)() const>(&StepVisual_StyleContextSelect::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("RepresentationItem",
             (handle<StepRepr_RepresentationItem> (StepVisual_StyleContextSelect::*)() const) static_cast<handle<StepRepr_RepresentationItem> (StepVisual_StyleContextSelect::*)() const>(&StepVisual_StyleContextSelect::RepresentationItem),
             R"#(returns Value as a RepresentationItem (Null if another type))#" 
          )
        .def("PresentationSet",
             (handle<StepVisual_PresentationSet> (StepVisual_StyleContextSelect::*)() const) static_cast<handle<StepVisual_PresentationSet> (StepVisual_StyleContextSelect::*)() const>(&StepVisual_StyleContextSelect::PresentationSet),
             R"#(returns Value as a PresentationSet (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 StepVisual_StyledItem from ./opencascade/StepVisual_StyledItem.hxx
    klass = m.attr("StepVisual_StyledItem");


    // nested enums

    static_cast<py::class_<StepVisual_StyledItem ,opencascade::handle<StepVisual_StyledItem>  , StepRepr_RepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_StyledItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> &  ) ) static_cast<void (StepVisual_StyledItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> &  ) >(&StepVisual_StyledItem::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aStyles"),  py::arg("aItem")
          )
        .def("SetStyles",
             (void (StepVisual_StyledItem::*)(  const handle<StepVisual_HArray1OfPresentationStyleAssignment> &  ) ) static_cast<void (StepVisual_StyledItem::*)(  const handle<StepVisual_HArray1OfPresentationStyleAssignment> &  ) >(&StepVisual_StyledItem::SetStyles),
             R"#()#"  , py::arg("aStyles")
          )
        .def("StylesValue",
             ( const handle<StepVisual_PresentationStyleAssignment> & (StepVisual_StyledItem::*)(  const Standard_Integer  ) const) static_cast< const handle<StepVisual_PresentationStyleAssignment> & (StepVisual_StyledItem::*)(  const Standard_Integer  ) const>(&StepVisual_StyledItem::StylesValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbStyles",
             (Standard_Integer (StepVisual_StyledItem::*)() const) static_cast<Standard_Integer (StepVisual_StyledItem::*)() const>(&StepVisual_StyledItem::NbStyles),
             R"#()#" 
          )
        .def("SetItem",
             (void (StepVisual_StyledItem::*)(  const handle<StepRepr_RepresentationItem> &  ) ) static_cast<void (StepVisual_StyledItem::*)(  const handle<StepRepr_RepresentationItem> &  ) >(&StepVisual_StyledItem::SetItem),
             R"#()#"  , py::arg("aItem")
          )
        .def("SetItem",
             (void (StepVisual_StyledItem::*)(  const StepVisual_StyledItemTarget &  ) ) static_cast<void (StepVisual_StyledItem::*)(  const StepVisual_StyledItemTarget &  ) >(&StepVisual_StyledItem::SetItem),
             R"#()#"  , py::arg("aItem")
          )
        .def("ItemAP242",
             (StepVisual_StyledItemTarget (StepVisual_StyledItem::*)() const) static_cast<StepVisual_StyledItemTarget (StepVisual_StyledItem::*)() const>(&StepVisual_StyledItem::ItemAP242),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_StyledItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_StyledItem::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("Styles",
             ( const handle<StepVisual_HArray1OfPresentationStyleAssignment> & (StepVisual_StyledItem::*)() const) static_cast< const handle<StepVisual_HArray1OfPresentationStyleAssignment> & (StepVisual_StyledItem::*)() const>(&StepVisual_StyledItem::Styles),
             R"#()#"
             
         )
       .def("Item",
             ( const handle<StepRepr_RepresentationItem> & (StepVisual_StyledItem::*)() const) static_cast< const handle<StepRepr_RepresentationItem> & (StepVisual_StyledItem::*)() const>(&StepVisual_StyledItem::Item),
             R"#()#"
             
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_StyledItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_StyledItem::*)() const>(&StepVisual_StyledItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_StyledItemTarget , shared_ptr<StepVisual_StyledItemTarget>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_StyledItemTarget::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_StyledItemTarget::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_StyledItemTarget::CaseNum),
             R"#(Recognizes a StyledItemTarget Kind Entity that is : 1 -> GeometricRepresentationItem 2 -> MappedItem 3 -> Representation 4 -> TopologicalRepresentationItem 0 else)#"  , py::arg("ent")
          )
        .def("GeometricRepresentationItem",
             (handle<StepGeom_GeometricRepresentationItem> (StepVisual_StyledItemTarget::*)() const) static_cast<handle<StepGeom_GeometricRepresentationItem> (StepVisual_StyledItemTarget::*)() const>(&StepVisual_StyledItemTarget::GeometricRepresentationItem),
             R"#(returns Value as a GeometricRepresentationItem (Null if another type))#" 
          )
        .def("MappedItem",
             (handle<StepRepr_MappedItem> (StepVisual_StyledItemTarget::*)() const) static_cast<handle<StepRepr_MappedItem> (StepVisual_StyledItemTarget::*)() const>(&StepVisual_StyledItemTarget::MappedItem),
             R"#(returns Value as a MappedItem (Null if another type))#" 
          )
        .def("Representation",
             (handle<StepRepr_Representation> (StepVisual_StyledItemTarget::*)() const) static_cast<handle<StepRepr_Representation> (StepVisual_StyledItemTarget::*)() const>(&StepVisual_StyledItemTarget::Representation),
             R"#(returns Value as a Representation (Null if another type))#" 
          )
        .def("TopologicalRepresentationItem",
             (handle<StepShape_TopologicalRepresentationItem> (StepVisual_StyledItemTarget::*)() const) static_cast<handle<StepShape_TopologicalRepresentationItem> (StepVisual_StyledItemTarget::*)() const>(&StepVisual_StyledItemTarget::TopologicalRepresentationItem),
             R"#(returns Value as a TopologicalRepresentationItem (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 StepVisual_SurfaceSideStyle from ./opencascade/StepVisual_SurfaceSideStyle.hxx
    klass = m.attr("StepVisual_SurfaceSideStyle");


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceSideStyle ,opencascade::handle<StepVisual_SurfaceSideStyle>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceSideStyle::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfSurfaceStyleElementSelect> &  ) ) static_cast<void (StepVisual_SurfaceSideStyle::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfSurfaceStyleElementSelect> &  ) >(&StepVisual_SurfaceSideStyle::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aStyles")
          )
        .def("SetName",
             (void (StepVisual_SurfaceSideStyle::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_SurfaceSideStyle::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_SurfaceSideStyle::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_SurfaceSideStyle::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_SurfaceSideStyle::*)() const>(&StepVisual_SurfaceSideStyle::Name),
             R"#()#" 
          )
        .def("SetStyles",
             (void (StepVisual_SurfaceSideStyle::*)(  const handle<StepVisual_HArray1OfSurfaceStyleElementSelect> &  ) ) static_cast<void (StepVisual_SurfaceSideStyle::*)(  const handle<StepVisual_HArray1OfSurfaceStyleElementSelect> &  ) >(&StepVisual_SurfaceSideStyle::SetStyles),
             R"#()#"  , py::arg("aStyles")
          )
        .def("Styles",
             (handle<StepVisual_HArray1OfSurfaceStyleElementSelect> (StepVisual_SurfaceSideStyle::*)() const) static_cast<handle<StepVisual_HArray1OfSurfaceStyleElementSelect> (StepVisual_SurfaceSideStyle::*)() const>(&StepVisual_SurfaceSideStyle::Styles),
             R"#()#" 
          )
        .def("StylesValue",
             (StepVisual_SurfaceStyleElementSelect (StepVisual_SurfaceSideStyle::*)(  const Standard_Integer  ) const) static_cast<StepVisual_SurfaceStyleElementSelect (StepVisual_SurfaceSideStyle::*)(  const Standard_Integer  ) const>(&StepVisual_SurfaceSideStyle::StylesValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbStyles",
             (Standard_Integer (StepVisual_SurfaceSideStyle::*)() const) static_cast<Standard_Integer (StepVisual_SurfaceSideStyle::*)() const>(&StepVisual_SurfaceSideStyle::NbStyles),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceSideStyle::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceSideStyle::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> & (StepVisual_SurfaceSideStyle::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceSideStyle::*)() const>(&StepVisual_SurfaceSideStyle::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleBoundary ,opencascade::handle<StepVisual_SurfaceStyleBoundary>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleBoundary::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleBoundary::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleBoundary::Init),
             R"#()#"  , py::arg("aStyleOfBoundary")
          )
        .def("SetStyleOfBoundary",
             (void (StepVisual_SurfaceStyleBoundary::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleBoundary::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleBoundary::SetStyleOfBoundary),
             R"#()#"  , py::arg("aStyleOfBoundary")
          )
        .def("StyleOfBoundary",
             (handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleBoundary::*)() const) static_cast<handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleBoundary::*)() const>(&StepVisual_SurfaceStyleBoundary::StyleOfBoundary),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleBoundary::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleBoundary::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> & (StepVisual_SurfaceStyleBoundary::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleBoundary::*)() const>(&StepVisual_SurfaceStyleBoundary::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleControlGrid ,opencascade::handle<StepVisual_SurfaceStyleControlGrid>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleControlGrid::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleControlGrid::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleControlGrid::Init),
             R"#()#"  , py::arg("aStyleOfControlGrid")
          )
        .def("SetStyleOfControlGrid",
             (void (StepVisual_SurfaceStyleControlGrid::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleControlGrid::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleControlGrid::SetStyleOfControlGrid),
             R"#()#"  , py::arg("aStyleOfControlGrid")
          )
        .def("StyleOfControlGrid",
             (handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleControlGrid::*)() const) static_cast<handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleControlGrid::*)() const>(&StepVisual_SurfaceStyleControlGrid::StyleOfControlGrid),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleControlGrid::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleControlGrid::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> & (StepVisual_SurfaceStyleControlGrid::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleControlGrid::*)() const>(&StepVisual_SurfaceStyleControlGrid::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleElementSelect , shared_ptr<StepVisual_SurfaceStyleElementSelect>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_SurfaceStyleElementSelect::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_SurfaceStyleElementSelect::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_SurfaceStyleElementSelect::CaseNum),
             R"#(Recognizes a SurfaceStyleElementSelect Kind Entity that is : 1 -> SurfaceStyleFillArea 2 -> SurfaceStyleBoundary 3 -> SurfaceStyleParameterLine 4 -> SurfaceStyleSilhouette 5 -> SurfaceStyleSegmentationCurve 6 -> SurfaceStyleControlGrid 7 -> SurfaceStyleRendering 0 else)#"  , py::arg("ent")
          )
        .def("SurfaceStyleFillArea",
             (handle<StepVisual_SurfaceStyleFillArea> (StepVisual_SurfaceStyleElementSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleFillArea> (StepVisual_SurfaceStyleElementSelect::*)() const>(&StepVisual_SurfaceStyleElementSelect::SurfaceStyleFillArea),
             R"#(returns Value as a SurfaceStyleFillArea (Null if another type))#" 
          )
        .def("SurfaceStyleBoundary",
             (handle<StepVisual_SurfaceStyleBoundary> (StepVisual_SurfaceStyleElementSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleBoundary> (StepVisual_SurfaceStyleElementSelect::*)() const>(&StepVisual_SurfaceStyleElementSelect::SurfaceStyleBoundary),
             R"#(returns Value as a SurfaceStyleBoundary (Null if another type))#" 
          )
        .def("SurfaceStyleParameterLine",
             (handle<StepVisual_SurfaceStyleParameterLine> (StepVisual_SurfaceStyleElementSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleParameterLine> (StepVisual_SurfaceStyleElementSelect::*)() const>(&StepVisual_SurfaceStyleElementSelect::SurfaceStyleParameterLine),
             R"#(returns Value as a SurfaceStyleParameterLine (Null if another type))#" 
          )
        .def("SurfaceStyleRendering",
             (handle<StepVisual_SurfaceStyleRendering> (StepVisual_SurfaceStyleElementSelect::*)() const) static_cast<handle<StepVisual_SurfaceStyleRendering> (StepVisual_SurfaceStyleElementSelect::*)() const>(&StepVisual_SurfaceStyleElementSelect::SurfaceStyleRendering),
             R"#(returns Value as a SurfaceStyleRendering (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 StepVisual_SurfaceStyleFillArea from ./opencascade/StepVisual_SurfaceStyleFillArea.hxx
    klass = m.attr("StepVisual_SurfaceStyleFillArea");


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleFillArea ,opencascade::handle<StepVisual_SurfaceStyleFillArea>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleFillArea::*)(  const handle<StepVisual_FillAreaStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleFillArea::*)(  const handle<StepVisual_FillAreaStyle> &  ) >(&StepVisual_SurfaceStyleFillArea::Init),
             R"#()#"  , py::arg("aFillArea")
          )
        .def("SetFillArea",
             (void (StepVisual_SurfaceStyleFillArea::*)(  const handle<StepVisual_FillAreaStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleFillArea::*)(  const handle<StepVisual_FillAreaStyle> &  ) >(&StepVisual_SurfaceStyleFillArea::SetFillArea),
             R"#()#"  , py::arg("aFillArea")
          )
        .def("FillArea",
             (handle<StepVisual_FillAreaStyle> (StepVisual_SurfaceStyleFillArea::*)() const) static_cast<handle<StepVisual_FillAreaStyle> (StepVisual_SurfaceStyleFillArea::*)() const>(&StepVisual_SurfaceStyleFillArea::FillArea),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleFillArea::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleFillArea::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> & (StepVisual_SurfaceStyleFillArea::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleFillArea::*)() const>(&StepVisual_SurfaceStyleFillArea::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleParameterLine ,opencascade::handle<StepVisual_SurfaceStyleParameterLine>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleParameterLine::*)(  const handle<StepVisual_CurveStyle> & ,   const handle<StepVisual_HArray1OfDirectionCountSelect> &  ) ) static_cast<void (StepVisual_SurfaceStyleParameterLine::*)(  const handle<StepVisual_CurveStyle> & ,   const handle<StepVisual_HArray1OfDirectionCountSelect> &  ) >(&StepVisual_SurfaceStyleParameterLine::Init),
             R"#()#"  , py::arg("aStyleOfParameterLines"),  py::arg("aDirectionCounts")
          )
        .def("SetStyleOfParameterLines",
             (void (StepVisual_SurfaceStyleParameterLine::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleParameterLine::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleParameterLine::SetStyleOfParameterLines),
             R"#()#"  , py::arg("aStyleOfParameterLines")
          )
        .def("StyleOfParameterLines",
             (handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleParameterLine::*)() const) static_cast<handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleParameterLine::*)() const>(&StepVisual_SurfaceStyleParameterLine::StyleOfParameterLines),
             R"#()#" 
          )
        .def("SetDirectionCounts",
             (void (StepVisual_SurfaceStyleParameterLine::*)(  const handle<StepVisual_HArray1OfDirectionCountSelect> &  ) ) static_cast<void (StepVisual_SurfaceStyleParameterLine::*)(  const handle<StepVisual_HArray1OfDirectionCountSelect> &  ) >(&StepVisual_SurfaceStyleParameterLine::SetDirectionCounts),
             R"#()#"  , py::arg("aDirectionCounts")
          )
        .def("DirectionCounts",
             (handle<StepVisual_HArray1OfDirectionCountSelect> (StepVisual_SurfaceStyleParameterLine::*)() const) static_cast<handle<StepVisual_HArray1OfDirectionCountSelect> (StepVisual_SurfaceStyleParameterLine::*)() const>(&StepVisual_SurfaceStyleParameterLine::DirectionCounts),
             R"#()#" 
          )
        .def("DirectionCountsValue",
             (StepVisual_DirectionCountSelect (StepVisual_SurfaceStyleParameterLine::*)(  const Standard_Integer  ) const) static_cast<StepVisual_DirectionCountSelect (StepVisual_SurfaceStyleParameterLine::*)(  const Standard_Integer  ) const>(&StepVisual_SurfaceStyleParameterLine::DirectionCountsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbDirectionCounts",
             (Standard_Integer (StepVisual_SurfaceStyleParameterLine::*)() const) static_cast<Standard_Integer (StepVisual_SurfaceStyleParameterLine::*)() const>(&StepVisual_SurfaceStyleParameterLine::NbDirectionCounts),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleParameterLine::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleParameterLine::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> & (StepVisual_SurfaceStyleParameterLine::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleParameterLine::*)() const>(&StepVisual_SurfaceStyleParameterLine::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleReflectanceAmbient ,opencascade::handle<StepVisual_SurfaceStyleReflectanceAmbient>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleReflectanceAmbient::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_SurfaceStyleReflectanceAmbient::*)(  const Standard_Real  ) >(&StepVisual_SurfaceStyleReflectanceAmbient::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theAmbientReflectance")
          )
        .def("AmbientReflectance",
             (Standard_Real (StepVisual_SurfaceStyleReflectanceAmbient::*)() const) static_cast<Standard_Real (StepVisual_SurfaceStyleReflectanceAmbient::*)() const>(&StepVisual_SurfaceStyleReflectanceAmbient::AmbientReflectance),
             R"#(Returns field AmbientReflectance)#" 
          )
        .def("SetAmbientReflectance",
             (void (StepVisual_SurfaceStyleReflectanceAmbient::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_SurfaceStyleReflectanceAmbient::*)(  const Standard_Real  ) >(&StepVisual_SurfaceStyleReflectanceAmbient::SetAmbientReflectance),
             R"#(Sets field AmbientReflectance)#"  , py::arg("theAmbientReflectance")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleReflectanceAmbient::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleReflectanceAmbient::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> & (StepVisual_SurfaceStyleReflectanceAmbient::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleReflectanceAmbient::*)() const>(&StepVisual_SurfaceStyleReflectanceAmbient::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleRendering ,opencascade::handle<StepVisual_SurfaceStyleRendering>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleRendering::*)(  const StepVisual_ShadingSurfaceMethod ,   const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_SurfaceStyleRendering::*)(  const StepVisual_ShadingSurfaceMethod ,   const handle<StepVisual_Colour> &  ) >(&StepVisual_SurfaceStyleRendering::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRenderingMethod"),  py::arg("theSurfaceColour")
          )
        .def("RenderingMethod",
             (StepVisual_ShadingSurfaceMethod (StepVisual_SurfaceStyleRendering::*)() const) static_cast<StepVisual_ShadingSurfaceMethod (StepVisual_SurfaceStyleRendering::*)() const>(&StepVisual_SurfaceStyleRendering::RenderingMethod),
             R"#(Returns field RenderingMethod)#" 
          )
        .def("SetRenderingMethod",
             (void (StepVisual_SurfaceStyleRendering::*)(  const StepVisual_ShadingSurfaceMethod  ) ) static_cast<void (StepVisual_SurfaceStyleRendering::*)(  const StepVisual_ShadingSurfaceMethod  ) >(&StepVisual_SurfaceStyleRendering::SetRenderingMethod),
             R"#(Sets field RenderingMethod)#"  , py::arg("theRenderingMethod")
          )
        .def("SurfaceColour",
             (handle<StepVisual_Colour> (StepVisual_SurfaceStyleRendering::*)() const) static_cast<handle<StepVisual_Colour> (StepVisual_SurfaceStyleRendering::*)() const>(&StepVisual_SurfaceStyleRendering::SurfaceColour),
             R"#(Returns field SurfaceColour)#" 
          )
        .def("SetSurfaceColour",
             (void (StepVisual_SurfaceStyleRendering::*)(  const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_SurfaceStyleRendering::*)(  const handle<StepVisual_Colour> &  ) >(&StepVisual_SurfaceStyleRendering::SetSurfaceColour),
             R"#(Sets field SurfaceColour)#"  , py::arg("theSurfaceColour")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleRendering::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleRendering::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> & (StepVisual_SurfaceStyleRendering::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleRendering::*)() const>(&StepVisual_SurfaceStyleRendering::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleSegmentationCurve ,opencascade::handle<StepVisual_SurfaceStyleSegmentationCurve>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleSegmentationCurve::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleSegmentationCurve::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleSegmentationCurve::Init),
             R"#()#"  , py::arg("aStyleOfSegmentationCurve")
          )
        .def("SetStyleOfSegmentationCurve",
             (void (StepVisual_SurfaceStyleSegmentationCurve::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleSegmentationCurve::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleSegmentationCurve::SetStyleOfSegmentationCurve),
             R"#()#"  , py::arg("aStyleOfSegmentationCurve")
          )
        .def("StyleOfSegmentationCurve",
             (handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleSegmentationCurve::*)() const) static_cast<handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleSegmentationCurve::*)() const>(&StepVisual_SurfaceStyleSegmentationCurve::StyleOfSegmentationCurve),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleSegmentationCurve::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleSegmentationCurve::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> & (StepVisual_SurfaceStyleSegmentationCurve::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleSegmentationCurve::*)() const>(&StepVisual_SurfaceStyleSegmentationCurve::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleSilhouette ,opencascade::handle<StepVisual_SurfaceStyleSilhouette>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleSilhouette::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleSilhouette::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleSilhouette::Init),
             R"#()#"  , py::arg("aStyleOfSilhouette")
          )
        .def("SetStyleOfSilhouette",
             (void (StepVisual_SurfaceStyleSilhouette::*)(  const handle<StepVisual_CurveStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleSilhouette::*)(  const handle<StepVisual_CurveStyle> &  ) >(&StepVisual_SurfaceStyleSilhouette::SetStyleOfSilhouette),
             R"#()#"  , py::arg("aStyleOfSilhouette")
          )
        .def("StyleOfSilhouette",
             (handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleSilhouette::*)() const) static_cast<handle<StepVisual_CurveStyle> (StepVisual_SurfaceStyleSilhouette::*)() const>(&StepVisual_SurfaceStyleSilhouette::StyleOfSilhouette),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleSilhouette::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleSilhouette::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> & (StepVisual_SurfaceStyleSilhouette::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleSilhouette::*)() const>(&StepVisual_SurfaceStyleSilhouette::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleTransparent ,opencascade::handle<StepVisual_SurfaceStyleTransparent>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleTransparent::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_SurfaceStyleTransparent::*)(  const Standard_Real  ) >(&StepVisual_SurfaceStyleTransparent::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theTransparency")
          )
        .def("Transparency",
             (Standard_Real (StepVisual_SurfaceStyleTransparent::*)() const) static_cast<Standard_Real (StepVisual_SurfaceStyleTransparent::*)() const>(&StepVisual_SurfaceStyleTransparent::Transparency),
             R"#(Returns field Transparency)#" 
          )
        .def("SetTransparency",
             (void (StepVisual_SurfaceStyleTransparent::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_SurfaceStyleTransparent::*)(  const Standard_Real  ) >(&StepVisual_SurfaceStyleTransparent::SetTransparency),
             R"#(Sets field Transparency)#"  , py::arg("theTransparency")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleTransparent::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleTransparent::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> & (StepVisual_SurfaceStyleTransparent::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleTransparent::*)() const>(&StepVisual_SurfaceStyleTransparent::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleUsage ,opencascade::handle<StepVisual_SurfaceStyleUsage>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleUsage::*)(  const StepVisual_SurfaceSide ,   const handle<StepVisual_SurfaceSideStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleUsage::*)(  const StepVisual_SurfaceSide ,   const handle<StepVisual_SurfaceSideStyle> &  ) >(&StepVisual_SurfaceStyleUsage::Init),
             R"#()#"  , py::arg("aSide"),  py::arg("aStyle")
          )
        .def("SetSide",
             (void (StepVisual_SurfaceStyleUsage::*)(  const StepVisual_SurfaceSide  ) ) static_cast<void (StepVisual_SurfaceStyleUsage::*)(  const StepVisual_SurfaceSide  ) >(&StepVisual_SurfaceStyleUsage::SetSide),
             R"#()#"  , py::arg("aSide")
          )
        .def("Side",
             (StepVisual_SurfaceSide (StepVisual_SurfaceStyleUsage::*)() const) static_cast<StepVisual_SurfaceSide (StepVisual_SurfaceStyleUsage::*)() const>(&StepVisual_SurfaceStyleUsage::Side),
             R"#()#" 
          )
        .def("SetStyle",
             (void (StepVisual_SurfaceStyleUsage::*)(  const handle<StepVisual_SurfaceSideStyle> &  ) ) static_cast<void (StepVisual_SurfaceStyleUsage::*)(  const handle<StepVisual_SurfaceSideStyle> &  ) >(&StepVisual_SurfaceStyleUsage::SetStyle),
             R"#()#"  , py::arg("aStyle")
          )
        .def("Style",
             (handle<StepVisual_SurfaceSideStyle> (StepVisual_SurfaceStyleUsage::*)() const) static_cast<handle<StepVisual_SurfaceSideStyle> (StepVisual_SurfaceStyleUsage::*)() const>(&StepVisual_SurfaceStyleUsage::Style),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleUsage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleUsage::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> & (StepVisual_SurfaceStyleUsage::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleUsage::*)() const>(&StepVisual_SurfaceStyleUsage::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_Template ,opencascade::handle<StepVisual_Template>  , 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 * (*)() >(&StepVisual_Template::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_Template::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> & (StepVisual_Template::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_Template::*)() const>(&StepVisual_Template::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TemplateInstance ,opencascade::handle<StepVisual_TemplateInstance>  , StepRepr_MappedItem >>(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 * (*)() >(&StepVisual_TemplateInstance::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TemplateInstance::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> & (StepVisual_TemplateInstance::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TemplateInstance::*)() const>(&StepVisual_TemplateInstance::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedEdgeOrVertex , shared_ptr<StepVisual_TessellatedEdgeOrVertex>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_TessellatedEdgeOrVertex::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_TessellatedEdgeOrVertex::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_TessellatedEdgeOrVertex::CaseNum),
             R"#(Recognizes a kind of TessellatedEdgeOrVertex select type -- 1 -> TessellatedEdge -- 2 -> TessellatedVertex)#"  , py::arg("ent")
          )
        .def("TessellatedEdge",
             (handle<StepVisual_TessellatedEdge> (StepVisual_TessellatedEdgeOrVertex::*)() const) static_cast<handle<StepVisual_TessellatedEdge> (StepVisual_TessellatedEdgeOrVertex::*)() const>(&StepVisual_TessellatedEdgeOrVertex::TessellatedEdge),
             R"#(Returns Value as TessellatedEdge (or Null if another type))#" 
          )
        .def("TessellatedVertex",
             (handle<StepVisual_TessellatedVertex> (StepVisual_TessellatedEdgeOrVertex::*)() const) static_cast<handle<StepVisual_TessellatedVertex> (StepVisual_TessellatedEdgeOrVertex::*)() const>(&StepVisual_TessellatedEdgeOrVertex::TessellatedVertex),
             R"#(Returns Value as TessellatedVertex (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 StepVisual_TessellatedItem from ./opencascade/StepVisual_TessellatedItem.hxx
    klass = m.attr("StepVisual_TessellatedItem");


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedItem ,opencascade::handle<StepVisual_TessellatedItem>  , StepGeom_GeometricRepresentationItem >>(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 * (*)() >(&StepVisual_TessellatedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedItem::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> & (StepVisual_TessellatedItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedItem::*)() const>(&StepVisual_TessellatedItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedShapeRepresentation ,opencascade::handle<StepVisual_TessellatedShapeRepresentation>  , StepShape_ShapeRepresentation >>(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 * (*)() >(&StepVisual_TessellatedShapeRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedShapeRepresentation::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> & (StepVisual_TessellatedShapeRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedShapeRepresentation::*)() const>(&StepVisual_TessellatedShapeRepresentation::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TextLiteral ,opencascade::handle<StepVisual_TextLiteral>  , StepGeom_GeometricRepresentationItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TextLiteral::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const StepGeom_Axis2Placement & ,   const handle<TCollection_HAsciiString> & ,   const StepVisual_TextPath ,   const StepVisual_FontSelect &  ) ) static_cast<void (StepVisual_TextLiteral::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TCollection_HAsciiString> & ,   const StepGeom_Axis2Placement & ,   const handle<TCollection_HAsciiString> & ,   const StepVisual_TextPath ,   const StepVisual_FontSelect &  ) >(&StepVisual_TextLiteral::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aLiteral"),  py::arg("aPlacement"),  py::arg("aAlignment"),  py::arg("aPath"),  py::arg("aFont")
          )
        .def("SetLiteral",
             (void (StepVisual_TextLiteral::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_TextLiteral::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_TextLiteral::SetLiteral),
             R"#()#"  , py::arg("aLiteral")
          )
        .def("Literal",
             (handle<TCollection_HAsciiString> (StepVisual_TextLiteral::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_TextLiteral::*)() const>(&StepVisual_TextLiteral::Literal),
             R"#()#" 
          )
        .def("SetPlacement",
             (void (StepVisual_TextLiteral::*)(  const StepGeom_Axis2Placement &  ) ) static_cast<void (StepVisual_TextLiteral::*)(  const StepGeom_Axis2Placement &  ) >(&StepVisual_TextLiteral::SetPlacement),
             R"#()#"  , py::arg("aPlacement")
          )
        .def("Placement",
             (StepGeom_Axis2Placement (StepVisual_TextLiteral::*)() const) static_cast<StepGeom_Axis2Placement (StepVisual_TextLiteral::*)() const>(&StepVisual_TextLiteral::Placement),
             R"#()#" 
          )
        .def("SetAlignment",
             (void (StepVisual_TextLiteral::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_TextLiteral::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_TextLiteral::SetAlignment),
             R"#()#"  , py::arg("aAlignment")
          )
        .def("Alignment",
             (handle<TCollection_HAsciiString> (StepVisual_TextLiteral::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_TextLiteral::*)() const>(&StepVisual_TextLiteral::Alignment),
             R"#()#" 
          )
        .def("SetPath",
             (void (StepVisual_TextLiteral::*)(  const StepVisual_TextPath  ) ) static_cast<void (StepVisual_TextLiteral::*)(  const StepVisual_TextPath  ) >(&StepVisual_TextLiteral::SetPath),
             R"#()#"  , py::arg("aPath")
          )
        .def("Path",
             (StepVisual_TextPath (StepVisual_TextLiteral::*)() const) static_cast<StepVisual_TextPath (StepVisual_TextLiteral::*)() const>(&StepVisual_TextLiteral::Path),
             R"#()#" 
          )
        .def("SetFont",
             (void (StepVisual_TextLiteral::*)(  const StepVisual_FontSelect &  ) ) static_cast<void (StepVisual_TextLiteral::*)(  const StepVisual_FontSelect &  ) >(&StepVisual_TextLiteral::SetFont),
             R"#()#"  , py::arg("aFont")
          )
        .def("Font",
             (StepVisual_FontSelect (StepVisual_TextLiteral::*)() const) static_cast<StepVisual_FontSelect (StepVisual_TextLiteral::*)() const>(&StepVisual_TextLiteral::Font),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TextLiteral::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TextLiteral::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> & (StepVisual_TextLiteral::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TextLiteral::*)() const>(&StepVisual_TextLiteral::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TextOrCharacter , shared_ptr<StepVisual_TextOrCharacter>  , StepData_SelectType >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("CaseNum",
             (Standard_Integer (StepVisual_TextOrCharacter::*)(  const handle<Standard_Transient> &  ) const) static_cast<Standard_Integer (StepVisual_TextOrCharacter::*)(  const handle<Standard_Transient> &  ) const>(&StepVisual_TextOrCharacter::CaseNum),
             R"#(Recognizes a TextOrCharacter Kind Entity that is : 1 -> AnnotationText 2 -> CompositeText 3 -> TextLiteral 0 else)#"  , py::arg("ent")
          )
        .def("AnnotationText",
             (handle<StepVisual_AnnotationText> (StepVisual_TextOrCharacter::*)() const) static_cast<handle<StepVisual_AnnotationText> (StepVisual_TextOrCharacter::*)() const>(&StepVisual_TextOrCharacter::AnnotationText),
             R"#(returns Value as a AnnotationText (Null if another type))#" 
          )
        .def("CompositeText",
             (handle<StepVisual_CompositeText> (StepVisual_TextOrCharacter::*)() const) static_cast<handle<StepVisual_CompositeText> (StepVisual_TextOrCharacter::*)() const>(&StepVisual_TextOrCharacter::CompositeText),
             R"#(returns Value as a CompositeText (Null if another type))#" 
          )
        .def("TextLiteral",
             (handle<StepVisual_TextLiteral> (StepVisual_TextOrCharacter::*)() const) static_cast<handle<StepVisual_TextLiteral> (StepVisual_TextOrCharacter::*)() const>(&StepVisual_TextOrCharacter::TextLiteral),
             R"#(returns Value as a TextLiteral (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 StepVisual_TextStyle from ./opencascade/StepVisual_TextStyle.hxx
    klass = m.attr("StepVisual_TextStyle");


    // nested enums

    static_cast<py::class_<StepVisual_TextStyle ,opencascade::handle<StepVisual_TextStyle>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TextStyle::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_TextStyleForDefinedFont> &  ) ) static_cast<void (StepVisual_TextStyle::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_TextStyleForDefinedFont> &  ) >(&StepVisual_TextStyle::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aCharacterAppearance")
          )
        .def("SetName",
             (void (StepVisual_TextStyle::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_TextStyle::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_TextStyle::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_TextStyle::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_TextStyle::*)() const>(&StepVisual_TextStyle::Name),
             R"#()#" 
          )
        .def("SetCharacterAppearance",
             (void (StepVisual_TextStyle::*)(  const handle<StepVisual_TextStyleForDefinedFont> &  ) ) static_cast<void (StepVisual_TextStyle::*)(  const handle<StepVisual_TextStyleForDefinedFont> &  ) >(&StepVisual_TextStyle::SetCharacterAppearance),
             R"#()#"  , py::arg("aCharacterAppearance")
          )
        .def("CharacterAppearance",
             (handle<StepVisual_TextStyleForDefinedFont> (StepVisual_TextStyle::*)() const) static_cast<handle<StepVisual_TextStyleForDefinedFont> (StepVisual_TextStyle::*)() const>(&StepVisual_TextStyle::CharacterAppearance),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TextStyle::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TextStyle::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> & (StepVisual_TextStyle::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TextStyle::*)() const>(&StepVisual_TextStyle::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TextStyleForDefinedFont ,opencascade::handle<StepVisual_TextStyleForDefinedFont>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TextStyleForDefinedFont::*)(  const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_TextStyleForDefinedFont::*)(  const handle<StepVisual_Colour> &  ) >(&StepVisual_TextStyleForDefinedFont::Init),
             R"#()#"  , py::arg("aTextColour")
          )
        .def("SetTextColour",
             (void (StepVisual_TextStyleForDefinedFont::*)(  const handle<StepVisual_Colour> &  ) ) static_cast<void (StepVisual_TextStyleForDefinedFont::*)(  const handle<StepVisual_Colour> &  ) >(&StepVisual_TextStyleForDefinedFont::SetTextColour),
             R"#()#"  , py::arg("aTextColour")
          )
        .def("TextColour",
             (handle<StepVisual_Colour> (StepVisual_TextStyleForDefinedFont::*)() const) static_cast<handle<StepVisual_Colour> (StepVisual_TextStyleForDefinedFont::*)() const>(&StepVisual_TextStyleForDefinedFont::TextColour),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TextStyleForDefinedFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TextStyleForDefinedFont::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> & (StepVisual_TextStyleForDefinedFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TextStyleForDefinedFont::*)() const>(&StepVisual_TextStyleForDefinedFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ViewVolume ,opencascade::handle<StepVisual_ViewVolume>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ViewVolume::*)(  const StepVisual_CentralOrParallel ,   const handle<StepGeom_CartesianPoint> & ,   const Standard_Real ,   const Standard_Real ,   const Standard_Boolean ,   const Standard_Real ,   const Standard_Boolean ,   const Standard_Boolean ,   const handle<StepVisual_PlanarBox> &  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const StepVisual_CentralOrParallel ,   const handle<StepGeom_CartesianPoint> & ,   const Standard_Real ,   const Standard_Real ,   const Standard_Boolean ,   const Standard_Real ,   const Standard_Boolean ,   const Standard_Boolean ,   const handle<StepVisual_PlanarBox> &  ) >(&StepVisual_ViewVolume::Init),
             R"#()#"  , py::arg("aProjectionType"),  py::arg("aProjectionPoint"),  py::arg("aViewPlaneDistance"),  py::arg("aFrontPlaneDistance"),  py::arg("aFrontPlaneClipping"),  py::arg("aBackPlaneDistance"),  py::arg("aBackPlaneClipping"),  py::arg("aViewVolumeSidesClipping"),  py::arg("aViewWindow")
          )
        .def("SetProjectionType",
             (void (StepVisual_ViewVolume::*)(  const StepVisual_CentralOrParallel  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const StepVisual_CentralOrParallel  ) >(&StepVisual_ViewVolume::SetProjectionType),
             R"#()#"  , py::arg("aProjectionType")
          )
        .def("ProjectionType",
             (StepVisual_CentralOrParallel (StepVisual_ViewVolume::*)() const) static_cast<StepVisual_CentralOrParallel (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::ProjectionType),
             R"#()#" 
          )
        .def("SetProjectionPoint",
             (void (StepVisual_ViewVolume::*)(  const handle<StepGeom_CartesianPoint> &  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const handle<StepGeom_CartesianPoint> &  ) >(&StepVisual_ViewVolume::SetProjectionPoint),
             R"#()#"  , py::arg("aProjectionPoint")
          )
        .def("ProjectionPoint",
             (handle<StepGeom_CartesianPoint> (StepVisual_ViewVolume::*)() const) static_cast<handle<StepGeom_CartesianPoint> (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::ProjectionPoint),
             R"#()#" 
          )
        .def("SetViewPlaneDistance",
             (void (StepVisual_ViewVolume::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const Standard_Real  ) >(&StepVisual_ViewVolume::SetViewPlaneDistance),
             R"#()#"  , py::arg("aViewPlaneDistance")
          )
        .def("ViewPlaneDistance",
             (Standard_Real (StepVisual_ViewVolume::*)() const) static_cast<Standard_Real (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::ViewPlaneDistance),
             R"#()#" 
          )
        .def("SetFrontPlaneDistance",
             (void (StepVisual_ViewVolume::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const Standard_Real  ) >(&StepVisual_ViewVolume::SetFrontPlaneDistance),
             R"#()#"  , py::arg("aFrontPlaneDistance")
          )
        .def("FrontPlaneDistance",
             (Standard_Real (StepVisual_ViewVolume::*)() const) static_cast<Standard_Real (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::FrontPlaneDistance),
             R"#()#" 
          )
        .def("SetFrontPlaneClipping",
             (void (StepVisual_ViewVolume::*)(  const Standard_Boolean  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const Standard_Boolean  ) >(&StepVisual_ViewVolume::SetFrontPlaneClipping),
             R"#()#"  , py::arg("aFrontPlaneClipping")
          )
        .def("FrontPlaneClipping",
             (Standard_Boolean (StepVisual_ViewVolume::*)() const) static_cast<Standard_Boolean (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::FrontPlaneClipping),
             R"#()#" 
          )
        .def("SetBackPlaneDistance",
             (void (StepVisual_ViewVolume::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const Standard_Real  ) >(&StepVisual_ViewVolume::SetBackPlaneDistance),
             R"#()#"  , py::arg("aBackPlaneDistance")
          )
        .def("BackPlaneDistance",
             (Standard_Real (StepVisual_ViewVolume::*)() const) static_cast<Standard_Real (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::BackPlaneDistance),
             R"#()#" 
          )
        .def("SetBackPlaneClipping",
             (void (StepVisual_ViewVolume::*)(  const Standard_Boolean  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const Standard_Boolean  ) >(&StepVisual_ViewVolume::SetBackPlaneClipping),
             R"#()#"  , py::arg("aBackPlaneClipping")
          )
        .def("BackPlaneClipping",
             (Standard_Boolean (StepVisual_ViewVolume::*)() const) static_cast<Standard_Boolean (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::BackPlaneClipping),
             R"#()#" 
          )
        .def("SetViewVolumeSidesClipping",
             (void (StepVisual_ViewVolume::*)(  const Standard_Boolean  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const Standard_Boolean  ) >(&StepVisual_ViewVolume::SetViewVolumeSidesClipping),
             R"#()#"  , py::arg("aViewVolumeSidesClipping")
          )
        .def("ViewVolumeSidesClipping",
             (Standard_Boolean (StepVisual_ViewVolume::*)() const) static_cast<Standard_Boolean (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::ViewVolumeSidesClipping),
             R"#()#" 
          )
        .def("SetViewWindow",
             (void (StepVisual_ViewVolume::*)(  const handle<StepVisual_PlanarBox> &  ) ) static_cast<void (StepVisual_ViewVolume::*)(  const handle<StepVisual_PlanarBox> &  ) >(&StepVisual_ViewVolume::SetViewWindow),
             R"#()#"  , py::arg("aViewWindow")
          )
        .def("ViewWindow",
             (handle<StepVisual_PlanarBox> (StepVisual_ViewVolume::*)() const) static_cast<handle<StepVisual_PlanarBox> (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::ViewWindow),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_ViewVolume::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ViewVolume::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> & (StepVisual_ViewVolume::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ViewVolume::*)() const>(&StepVisual_ViewVolume::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationOccurrence ,opencascade::handle<StepVisual_AnnotationOccurrence>  , StepVisual_StyledItem >>(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 * (*)() >(&StepVisual_AnnotationOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationOccurrence::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> & (StepVisual_AnnotationOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationOccurrence::*)() const>(&StepVisual_AnnotationOccurrence::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_BackgroundColour ,opencascade::handle<StepVisual_BackgroundColour>  , StepVisual_Colour >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_BackgroundColour::*)(  const StepVisual_AreaOrView &  ) ) static_cast<void (StepVisual_BackgroundColour::*)(  const StepVisual_AreaOrView &  ) >(&StepVisual_BackgroundColour::Init),
             R"#()#"  , py::arg("aPresentation")
          )
        .def("SetPresentation",
             (void (StepVisual_BackgroundColour::*)(  const StepVisual_AreaOrView &  ) ) static_cast<void (StepVisual_BackgroundColour::*)(  const StepVisual_AreaOrView &  ) >(&StepVisual_BackgroundColour::SetPresentation),
             R"#()#"  , py::arg("aPresentation")
          )
        .def("Presentation",
             (StepVisual_AreaOrView (StepVisual_BackgroundColour::*)() const) static_cast<StepVisual_AreaOrView (StepVisual_BackgroundColour::*)() const>(&StepVisual_BackgroundColour::Presentation),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_BackgroundColour::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_BackgroundColour::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> & (StepVisual_BackgroundColour::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_BackgroundColour::*)() const>(&StepVisual_BackgroundColour::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraImage2dWithScale ,opencascade::handle<StepVisual_CameraImage2dWithScale>  , StepVisual_CameraImage >>(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 * (*)() >(&StepVisual_CameraImage2dWithScale::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraImage2dWithScale::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> & (StepVisual_CameraImage2dWithScale::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraImage2dWithScale::*)() const>(&StepVisual_CameraImage2dWithScale::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraImage3dWithScale ,opencascade::handle<StepVisual_CameraImage3dWithScale>  , StepVisual_CameraImage >>(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 * (*)() >(&StepVisual_CameraImage3dWithScale::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraImage3dWithScale::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> & (StepVisual_CameraImage3dWithScale::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraImage3dWithScale::*)() const>(&StepVisual_CameraImage3dWithScale::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD2 ,opencascade::handle<StepVisual_CameraModelD2>  , StepVisual_CameraModel >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CameraModelD2::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_PlanarBox> & ,   const Standard_Boolean  ) ) static_cast<void (StepVisual_CameraModelD2::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_PlanarBox> & ,   const Standard_Boolean  ) >(&StepVisual_CameraModelD2::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aViewWindow"),  py::arg("aViewWindowClipping")
          )
        .def("SetViewWindow",
             (void (StepVisual_CameraModelD2::*)(  const handle<StepVisual_PlanarBox> &  ) ) static_cast<void (StepVisual_CameraModelD2::*)(  const handle<StepVisual_PlanarBox> &  ) >(&StepVisual_CameraModelD2::SetViewWindow),
             R"#()#"  , py::arg("aViewWindow")
          )
        .def("ViewWindow",
             (handle<StepVisual_PlanarBox> (StepVisual_CameraModelD2::*)() const) static_cast<handle<StepVisual_PlanarBox> (StepVisual_CameraModelD2::*)() const>(&StepVisual_CameraModelD2::ViewWindow),
             R"#()#" 
          )
        .def("SetViewWindowClipping",
             (void (StepVisual_CameraModelD2::*)(  const Standard_Boolean  ) ) static_cast<void (StepVisual_CameraModelD2::*)(  const Standard_Boolean  ) >(&StepVisual_CameraModelD2::SetViewWindowClipping),
             R"#()#"  , py::arg("aViewWindowClipping")
          )
        .def("ViewWindowClipping",
             (Standard_Boolean (StepVisual_CameraModelD2::*)() const) static_cast<Standard_Boolean (StepVisual_CameraModelD2::*)() const>(&StepVisual_CameraModelD2::ViewWindowClipping),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CameraModelD2::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraModelD2::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> & (StepVisual_CameraModelD2::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraModelD2::*)() const>(&StepVisual_CameraModelD2::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD3 ,opencascade::handle<StepVisual_CameraModelD3>  , StepVisual_CameraModel >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CameraModelD3::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepGeom_Axis2Placement3d> & ,   const handle<StepVisual_ViewVolume> &  ) ) static_cast<void (StepVisual_CameraModelD3::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepGeom_Axis2Placement3d> & ,   const handle<StepVisual_ViewVolume> &  ) >(&StepVisual_CameraModelD3::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aViewReferenceSystem"),  py::arg("aPerspectiveOfVolume")
          )
        .def("SetViewReferenceSystem",
             (void (StepVisual_CameraModelD3::*)(  const handle<StepGeom_Axis2Placement3d> &  ) ) static_cast<void (StepVisual_CameraModelD3::*)(  const handle<StepGeom_Axis2Placement3d> &  ) >(&StepVisual_CameraModelD3::SetViewReferenceSystem),
             R"#()#"  , py::arg("aViewReferenceSystem")
          )
        .def("ViewReferenceSystem",
             (handle<StepGeom_Axis2Placement3d> (StepVisual_CameraModelD3::*)() const) static_cast<handle<StepGeom_Axis2Placement3d> (StepVisual_CameraModelD3::*)() const>(&StepVisual_CameraModelD3::ViewReferenceSystem),
             R"#()#" 
          )
        .def("SetPerspectiveOfVolume",
             (void (StepVisual_CameraModelD3::*)(  const handle<StepVisual_ViewVolume> &  ) ) static_cast<void (StepVisual_CameraModelD3::*)(  const handle<StepVisual_ViewVolume> &  ) >(&StepVisual_CameraModelD3::SetPerspectiveOfVolume),
             R"#()#"  , py::arg("aPerspectiveOfVolume")
          )
        .def("PerspectiveOfVolume",
             (handle<StepVisual_ViewVolume> (StepVisual_CameraModelD3::*)() const) static_cast<handle<StepVisual_ViewVolume> (StepVisual_CameraModelD3::*)() const>(&StepVisual_CameraModelD3::PerspectiveOfVolume),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CameraModelD3::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraModelD3::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> & (StepVisual_CameraModelD3::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraModelD3::*)() const>(&StepVisual_CameraModelD3::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel ,opencascade::handle<StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel>  , StepVisual_DraughtingModel >>(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 * (*)() >(&StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel::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> & (StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel::*)() const>(&StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ColourSpecification ,opencascade::handle<StepVisual_ColourSpecification>  , StepVisual_Colour >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ColourSpecification::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_ColourSpecification::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_ColourSpecification::Init),
             R"#()#"  , py::arg("aName")
          )
        .def("SetName",
             (void (StepVisual_ColourSpecification::*)(  const handle<TCollection_HAsciiString> &  ) ) static_cast<void (StepVisual_ColourSpecification::*)(  const handle<TCollection_HAsciiString> &  ) >(&StepVisual_ColourSpecification::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (handle<TCollection_HAsciiString> (StepVisual_ColourSpecification::*)() const) static_cast<handle<TCollection_HAsciiString> (StepVisual_ColourSpecification::*)() const>(&StepVisual_ColourSpecification::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 * (*)() >(&StepVisual_ColourSpecification::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ColourSpecification::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> & (StepVisual_ColourSpecification::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ColourSpecification::*)() const>(&StepVisual_ColourSpecification::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CompositeTextWithExtent ,opencascade::handle<StepVisual_CompositeTextWithExtent>  , StepVisual_CompositeText >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CompositeTextWithExtent::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTextOrCharacter> & ,   const handle<StepVisual_PlanarExtent> &  ) ) static_cast<void (StepVisual_CompositeTextWithExtent::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTextOrCharacter> & ,   const handle<StepVisual_PlanarExtent> &  ) >(&StepVisual_CompositeTextWithExtent::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aCollectedText"),  py::arg("aExtent")
          )
        .def("SetExtent",
             (void (StepVisual_CompositeTextWithExtent::*)(  const handle<StepVisual_PlanarExtent> &  ) ) static_cast<void (StepVisual_CompositeTextWithExtent::*)(  const handle<StepVisual_PlanarExtent> &  ) >(&StepVisual_CompositeTextWithExtent::SetExtent),
             R"#()#"  , py::arg("aExtent")
          )
        .def("Extent",
             (handle<StepVisual_PlanarExtent> (StepVisual_CompositeTextWithExtent::*)() const) static_cast<handle<StepVisual_PlanarExtent> (StepVisual_CompositeTextWithExtent::*)() const>(&StepVisual_CompositeTextWithExtent::Extent),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CompositeTextWithExtent::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CompositeTextWithExtent::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> & (StepVisual_CompositeTextWithExtent::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CompositeTextWithExtent::*)() const>(&StepVisual_CompositeTextWithExtent::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ContextDependentInvisibility ,opencascade::handle<StepVisual_ContextDependentInvisibility>  , StepVisual_Invisibility >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ContextDependentInvisibility::*)(  const handle<StepVisual_HArray1OfInvisibleItem> & ,   const StepVisual_InvisibilityContext &  ) ) static_cast<void (StepVisual_ContextDependentInvisibility::*)(  const handle<StepVisual_HArray1OfInvisibleItem> & ,   const StepVisual_InvisibilityContext &  ) >(&StepVisual_ContextDependentInvisibility::Init),
             R"#()#"  , py::arg("aInvisibleItems"),  py::arg("aPresentationContext")
          )
        .def("SetPresentationContext",
             (void (StepVisual_ContextDependentInvisibility::*)(  const StepVisual_InvisibilityContext &  ) ) static_cast<void (StepVisual_ContextDependentInvisibility::*)(  const StepVisual_InvisibilityContext &  ) >(&StepVisual_ContextDependentInvisibility::SetPresentationContext),
             R"#()#"  , py::arg("aPresentationContext")
          )
        .def("PresentationContext",
             (StepVisual_InvisibilityContext (StepVisual_ContextDependentInvisibility::*)() const) static_cast<StepVisual_InvisibilityContext (StepVisual_ContextDependentInvisibility::*)() const>(&StepVisual_ContextDependentInvisibility::PresentationContext),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_ContextDependentInvisibility::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ContextDependentInvisibility::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> & (StepVisual_ContextDependentInvisibility::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ContextDependentInvisibility::*)() const>(&StepVisual_ContextDependentInvisibility::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CoordinatesList ,opencascade::handle<StepVisual_CoordinatesList>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CoordinatesList::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TColgp_HArray1OfXYZ> &  ) ) static_cast<void (StepVisual_CoordinatesList::*)(  const handle<TCollection_HAsciiString> & ,   const handle<TColgp_HArray1OfXYZ> &  ) >(&StepVisual_CoordinatesList::Init),
             R"#()#"  , py::arg("theName"),  py::arg("thePoints")
          )
        .def("Points",
             (handle<TColgp_HArray1OfXYZ> (StepVisual_CoordinatesList::*)() const) static_cast<handle<TColgp_HArray1OfXYZ> (StepVisual_CoordinatesList::*)() const>(&StepVisual_CoordinatesList::Points),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CoordinatesList::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CoordinatesList::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> & (StepVisual_CoordinatesList::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CoordinatesList::*)() const>(&StepVisual_CoordinatesList::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_MechanicalDesignGeometricPresentationRepresentation ,opencascade::handle<StepVisual_MechanicalDesignGeometricPresentationRepresentation>  , StepVisual_PresentationRepresentation >>(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 * (*)() >(&StepVisual_MechanicalDesignGeometricPresentationRepresentation::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_MechanicalDesignGeometricPresentationRepresentation::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> & (StepVisual_MechanicalDesignGeometricPresentationRepresentation::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_MechanicalDesignGeometricPresentationRepresentation::*)() const>(&StepVisual_MechanicalDesignGeometricPresentationRepresentation::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_OverRidingStyledItem ,opencascade::handle<StepVisual_OverRidingStyledItem>  , StepVisual_StyledItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_OverRidingStyledItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepVisual_StyledItem> &  ) ) static_cast<void (StepVisual_OverRidingStyledItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepVisual_StyledItem> &  ) >(&StepVisual_OverRidingStyledItem::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aStyles"),  py::arg("aItem"),  py::arg("aOverRiddenStyle")
          )
        .def("SetOverRiddenStyle",
             (void (StepVisual_OverRidingStyledItem::*)(  const handle<StepVisual_StyledItem> &  ) ) static_cast<void (StepVisual_OverRidingStyledItem::*)(  const handle<StepVisual_StyledItem> &  ) >(&StepVisual_OverRidingStyledItem::SetOverRiddenStyle),
             R"#()#"  , py::arg("aOverRiddenStyle")
          )
        .def("OverRiddenStyle",
             (handle<StepVisual_StyledItem> (StepVisual_OverRidingStyledItem::*)() const) static_cast<handle<StepVisual_StyledItem> (StepVisual_OverRidingStyledItem::*)() const>(&StepVisual_OverRidingStyledItem::OverRiddenStyle),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_OverRidingStyledItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_OverRidingStyledItem::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> & (StepVisual_OverRidingStyledItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_OverRidingStyledItem::*)() const>(&StepVisual_OverRidingStyledItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PlanarBox ,opencascade::handle<StepVisual_PlanarBox>  , StepVisual_PlanarExtent >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PlanarBox::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real ,   const Standard_Real ,   const StepGeom_Axis2Placement &  ) ) static_cast<void (StepVisual_PlanarBox::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real ,   const Standard_Real ,   const StepGeom_Axis2Placement &  ) >(&StepVisual_PlanarBox::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aSizeInX"),  py::arg("aSizeInY"),  py::arg("aPlacement")
          )
        .def("SetPlacement",
             (void (StepVisual_PlanarBox::*)(  const StepGeom_Axis2Placement &  ) ) static_cast<void (StepVisual_PlanarBox::*)(  const StepGeom_Axis2Placement &  ) >(&StepVisual_PlanarBox::SetPlacement),
             R"#()#"  , py::arg("aPlacement")
          )
        .def("Placement",
             (StepGeom_Axis2Placement (StepVisual_PlanarBox::*)() const) static_cast<StepGeom_Axis2Placement (StepVisual_PlanarBox::*)() const>(&StepVisual_PlanarBox::Placement),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PlanarBox::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PlanarBox::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> & (StepVisual_PlanarBox::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PlanarBox::*)() const>(&StepVisual_PlanarBox::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PreDefinedColour ,opencascade::handle<StepVisual_PreDefinedColour>  , StepVisual_Colour >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetPreDefinedItem",
             (void (StepVisual_PreDefinedColour::*)(  const handle<StepVisual_PreDefinedItem> &  ) ) static_cast<void (StepVisual_PreDefinedColour::*)(  const handle<StepVisual_PreDefinedItem> &  ) >(&StepVisual_PreDefinedColour::SetPreDefinedItem),
             R"#(set a pre_defined_item part)#"  , py::arg("item")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PreDefinedColour::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PreDefinedColour::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("GetPreDefinedItem",
             ( const handle<StepVisual_PreDefinedItem> & (StepVisual_PreDefinedColour::*)() const) static_cast< const handle<StepVisual_PreDefinedItem> & (StepVisual_PreDefinedColour::*)() const>(&StepVisual_PreDefinedColour::GetPreDefinedItem),
             R"#(return a pre_defined_item part)#"
             
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (StepVisual_PreDefinedColour::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PreDefinedColour::*)() const>(&StepVisual_PreDefinedColour::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PreDefinedCurveFont ,opencascade::handle<StepVisual_PreDefinedCurveFont>  , StepVisual_PreDefinedItem >>(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 * (*)() >(&StepVisual_PreDefinedCurveFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PreDefinedCurveFont::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> & (StepVisual_PreDefinedCurveFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PreDefinedCurveFont::*)() const>(&StepVisual_PreDefinedCurveFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PreDefinedTextFont ,opencascade::handle<StepVisual_PreDefinedTextFont>  , StepVisual_PreDefinedItem >>(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 * (*)() >(&StepVisual_PreDefinedTextFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PreDefinedTextFont::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> & (StepVisual_PreDefinedTextFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PreDefinedTextFont::*)() const>(&StepVisual_PreDefinedTextFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationArea ,opencascade::handle<StepVisual_PresentationArea>  , StepVisual_PresentationRepresentation >>(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 * (*)() >(&StepVisual_PresentationArea::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationArea::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> & (StepVisual_PresentationArea::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationArea::*)() const>(&StepVisual_PresentationArea::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationStyleByContext ,opencascade::handle<StepVisual_PresentationStyleByContext>  , StepVisual_PresentationStyleAssignment >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_PresentationStyleByContext::*)(  const handle<StepVisual_HArray1OfPresentationStyleSelect> & ,   const StepVisual_StyleContextSelect &  ) ) static_cast<void (StepVisual_PresentationStyleByContext::*)(  const handle<StepVisual_HArray1OfPresentationStyleSelect> & ,   const StepVisual_StyleContextSelect &  ) >(&StepVisual_PresentationStyleByContext::Init),
             R"#()#"  , py::arg("aStyles"),  py::arg("aStyleContext")
          )
        .def("SetStyleContext",
             (void (StepVisual_PresentationStyleByContext::*)(  const StepVisual_StyleContextSelect &  ) ) static_cast<void (StepVisual_PresentationStyleByContext::*)(  const StepVisual_StyleContextSelect &  ) >(&StepVisual_PresentationStyleByContext::SetStyleContext),
             R"#()#"  , py::arg("aStyleContext")
          )
        .def("StyleContext",
             (StepVisual_StyleContextSelect (StepVisual_PresentationStyleByContext::*)() const) static_cast<StepVisual_StyleContextSelect (StepVisual_PresentationStyleByContext::*)() const>(&StepVisual_PresentationStyleByContext::StyleContext),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_PresentationStyleByContext::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationStyleByContext::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> & (StepVisual_PresentationStyleByContext::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationStyleByContext::*)() const>(&StepVisual_PresentationStyleByContext::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_PresentationView ,opencascade::handle<StepVisual_PresentationView>  , StepVisual_PresentationRepresentation >>(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 * (*)() >(&StepVisual_PresentationView::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_PresentationView::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> & (StepVisual_PresentationView::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_PresentationView::*)() const>(&StepVisual_PresentationView::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_RepositionedTessellatedItem ,opencascade::handle<StepVisual_RepositionedTessellatedItem>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_RepositionedTessellatedItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepGeom_Axis2Placement3d> &  ) ) static_cast<void (StepVisual_RepositionedTessellatedItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepGeom_Axis2Placement3d> &  ) >(&StepVisual_RepositionedTessellatedItem::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theName"),  py::arg("theLocation")
          )
        .def("Location",
             (handle<StepGeom_Axis2Placement3d> (StepVisual_RepositionedTessellatedItem::*)() const) static_cast<handle<StepGeom_Axis2Placement3d> (StepVisual_RepositionedTessellatedItem::*)() const>(&StepVisual_RepositionedTessellatedItem::Location),
             R"#(Returns location)#" 
          )
        .def("SetLocation",
             (void (StepVisual_RepositionedTessellatedItem::*)(  const handle<StepGeom_Axis2Placement3d> &  ) ) static_cast<void (StepVisual_RepositionedTessellatedItem::*)(  const handle<StepGeom_Axis2Placement3d> &  ) >(&StepVisual_RepositionedTessellatedItem::SetLocation),
             R"#(Sets location)#"  , py::arg("theLocation")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_RepositionedTessellatedItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_RepositionedTessellatedItem::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> & (StepVisual_RepositionedTessellatedItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_RepositionedTessellatedItem::*)() const>(&StepVisual_RepositionedTessellatedItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_SurfaceStyleRenderingWithProperties ,opencascade::handle<StepVisual_SurfaceStyleRenderingWithProperties>  , StepVisual_SurfaceStyleRendering >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_SurfaceStyleRenderingWithProperties::*)(  const StepVisual_ShadingSurfaceMethod ,   const handle<StepVisual_Colour> & ,   const handle<StepVisual_HArray1OfRenderingPropertiesSelect> &  ) ) static_cast<void (StepVisual_SurfaceStyleRenderingWithProperties::*)(  const StepVisual_ShadingSurfaceMethod ,   const handle<StepVisual_Colour> & ,   const handle<StepVisual_HArray1OfRenderingPropertiesSelect> &  ) >(&StepVisual_SurfaceStyleRenderingWithProperties::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theSurfaceStyleRendering_RenderingMethod"),  py::arg("theSurfaceStyleRendering_SurfaceColour"),  py::arg("theProperties")
          )
        .def("Properties",
             (handle<StepVisual_HArray1OfRenderingPropertiesSelect> (StepVisual_SurfaceStyleRenderingWithProperties::*)() const) static_cast<handle<StepVisual_HArray1OfRenderingPropertiesSelect> (StepVisual_SurfaceStyleRenderingWithProperties::*)() const>(&StepVisual_SurfaceStyleRenderingWithProperties::Properties),
             R"#(Returns field Properties)#" 
          )
        .def("SetProperties",
             (void (StepVisual_SurfaceStyleRenderingWithProperties::*)(  const handle<StepVisual_HArray1OfRenderingPropertiesSelect> &  ) ) static_cast<void (StepVisual_SurfaceStyleRenderingWithProperties::*)(  const handle<StepVisual_HArray1OfRenderingPropertiesSelect> &  ) >(&StepVisual_SurfaceStyleRenderingWithProperties::SetProperties),
             R"#(Sets field Properties)#"  , py::arg("theProperties")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_SurfaceStyleRenderingWithProperties::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_SurfaceStyleRenderingWithProperties::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> & (StepVisual_SurfaceStyleRenderingWithProperties::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_SurfaceStyleRenderingWithProperties::*)() const>(&StepVisual_SurfaceStyleRenderingWithProperties::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedAnnotationOccurrence ,opencascade::handle<StepVisual_TessellatedAnnotationOccurrence>  , StepVisual_StyledItem >>(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 * (*)() >(&StepVisual_TessellatedAnnotationOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedAnnotationOccurrence::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> & (StepVisual_TessellatedAnnotationOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedAnnotationOccurrence::*)() const>(&StepVisual_TessellatedAnnotationOccurrence::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedCurveSet ,opencascade::handle<StepVisual_TessellatedCurveSet>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedCurveSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> &  ) ) static_cast<void (StepVisual_TessellatedCurveSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> &  ) >(&StepVisual_TessellatedCurveSet::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theCoordList"),  py::arg("theCurves")
          )
        .def("CoordList",
             (handle<StepVisual_CoordinatesList> (StepVisual_TessellatedCurveSet::*)() const) static_cast<handle<StepVisual_CoordinatesList> (StepVisual_TessellatedCurveSet::*)() const>(&StepVisual_TessellatedCurveSet::CoordList),
             R"#()#" 
          )
        .def("Curves",
             (NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> (StepVisual_TessellatedCurveSet::*)() const) static_cast<NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> (StepVisual_TessellatedCurveSet::*)() const>(&StepVisual_TessellatedCurveSet::Curves),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedCurveSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedCurveSet::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> & (StepVisual_TessellatedCurveSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedCurveSet::*)() const>(&StepVisual_TessellatedCurveSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedGeometricSet ,opencascade::handle<StepVisual_TessellatedGeometricSet>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedGeometricSet::*)(  const handle<TCollection_HAsciiString> & ,   const NCollection_Handle<StepVisual_Array1OfTessellatedItem> &  ) ) static_cast<void (StepVisual_TessellatedGeometricSet::*)(  const handle<TCollection_HAsciiString> & ,   const NCollection_Handle<StepVisual_Array1OfTessellatedItem> &  ) >(&StepVisual_TessellatedGeometricSet::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theItems")
          )
        .def("Items",
             (NCollection_Handle<StepVisual_Array1OfTessellatedItem> (StepVisual_TessellatedGeometricSet::*)() const) static_cast<NCollection_Handle<StepVisual_Array1OfTessellatedItem> (StepVisual_TessellatedGeometricSet::*)() const>(&StepVisual_TessellatedGeometricSet::Items),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedGeometricSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedGeometricSet::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> & (StepVisual_TessellatedGeometricSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedGeometricSet::*)() const>(&StepVisual_TessellatedGeometricSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedPointSet ,opencascade::handle<StepVisual_TessellatedPointSet>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedPointSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedPointSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedPointSet::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theCoordinates"),  py::arg("thePointList")
          )
        .def("Coordinates",
             (handle<StepVisual_CoordinatesList> (StepVisual_TessellatedPointSet::*)() const) static_cast<handle<StepVisual_CoordinatesList> (StepVisual_TessellatedPointSet::*)() const>(&StepVisual_TessellatedPointSet::Coordinates),
             R"#(Returns field Coordinates)#" 
          )
        .def("SetCoordinates",
             (void (StepVisual_TessellatedPointSet::*)(  const handle<StepVisual_CoordinatesList> &  ) ) static_cast<void (StepVisual_TessellatedPointSet::*)(  const handle<StepVisual_CoordinatesList> &  ) >(&StepVisual_TessellatedPointSet::SetCoordinates),
             R"#(Sets field Coordinates)#"  , py::arg("theCoordinates")
          )
        .def("PointList",
             (handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedPointSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedPointSet::*)() const>(&StepVisual_TessellatedPointSet::PointList),
             R"#(Returns field PointList)#" 
          )
        .def("SetPointList",
             (void (StepVisual_TessellatedPointSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedPointSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedPointSet::SetPointList),
             R"#(Sets field PointList)#"  , py::arg("thePointList")
          )
        .def("NbPointList",
             (Standard_Integer (StepVisual_TessellatedPointSet::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedPointSet::*)() const>(&StepVisual_TessellatedPointSet::NbPointList),
             R"#(Returns number of PointList)#" 
          )
        .def("PointListValue",
             (Standard_Integer (StepVisual_TessellatedPointSet::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_TessellatedPointSet::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedPointSet::PointListValue),
             R"#(Returns value of PointList by its num)#"  , py::arg("theNum")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedPointSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedPointSet::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> & (StepVisual_TessellatedPointSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedPointSet::*)() const>(&StepVisual_TessellatedPointSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedShapeRepresentationWithAccuracyParameters ,opencascade::handle<StepVisual_TessellatedShapeRepresentationWithAccuracyParameters>  , StepVisual_TessellatedShapeRepresentation >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> & ,   const handle<StepRepr_RepresentationContext> & ,   const handle<TColStd_HArray1OfReal> &  ) ) static_cast<void (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepRepr_HArray1OfRepresentationItem> & ,   const handle<StepRepr_RepresentationContext> & ,   const handle<TColStd_HArray1OfReal> &  ) >(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentation_Name"),  py::arg("theRepresentation_Items"),  py::arg("theRepresentation_ContextOfItems"),  py::arg("theTessellationAccuracyParameters")
          )
        .def("TessellationAccuracyParameters",
             (handle<TColStd_HArray1OfReal> (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)() const) static_cast<handle<TColStd_HArray1OfReal> (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)() const>(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::TessellationAccuracyParameters),
             R"#(Returns field TessellationAccuracyParameters)#" 
          )
        .def("SetTessellationAccuracyParameters",
             (void (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)(  const handle<TColStd_HArray1OfReal> &  ) ) static_cast<void (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)(  const handle<TColStd_HArray1OfReal> &  ) >(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::SetTessellationAccuracyParameters),
             R"#(Sets field TessellationAccuracyParameters)#"  , py::arg("theTessellationAccuracyParameters")
          )
        .def("NbTessellationAccuracyParameters",
             (Standard_Integer (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)() const>(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::NbTessellationAccuracyParameters),
             R"#(Returns number of TessellationAccuracyParameters)#" 
          )
        .def("TessellationAccuracyParametersValue",
             ( const Standard_Real & (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)(  const Standard_Integer  ) const) static_cast< const Standard_Real & (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::TessellationAccuracyParametersValue),
             R"#(Returns value of TessellationAccuracyParameters by its num)#"  , py::arg("theNum")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::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> & (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::*)() const>(&StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedShell ,opencascade::handle<StepVisual_TessellatedShell>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedShell::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTessellatedStructuredItem> & ,   const Standard_Boolean ,   const handle<StepShape_ConnectedFaceSet> &  ) ) static_cast<void (StepVisual_TessellatedShell::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTessellatedStructuredItem> & ,   const Standard_Boolean ,   const handle<StepShape_ConnectedFaceSet> &  ) >(&StepVisual_TessellatedShell::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theItems"),  py::arg("theHasTopologicalLink"),  py::arg("theTopologicalLink")
          )
        .def("Items",
             (handle<StepVisual_HArray1OfTessellatedStructuredItem> (StepVisual_TessellatedShell::*)() const) static_cast<handle<StepVisual_HArray1OfTessellatedStructuredItem> (StepVisual_TessellatedShell::*)() const>(&StepVisual_TessellatedShell::Items),
             R"#(Returns field Items)#" 
          )
        .def("SetItems",
             (void (StepVisual_TessellatedShell::*)(  const handle<StepVisual_HArray1OfTessellatedStructuredItem> &  ) ) static_cast<void (StepVisual_TessellatedShell::*)(  const handle<StepVisual_HArray1OfTessellatedStructuredItem> &  ) >(&StepVisual_TessellatedShell::SetItems),
             R"#(Sets field Items)#"  , py::arg("theItems")
          )
        .def("NbItems",
             (Standard_Integer (StepVisual_TessellatedShell::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedShell::*)() const>(&StepVisual_TessellatedShell::NbItems),
             R"#(Returns number of Items)#" 
          )
        .def("ItemsValue",
             (handle<StepVisual_TessellatedStructuredItem> (StepVisual_TessellatedShell::*)(  const Standard_Integer  ) const) static_cast<handle<StepVisual_TessellatedStructuredItem> (StepVisual_TessellatedShell::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedShell::ItemsValue),
             R"#(Returns value of Items by its num)#"  , py::arg("theNum")
          )
        .def("TopologicalLink",
             (handle<StepShape_ConnectedFaceSet> (StepVisual_TessellatedShell::*)() const) static_cast<handle<StepShape_ConnectedFaceSet> (StepVisual_TessellatedShell::*)() const>(&StepVisual_TessellatedShell::TopologicalLink),
             R"#(Returns field TopologicalLink)#" 
          )
        .def("SetTopologicalLink",
             (void (StepVisual_TessellatedShell::*)(  const handle<StepShape_ConnectedFaceSet> &  ) ) static_cast<void (StepVisual_TessellatedShell::*)(  const handle<StepShape_ConnectedFaceSet> &  ) >(&StepVisual_TessellatedShell::SetTopologicalLink),
             R"#(Sets field TopologicalLink)#"  , py::arg("theTopologicalLink")
          )
        .def("HasTopologicalLink",
             (Standard_Boolean (StepVisual_TessellatedShell::*)() const) static_cast<Standard_Boolean (StepVisual_TessellatedShell::*)() const>(&StepVisual_TessellatedShell::HasTopologicalLink),
             R"#(Returns True if optional field TopologicalLink 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 * (*)() >(&StepVisual_TessellatedShell::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedShell::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> & (StepVisual_TessellatedShell::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedShell::*)() const>(&StepVisual_TessellatedShell::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedSolid ,opencascade::handle<StepVisual_TessellatedSolid>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedSolid::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTessellatedStructuredItem> & ,   const Standard_Boolean ,   const handle<StepShape_ManifoldSolidBrep> &  ) ) static_cast<void (StepVisual_TessellatedSolid::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTessellatedStructuredItem> & ,   const Standard_Boolean ,   const handle<StepShape_ManifoldSolidBrep> &  ) >(&StepVisual_TessellatedSolid::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theItems"),  py::arg("theHasGeometricLink"),  py::arg("theGeometricLink")
          )
        .def("Items",
             (handle<StepVisual_HArray1OfTessellatedStructuredItem> (StepVisual_TessellatedSolid::*)() const) static_cast<handle<StepVisual_HArray1OfTessellatedStructuredItem> (StepVisual_TessellatedSolid::*)() const>(&StepVisual_TessellatedSolid::Items),
             R"#(Returns field Items)#" 
          )
        .def("SetItems",
             (void (StepVisual_TessellatedSolid::*)(  const handle<StepVisual_HArray1OfTessellatedStructuredItem> &  ) ) static_cast<void (StepVisual_TessellatedSolid::*)(  const handle<StepVisual_HArray1OfTessellatedStructuredItem> &  ) >(&StepVisual_TessellatedSolid::SetItems),
             R"#(Sets field Items)#"  , py::arg("theItems")
          )
        .def("NbItems",
             (Standard_Integer (StepVisual_TessellatedSolid::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedSolid::*)() const>(&StepVisual_TessellatedSolid::NbItems),
             R"#(Returns number of Items)#" 
          )
        .def("ItemsValue",
             (handle<StepVisual_TessellatedStructuredItem> (StepVisual_TessellatedSolid::*)(  const Standard_Integer  ) const) static_cast<handle<StepVisual_TessellatedStructuredItem> (StepVisual_TessellatedSolid::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedSolid::ItemsValue),
             R"#(Returns value of Items by its num)#"  , py::arg("theNum")
          )
        .def("GeometricLink",
             (handle<StepShape_ManifoldSolidBrep> (StepVisual_TessellatedSolid::*)() const) static_cast<handle<StepShape_ManifoldSolidBrep> (StepVisual_TessellatedSolid::*)() const>(&StepVisual_TessellatedSolid::GeometricLink),
             R"#(Returns field GeometricLink)#" 
          )
        .def("SetGeometricLink",
             (void (StepVisual_TessellatedSolid::*)(  const handle<StepShape_ManifoldSolidBrep> &  ) ) static_cast<void (StepVisual_TessellatedSolid::*)(  const handle<StepShape_ManifoldSolidBrep> &  ) >(&StepVisual_TessellatedSolid::SetGeometricLink),
             R"#(Sets field GeometricLink)#"  , py::arg("theGeometricLink")
          )
        .def("HasGeometricLink",
             (Standard_Boolean (StepVisual_TessellatedSolid::*)() const) static_cast<Standard_Boolean (StepVisual_TessellatedSolid::*)() const>(&StepVisual_TessellatedSolid::HasGeometricLink),
             R"#(Returns True if optional field GeometricLink 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 * (*)() >(&StepVisual_TessellatedSolid::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedSolid::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> & (StepVisual_TessellatedSolid::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedSolid::*)() const>(&StepVisual_TessellatedSolid::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedStructuredItem ,opencascade::handle<StepVisual_TessellatedStructuredItem>  , StepVisual_TessellatedItem >>(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 * (*)() >(&StepVisual_TessellatedStructuredItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedStructuredItem::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> & (StepVisual_TessellatedStructuredItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedStructuredItem::*)() const>(&StepVisual_TessellatedStructuredItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedSurfaceSet ,opencascade::handle<StepVisual_TessellatedSurfaceSet>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedSurfaceSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> &  ) ) static_cast<void (StepVisual_TessellatedSurfaceSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> &  ) >(&StepVisual_TessellatedSurfaceSet::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theCoordinates"),  py::arg("thePnmax"),  py::arg("theNormals")
          )
        .def("Coordinates",
             (handle<StepVisual_CoordinatesList> (StepVisual_TessellatedSurfaceSet::*)() const) static_cast<handle<StepVisual_CoordinatesList> (StepVisual_TessellatedSurfaceSet::*)() const>(&StepVisual_TessellatedSurfaceSet::Coordinates),
             R"#(Returns field Coordinates)#" 
          )
        .def("SetCoordinates",
             (void (StepVisual_TessellatedSurfaceSet::*)(  const handle<StepVisual_CoordinatesList> &  ) ) static_cast<void (StepVisual_TessellatedSurfaceSet::*)(  const handle<StepVisual_CoordinatesList> &  ) >(&StepVisual_TessellatedSurfaceSet::SetCoordinates),
             R"#(Sets field Coordinates)#"  , py::arg("theCoordinates")
          )
        .def("Pnmax",
             (Standard_Integer (StepVisual_TessellatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedSurfaceSet::*)() const>(&StepVisual_TessellatedSurfaceSet::Pnmax),
             R"#(Returns field Pnmax)#" 
          )
        .def("SetPnmax",
             (void (StepVisual_TessellatedSurfaceSet::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_TessellatedSurfaceSet::*)(  const Standard_Integer  ) >(&StepVisual_TessellatedSurfaceSet::SetPnmax),
             R"#(Sets field Pnmax)#"  , py::arg("thePnmax")
          )
        .def("Normals",
             (handle<TColStd_HArray2OfReal> (StepVisual_TessellatedSurfaceSet::*)() const) static_cast<handle<TColStd_HArray2OfReal> (StepVisual_TessellatedSurfaceSet::*)() const>(&StepVisual_TessellatedSurfaceSet::Normals),
             R"#(Returns field Normals)#" 
          )
        .def("SetNormals",
             (void (StepVisual_TessellatedSurfaceSet::*)(  const handle<TColStd_HArray2OfReal> &  ) ) static_cast<void (StepVisual_TessellatedSurfaceSet::*)(  const handle<TColStd_HArray2OfReal> &  ) >(&StepVisual_TessellatedSurfaceSet::SetNormals),
             R"#(Sets field Normals)#"  , py::arg("theNormals")
          )
        .def("NbNormals",
             (Standard_Integer (StepVisual_TessellatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedSurfaceSet::*)() const>(&StepVisual_TessellatedSurfaceSet::NbNormals),
             R"#(Returns number of Normals)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedSurfaceSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedSurfaceSet::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> & (StepVisual_TessellatedSurfaceSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedSurfaceSet::*)() const>(&StepVisual_TessellatedSurfaceSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedWire ,opencascade::handle<StepVisual_TessellatedWire>  , StepVisual_TessellatedItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedWire::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTessellatedEdgeOrVertex> & ,   const Standard_Boolean ,   const StepVisual_PathOrCompositeCurve &  ) ) static_cast<void (StepVisual_TessellatedWire::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfTessellatedEdgeOrVertex> & ,   const Standard_Boolean ,   const StepVisual_PathOrCompositeCurve &  ) >(&StepVisual_TessellatedWire::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theItems"),  py::arg("theHasGeometricModelLink"),  py::arg("theGeometricModelLink")
          )
        .def("Items",
             (handle<StepVisual_HArray1OfTessellatedEdgeOrVertex> (StepVisual_TessellatedWire::*)() const) static_cast<handle<StepVisual_HArray1OfTessellatedEdgeOrVertex> (StepVisual_TessellatedWire::*)() const>(&StepVisual_TessellatedWire::Items),
             R"#(Returns field Items)#" 
          )
        .def("SetItems",
             (void (StepVisual_TessellatedWire::*)(  const handle<StepVisual_HArray1OfTessellatedEdgeOrVertex> &  ) ) static_cast<void (StepVisual_TessellatedWire::*)(  const handle<StepVisual_HArray1OfTessellatedEdgeOrVertex> &  ) >(&StepVisual_TessellatedWire::SetItems),
             R"#(Sets field Items)#"  , py::arg("theItems")
          )
        .def("NbItems",
             (Standard_Integer (StepVisual_TessellatedWire::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedWire::*)() const>(&StepVisual_TessellatedWire::NbItems),
             R"#(Returns number of Items)#" 
          )
        .def("ItemsValue",
             ( const StepVisual_TessellatedEdgeOrVertex & (StepVisual_TessellatedWire::*)(  const Standard_Integer  ) const) static_cast< const StepVisual_TessellatedEdgeOrVertex & (StepVisual_TessellatedWire::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedWire::ItemsValue),
             R"#(Returns value of Items by its num)#"  , py::arg("theNum")
          )
        .def("GeometricModelLink",
             (StepVisual_PathOrCompositeCurve (StepVisual_TessellatedWire::*)() const) static_cast<StepVisual_PathOrCompositeCurve (StepVisual_TessellatedWire::*)() const>(&StepVisual_TessellatedWire::GeometricModelLink),
             R"#(Returns field GeometricModelLink)#" 
          )
        .def("SetGeometricModelLink",
             (void (StepVisual_TessellatedWire::*)(  const StepVisual_PathOrCompositeCurve &  ) ) static_cast<void (StepVisual_TessellatedWire::*)(  const StepVisual_PathOrCompositeCurve &  ) >(&StepVisual_TessellatedWire::SetGeometricModelLink),
             R"#(Sets field GeometricModelLink)#"  , py::arg("theGeometricModelLink")
          )
        .def("HasGeometricModelLink",
             (Standard_Boolean (StepVisual_TessellatedWire::*)() const) static_cast<Standard_Boolean (StepVisual_TessellatedWire::*)() const>(&StepVisual_TessellatedWire::HasGeometricModelLink),
             R"#(Returns True if optional field GeometricModelLink 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 * (*)() >(&StepVisual_TessellatedWire::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedWire::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> & (StepVisual_TessellatedWire::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedWire::*)() const>(&StepVisual_TessellatedWire::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TextStyleWithBoxCharacteristics ,opencascade::handle<StepVisual_TextStyleWithBoxCharacteristics>  , StepVisual_TextStyle >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TextStyleWithBoxCharacteristics::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_TextStyleForDefinedFont> & ,   const handle<StepVisual_HArray1OfBoxCharacteristicSelect> &  ) ) static_cast<void (StepVisual_TextStyleWithBoxCharacteristics::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_TextStyleForDefinedFont> & ,   const handle<StepVisual_HArray1OfBoxCharacteristicSelect> &  ) >(&StepVisual_TextStyleWithBoxCharacteristics::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aCharacterAppearance"),  py::arg("aCharacteristics")
          )
        .def("SetCharacteristics",
             (void (StepVisual_TextStyleWithBoxCharacteristics::*)(  const handle<StepVisual_HArray1OfBoxCharacteristicSelect> &  ) ) static_cast<void (StepVisual_TextStyleWithBoxCharacteristics::*)(  const handle<StepVisual_HArray1OfBoxCharacteristicSelect> &  ) >(&StepVisual_TextStyleWithBoxCharacteristics::SetCharacteristics),
             R"#()#"  , py::arg("aCharacteristics")
          )
        .def("Characteristics",
             (handle<StepVisual_HArray1OfBoxCharacteristicSelect> (StepVisual_TextStyleWithBoxCharacteristics::*)() const) static_cast<handle<StepVisual_HArray1OfBoxCharacteristicSelect> (StepVisual_TextStyleWithBoxCharacteristics::*)() const>(&StepVisual_TextStyleWithBoxCharacteristics::Characteristics),
             R"#()#" 
          )
        .def("CharacteristicsValue",
             (StepVisual_BoxCharacteristicSelect (StepVisual_TextStyleWithBoxCharacteristics::*)(  const Standard_Integer  ) const) static_cast<StepVisual_BoxCharacteristicSelect (StepVisual_TextStyleWithBoxCharacteristics::*)(  const Standard_Integer  ) const>(&StepVisual_TextStyleWithBoxCharacteristics::CharacteristicsValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbCharacteristics",
             (Standard_Integer (StepVisual_TextStyleWithBoxCharacteristics::*)() const) static_cast<Standard_Integer (StepVisual_TextStyleWithBoxCharacteristics::*)() const>(&StepVisual_TextStyleWithBoxCharacteristics::NbCharacteristics),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TextStyleWithBoxCharacteristics::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TextStyleWithBoxCharacteristics::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> & (StepVisual_TextStyleWithBoxCharacteristics::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TextStyleWithBoxCharacteristics::*)() const>(&StepVisual_TextStyleWithBoxCharacteristics::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationCurveOccurrence ,opencascade::handle<StepVisual_AnnotationCurveOccurrence>  , StepVisual_AnnotationOccurrence >>(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 * (*)() >(&StepVisual_AnnotationCurveOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationCurveOccurrence::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> & (StepVisual_AnnotationCurveOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationCurveOccurrence::*)() const>(&StepVisual_AnnotationCurveOccurrence::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationFillAreaOccurrence ,opencascade::handle<StepVisual_AnnotationFillAreaOccurrence>  , StepVisual_AnnotationOccurrence >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_AnnotationFillAreaOccurrence::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepGeom_GeometricRepresentationItem> &  ) ) static_cast<void (StepVisual_AnnotationFillAreaOccurrence::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepGeom_GeometricRepresentationItem> &  ) >(&StepVisual_AnnotationFillAreaOccurrence::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theName"),  py::arg("theStyles"),  py::arg("theItem"),  py::arg("theFillStyleTarget")
          )
        .def("FillStyleTarget",
             (handle<StepGeom_GeometricRepresentationItem> (StepVisual_AnnotationFillAreaOccurrence::*)() const) static_cast<handle<StepGeom_GeometricRepresentationItem> (StepVisual_AnnotationFillAreaOccurrence::*)() const>(&StepVisual_AnnotationFillAreaOccurrence::FillStyleTarget),
             R"#(Returns field fill_style_target)#" 
          )
        .def("SetFillStyleTarget",
             (void (StepVisual_AnnotationFillAreaOccurrence::*)(  const handle<StepGeom_GeometricRepresentationItem> &  ) ) static_cast<void (StepVisual_AnnotationFillAreaOccurrence::*)(  const handle<StepGeom_GeometricRepresentationItem> &  ) >(&StepVisual_AnnotationFillAreaOccurrence::SetFillStyleTarget),
             R"#(Set field fill_style_target)#"  , py::arg("theTarget")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_AnnotationFillAreaOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationFillAreaOccurrence::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> & (StepVisual_AnnotationFillAreaOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationFillAreaOccurrence::*)() const>(&StepVisual_AnnotationFillAreaOccurrence::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationPlane ,opencascade::handle<StepVisual_AnnotationPlane>  , StepVisual_AnnotationOccurrence >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_AnnotationPlane::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepVisual_HArray1OfAnnotationPlaneElement> &  ) ) static_cast<void (StepVisual_AnnotationPlane::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepVisual_HArray1OfAnnotationPlaneElement> &  ) >(&StepVisual_AnnotationPlane::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theStyles"),  py::arg("theItem"),  py::arg("theElements")
          )
        .def("Elements",
             (handle<StepVisual_HArray1OfAnnotationPlaneElement> (StepVisual_AnnotationPlane::*)() const) static_cast<handle<StepVisual_HArray1OfAnnotationPlaneElement> (StepVisual_AnnotationPlane::*)() const>(&StepVisual_AnnotationPlane::Elements),
             R"#(Returns field Elements)#" 
          )
        .def("SetElements",
             (void (StepVisual_AnnotationPlane::*)(  const handle<StepVisual_HArray1OfAnnotationPlaneElement> &  ) ) static_cast<void (StepVisual_AnnotationPlane::*)(  const handle<StepVisual_HArray1OfAnnotationPlaneElement> &  ) >(&StepVisual_AnnotationPlane::SetElements),
             R"#(Set field Elements)#"  , py::arg("theElements")
          )
        .def("NbElements",
             (Standard_Integer (StepVisual_AnnotationPlane::*)() const) static_cast<Standard_Integer (StepVisual_AnnotationPlane::*)() const>(&StepVisual_AnnotationPlane::NbElements),
             R"#(Returns number of Elements)#" 
          )
        .def("ElementsValue",
             (StepVisual_AnnotationPlaneElement (StepVisual_AnnotationPlane::*)(  const Standard_Integer  ) const) static_cast<StepVisual_AnnotationPlaneElement (StepVisual_AnnotationPlane::*)(  const Standard_Integer  ) const>(&StepVisual_AnnotationPlane::ElementsValue),
             R"#(Returns Elements with the given number)#"  , py::arg("theNum")
          )
        .def("SetElementsValue",
             (void (StepVisual_AnnotationPlane::*)(  const Standard_Integer ,   const StepVisual_AnnotationPlaneElement &  ) ) static_cast<void (StepVisual_AnnotationPlane::*)(  const Standard_Integer ,   const StepVisual_AnnotationPlaneElement &  ) >(&StepVisual_AnnotationPlane::SetElementsValue),
             R"#(Sets Elements with given number)#"  , py::arg("theNum"),  py::arg("theItem")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_AnnotationPlane::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationPlane::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> & (StepVisual_AnnotationPlane::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationPlane::*)() const>(&StepVisual_AnnotationPlane::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationTextOccurrence ,opencascade::handle<StepVisual_AnnotationTextOccurrence>  , StepVisual_AnnotationOccurrence >>(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 * (*)() >(&StepVisual_AnnotationTextOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationTextOccurrence::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> & (StepVisual_AnnotationTextOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationTextOccurrence::*)() const>(&StepVisual_AnnotationTextOccurrence::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CameraModelD3MultiClipping ,opencascade::handle<StepVisual_CameraModelD3MultiClipping>  , StepVisual_CameraModelD3 >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CameraModelD3MultiClipping::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepGeom_Axis2Placement3d> & ,   const handle<StepVisual_ViewVolume> & ,   const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) ) static_cast<void (StepVisual_CameraModelD3MultiClipping::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepGeom_Axis2Placement3d> & ,   const handle<StepVisual_ViewVolume> & ,   const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) >(&StepVisual_CameraModelD3MultiClipping::Init),
             R"#()#"  , py::arg("theName"),  py::arg("theViewReferenceSystem"),  py::arg("thePerspectiveOfVolume"),  py::arg("theShapeClipping")
          )
        .def("SetShapeClipping",
             (void (StepVisual_CameraModelD3MultiClipping::*)(  const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) ) static_cast<void (StepVisual_CameraModelD3MultiClipping::*)(  const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> &  ) >(&StepVisual_CameraModelD3MultiClipping::SetShapeClipping),
             R"#()#"  , py::arg("theShapeClipping")
          )
        .def("ShapeClipping",
             ( const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> (StepVisual_CameraModelD3MultiClipping::*)() ) static_cast< const handle<StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect> (StepVisual_CameraModelD3MultiClipping::*)() >(&StepVisual_CameraModelD3MultiClipping::ShapeClipping),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CameraModelD3MultiClipping::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CameraModelD3MultiClipping::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> & (StepVisual_CameraModelD3MultiClipping::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CameraModelD3MultiClipping::*)() const>(&StepVisual_CameraModelD3MultiClipping::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ColourRgb ,opencascade::handle<StepVisual_ColourRgb>  , StepVisual_ColourSpecification >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ColourRgb::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real ,   const Standard_Real ,   const Standard_Real  ) ) static_cast<void (StepVisual_ColourRgb::*)(  const handle<TCollection_HAsciiString> & ,   const Standard_Real ,   const Standard_Real ,   const Standard_Real  ) >(&StepVisual_ColourRgb::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aRed"),  py::arg("aGreen"),  py::arg("aBlue")
          )
        .def("SetRed",
             (void (StepVisual_ColourRgb::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_ColourRgb::*)(  const Standard_Real  ) >(&StepVisual_ColourRgb::SetRed),
             R"#()#"  , py::arg("aRed")
          )
        .def("Red",
             (Standard_Real (StepVisual_ColourRgb::*)() const) static_cast<Standard_Real (StepVisual_ColourRgb::*)() const>(&StepVisual_ColourRgb::Red),
             R"#()#" 
          )
        .def("SetGreen",
             (void (StepVisual_ColourRgb::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_ColourRgb::*)(  const Standard_Real  ) >(&StepVisual_ColourRgb::SetGreen),
             R"#()#"  , py::arg("aGreen")
          )
        .def("Green",
             (Standard_Real (StepVisual_ColourRgb::*)() const) static_cast<Standard_Real (StepVisual_ColourRgb::*)() const>(&StepVisual_ColourRgb::Green),
             R"#()#" 
          )
        .def("SetBlue",
             (void (StepVisual_ColourRgb::*)(  const Standard_Real  ) ) static_cast<void (StepVisual_ColourRgb::*)(  const Standard_Real  ) >(&StepVisual_ColourRgb::SetBlue),
             R"#()#"  , py::arg("aBlue")
          )
        .def("Blue",
             (Standard_Real (StepVisual_ColourRgb::*)() const) static_cast<Standard_Real (StepVisual_ColourRgb::*)() const>(&StepVisual_ColourRgb::Blue),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_ColourRgb::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ColourRgb::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> & (StepVisual_ColourRgb::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ColourRgb::*)() const>(&StepVisual_ColourRgb::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ComplexTriangulatedSurfaceSet ,opencascade::handle<StepVisual_ComplexTriangulatedSurfaceSet>  , StepVisual_TessellatedSurfaceSet >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray1OfTransient> & ,   const handle<TColStd_HArray1OfTransient> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray1OfTransient> & ,   const handle<TColStd_HArray1OfTransient> &  ) >(&StepVisual_ComplexTriangulatedSurfaceSet::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theTessellatedSurfaceSet_Coordinates"),  py::arg("theTessellatedSurfaceSet_Pnmax"),  py::arg("theTessellatedSurfaceSet_Normals"),  py::arg("thePnindex"),  py::arg("theTriangleStrips"),  py::arg("theTriangleFans")
          )
        .def("Pnindex",
             (handle<TColStd_HArray1OfInteger> (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::Pnindex),
             R"#(Returns field Pnindex)#" 
          )
        .def("SetPnindex",
             (void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_ComplexTriangulatedSurfaceSet::SetPnindex),
             R"#(Sets field Pnindex)#"  , py::arg("thePnindex")
          )
        .def("NbPnindex",
             (Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::NbPnindex),
             R"#(Returns number of Pnindex)#" 
          )
        .def("PnindexValue",
             (Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const Standard_Integer  ) const>(&StepVisual_ComplexTriangulatedSurfaceSet::PnindexValue),
             R"#(Returns value of Pnindex by its num)#"  , py::arg("theNum")
          )
        .def("TriangleStrips",
             (handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast<handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::TriangleStrips),
             R"#(Returns field TriangleStrips)#" 
          )
        .def("SetTriangleStrips",
             (void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfTransient> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfTransient> &  ) >(&StepVisual_ComplexTriangulatedSurfaceSet::SetTriangleStrips),
             R"#(Sets field TriangleStrips)#"  , py::arg("theTriangleStrips")
          )
        .def("NbTriangleStrips",
             (Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::NbTriangleStrips),
             R"#(Returns number of TriangleStrips)#" 
          )
        .def("TriangleFans",
             (handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast<handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::TriangleFans),
             R"#(Returns field TriangleFans)#" 
          )
        .def("SetTriangleFans",
             (void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfTransient> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfTransient> &  ) >(&StepVisual_ComplexTriangulatedSurfaceSet::SetTriangleFans),
             R"#(Sets field TriangleFans)#"  , py::arg("theTriangleFans")
          )
        .def("NbTriangleFans",
             (Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::NbTriangleFans),
             R"#(Returns number of TriangleFans)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_ComplexTriangulatedSurfaceSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ComplexTriangulatedSurfaceSet::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> & (StepVisual_ComplexTriangulatedSurfaceSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ComplexTriangulatedSurfaceSet::*)() const>(&StepVisual_ComplexTriangulatedSurfaceSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ContextDependentOverRidingStyledItem ,opencascade::handle<StepVisual_ContextDependentOverRidingStyledItem>  , StepVisual_OverRidingStyledItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ContextDependentOverRidingStyledItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepVisual_StyledItem> & ,   const handle<StepVisual_HArray1OfStyleContextSelect> &  ) ) static_cast<void (StepVisual_ContextDependentOverRidingStyledItem::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_HArray1OfPresentationStyleAssignment> & ,   const handle<Standard_Transient> & ,   const handle<StepVisual_StyledItem> & ,   const handle<StepVisual_HArray1OfStyleContextSelect> &  ) >(&StepVisual_ContextDependentOverRidingStyledItem::Init),
             R"#()#"  , py::arg("aName"),  py::arg("aStyles"),  py::arg("aItem"),  py::arg("aOverRiddenStyle"),  py::arg("aStyleContext")
          )
        .def("SetStyleContext",
             (void (StepVisual_ContextDependentOverRidingStyledItem::*)(  const handle<StepVisual_HArray1OfStyleContextSelect> &  ) ) static_cast<void (StepVisual_ContextDependentOverRidingStyledItem::*)(  const handle<StepVisual_HArray1OfStyleContextSelect> &  ) >(&StepVisual_ContextDependentOverRidingStyledItem::SetStyleContext),
             R"#()#"  , py::arg("aStyleContext")
          )
        .def("StyleContext",
             (handle<StepVisual_HArray1OfStyleContextSelect> (StepVisual_ContextDependentOverRidingStyledItem::*)() const) static_cast<handle<StepVisual_HArray1OfStyleContextSelect> (StepVisual_ContextDependentOverRidingStyledItem::*)() const>(&StepVisual_ContextDependentOverRidingStyledItem::StyleContext),
             R"#()#" 
          )
        .def("StyleContextValue",
             (StepVisual_StyleContextSelect (StepVisual_ContextDependentOverRidingStyledItem::*)(  const Standard_Integer  ) const) static_cast<StepVisual_StyleContextSelect (StepVisual_ContextDependentOverRidingStyledItem::*)(  const Standard_Integer  ) const>(&StepVisual_ContextDependentOverRidingStyledItem::StyleContextValue),
             R"#()#"  , py::arg("num")
          )
        .def("NbStyleContext",
             (Standard_Integer (StepVisual_ContextDependentOverRidingStyledItem::*)() const) static_cast<Standard_Integer (StepVisual_ContextDependentOverRidingStyledItem::*)() const>(&StepVisual_ContextDependentOverRidingStyledItem::NbStyleContext),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_ContextDependentOverRidingStyledItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ContextDependentOverRidingStyledItem::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> & (StepVisual_ContextDependentOverRidingStyledItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ContextDependentOverRidingStyledItem::*)() const>(&StepVisual_ContextDependentOverRidingStyledItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_DraughtingAnnotationOccurrence ,opencascade::handle<StepVisual_DraughtingAnnotationOccurrence>  , StepVisual_AnnotationOccurrence >>(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 * (*)() >(&StepVisual_DraughtingAnnotationOccurrence::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_DraughtingAnnotationOccurrence::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> & (StepVisual_DraughtingAnnotationOccurrence::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_DraughtingAnnotationOccurrence::*)() const>(&StepVisual_DraughtingAnnotationOccurrence::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_DraughtingPreDefinedColour ,opencascade::handle<StepVisual_DraughtingPreDefinedColour>  , StepVisual_PreDefinedColour >>(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 * (*)() >(&StepVisual_DraughtingPreDefinedColour::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_DraughtingPreDefinedColour::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> & (StepVisual_DraughtingPreDefinedColour::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_DraughtingPreDefinedColour::*)() const>(&StepVisual_DraughtingPreDefinedColour::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_DraughtingPreDefinedCurveFont ,opencascade::handle<StepVisual_DraughtingPreDefinedCurveFont>  , StepVisual_PreDefinedCurveFont >>(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 * (*)() >(&StepVisual_DraughtingPreDefinedCurveFont::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_DraughtingPreDefinedCurveFont::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> & (StepVisual_DraughtingPreDefinedCurveFont::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_DraughtingPreDefinedCurveFont::*)() const>(&StepVisual_DraughtingPreDefinedCurveFont::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_MechanicalDesignGeometricPresentationArea ,opencascade::handle<StepVisual_MechanicalDesignGeometricPresentationArea>  , StepVisual_PresentationArea >>(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 * (*)() >(&StepVisual_MechanicalDesignGeometricPresentationArea::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_MechanicalDesignGeometricPresentationArea::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> & (StepVisual_MechanicalDesignGeometricPresentationArea::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_MechanicalDesignGeometricPresentationArea::*)() const>(&StepVisual_MechanicalDesignGeometricPresentationArea::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_RepositionedTessellatedGeometricSet ,opencascade::handle<StepVisual_RepositionedTessellatedGeometricSet>  , StepVisual_TessellatedGeometricSet >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_RepositionedTessellatedGeometricSet::*)(  const handle<TCollection_HAsciiString> & ,   const NCollection_Handle<StepVisual_Array1OfTessellatedItem> & ,   const handle<StepGeom_Axis2Placement3d> &  ) ) static_cast<void (StepVisual_RepositionedTessellatedGeometricSet::*)(  const handle<TCollection_HAsciiString> & ,   const NCollection_Handle<StepVisual_Array1OfTessellatedItem> & ,   const handle<StepGeom_Axis2Placement3d> &  ) >(&StepVisual_RepositionedTessellatedGeometricSet::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theName"),  py::arg("theItems"),  py::arg("theLocation")
          )
        .def("Location",
             (handle<StepGeom_Axis2Placement3d> (StepVisual_RepositionedTessellatedGeometricSet::*)() const) static_cast<handle<StepGeom_Axis2Placement3d> (StepVisual_RepositionedTessellatedGeometricSet::*)() const>(&StepVisual_RepositionedTessellatedGeometricSet::Location),
             R"#(Returns location)#" 
          )
        .def("SetLocation",
             (void (StepVisual_RepositionedTessellatedGeometricSet::*)(  const handle<StepGeom_Axis2Placement3d> &  ) ) static_cast<void (StepVisual_RepositionedTessellatedGeometricSet::*)(  const handle<StepGeom_Axis2Placement3d> &  ) >(&StepVisual_RepositionedTessellatedGeometricSet::SetLocation),
             R"#(Sets location)#"  , py::arg("theLocation")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_RepositionedTessellatedGeometricSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_RepositionedTessellatedGeometricSet::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> & (StepVisual_RepositionedTessellatedGeometricSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_RepositionedTessellatedGeometricSet::*)() const>(&StepVisual_RepositionedTessellatedGeometricSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedEdge ,opencascade::handle<StepVisual_TessellatedEdge>  , StepVisual_TessellatedStructuredItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedEdge::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Boolean ,   const StepVisual_EdgeOrCurve & ,   const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedEdge::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Boolean ,   const StepVisual_EdgeOrCurve & ,   const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedEdge::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theCoordinates"),  py::arg("theHasGeometricLink"),  py::arg("theGeometricLink"),  py::arg("theLineStrip")
          )
        .def("Coordinates",
             (handle<StepVisual_CoordinatesList> (StepVisual_TessellatedEdge::*)() const) static_cast<handle<StepVisual_CoordinatesList> (StepVisual_TessellatedEdge::*)() const>(&StepVisual_TessellatedEdge::Coordinates),
             R"#(Returns field Coordinates)#" 
          )
        .def("SetCoordinates",
             (void (StepVisual_TessellatedEdge::*)(  const handle<StepVisual_CoordinatesList> &  ) ) static_cast<void (StepVisual_TessellatedEdge::*)(  const handle<StepVisual_CoordinatesList> &  ) >(&StepVisual_TessellatedEdge::SetCoordinates),
             R"#(Sets field Coordinates)#"  , py::arg("theCoordinates")
          )
        .def("GeometricLink",
             (StepVisual_EdgeOrCurve (StepVisual_TessellatedEdge::*)() const) static_cast<StepVisual_EdgeOrCurve (StepVisual_TessellatedEdge::*)() const>(&StepVisual_TessellatedEdge::GeometricLink),
             R"#(Returns field GeometricLink)#" 
          )
        .def("SetGeometricLink",
             (void (StepVisual_TessellatedEdge::*)(  const StepVisual_EdgeOrCurve &  ) ) static_cast<void (StepVisual_TessellatedEdge::*)(  const StepVisual_EdgeOrCurve &  ) >(&StepVisual_TessellatedEdge::SetGeometricLink),
             R"#(Sets field GeometricLink)#"  , py::arg("theGeometricLink")
          )
        .def("HasGeometricLink",
             (Standard_Boolean (StepVisual_TessellatedEdge::*)() const) static_cast<Standard_Boolean (StepVisual_TessellatedEdge::*)() const>(&StepVisual_TessellatedEdge::HasGeometricLink),
             R"#(Returns True if optional field GeometricLink is defined)#" 
          )
        .def("LineStrip",
             (handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedEdge::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedEdge::*)() const>(&StepVisual_TessellatedEdge::LineStrip),
             R"#(Returns field LineStrip)#" 
          )
        .def("SetLineStrip",
             (void (StepVisual_TessellatedEdge::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedEdge::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedEdge::SetLineStrip),
             R"#(Sets field LineStrip)#"  , py::arg("theLineStrip")
          )
        .def("NbLineStrip",
             (Standard_Integer (StepVisual_TessellatedEdge::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedEdge::*)() const>(&StepVisual_TessellatedEdge::NbLineStrip),
             R"#(Returns number of LineStrip)#" 
          )
        .def("LineStripValue",
             (Standard_Integer (StepVisual_TessellatedEdge::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_TessellatedEdge::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedEdge::LineStripValue),
             R"#(Returns value of LineStrip by its num)#"  , py::arg("theNum")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedEdge::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedEdge::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> & (StepVisual_TessellatedEdge::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedEdge::*)() const>(&StepVisual_TessellatedEdge::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedFace ,opencascade::handle<StepVisual_TessellatedFace>  , StepVisual_TessellatedStructuredItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface &  ) ) static_cast<void (StepVisual_TessellatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface &  ) >(&StepVisual_TessellatedFace::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theCoordinates"),  py::arg("thePnmax"),  py::arg("theNormals"),  py::arg("theHasGeometricLink"),  py::arg("theGeometricLink")
          )
        .def("Coordinates",
             (handle<StepVisual_CoordinatesList> (StepVisual_TessellatedFace::*)() const) static_cast<handle<StepVisual_CoordinatesList> (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::Coordinates),
             R"#(Returns field Coordinates)#" 
          )
        .def("SetCoordinates",
             (void (StepVisual_TessellatedFace::*)(  const handle<StepVisual_CoordinatesList> &  ) ) static_cast<void (StepVisual_TessellatedFace::*)(  const handle<StepVisual_CoordinatesList> &  ) >(&StepVisual_TessellatedFace::SetCoordinates),
             R"#(Sets field Coordinates)#"  , py::arg("theCoordinates")
          )
        .def("Pnmax",
             (Standard_Integer (StepVisual_TessellatedFace::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::Pnmax),
             R"#(Returns field Pnmax)#" 
          )
        .def("SetPnmax",
             (void (StepVisual_TessellatedFace::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_TessellatedFace::*)(  const Standard_Integer  ) >(&StepVisual_TessellatedFace::SetPnmax),
             R"#(Sets field Pnmax)#"  , py::arg("thePnmax")
          )
        .def("Normals",
             (handle<TColStd_HArray2OfReal> (StepVisual_TessellatedFace::*)() const) static_cast<handle<TColStd_HArray2OfReal> (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::Normals),
             R"#(Returns field Normals)#" 
          )
        .def("SetNormals",
             (void (StepVisual_TessellatedFace::*)(  const handle<TColStd_HArray2OfReal> &  ) ) static_cast<void (StepVisual_TessellatedFace::*)(  const handle<TColStd_HArray2OfReal> &  ) >(&StepVisual_TessellatedFace::SetNormals),
             R"#(Sets field Normals)#"  , py::arg("theNormals")
          )
        .def("NbNormals",
             (Standard_Integer (StepVisual_TessellatedFace::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::NbNormals),
             R"#(Returns number of Normals)#" 
          )
        .def("GeometricLink",
             (StepVisual_FaceOrSurface (StepVisual_TessellatedFace::*)() const) static_cast<StepVisual_FaceOrSurface (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::GeometricLink),
             R"#(Returns field GeometricLink)#" 
          )
        .def("SetGeometricLink",
             (void (StepVisual_TessellatedFace::*)(  const StepVisual_FaceOrSurface &  ) ) static_cast<void (StepVisual_TessellatedFace::*)(  const StepVisual_FaceOrSurface &  ) >(&StepVisual_TessellatedFace::SetGeometricLink),
             R"#(Sets field GeometricLink)#"  , py::arg("theGeometricLink")
          )
        .def("HasGeometricLink",
             (Standard_Boolean (StepVisual_TessellatedFace::*)() const) static_cast<Standard_Boolean (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::HasGeometricLink),
             R"#(Returns True if optional field GeometricLink 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 * (*)() >(&StepVisual_TessellatedFace::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedFace::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> & (StepVisual_TessellatedFace::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedFace::*)() const>(&StepVisual_TessellatedFace::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedVertex ,opencascade::handle<StepVisual_TessellatedVertex>  , StepVisual_TessellatedStructuredItem >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedVertex::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Boolean ,   const handle<StepShape_VertexPoint> & ,   const Standard_Integer  ) ) static_cast<void (StepVisual_TessellatedVertex::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Boolean ,   const handle<StepShape_VertexPoint> & ,   const Standard_Integer  ) >(&StepVisual_TessellatedVertex::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theCoordinates"),  py::arg("theHasTopologicalLink"),  py::arg("theTopologicalLink"),  py::arg("thePointIndex")
          )
        .def("Coordinates",
             (handle<StepVisual_CoordinatesList> (StepVisual_TessellatedVertex::*)() const) static_cast<handle<StepVisual_CoordinatesList> (StepVisual_TessellatedVertex::*)() const>(&StepVisual_TessellatedVertex::Coordinates),
             R"#(Returns field Coordinates)#" 
          )
        .def("SetCoordinates",
             (void (StepVisual_TessellatedVertex::*)(  const handle<StepVisual_CoordinatesList> &  ) ) static_cast<void (StepVisual_TessellatedVertex::*)(  const handle<StepVisual_CoordinatesList> &  ) >(&StepVisual_TessellatedVertex::SetCoordinates),
             R"#(Sets field Coordinates)#"  , py::arg("theCoordinates")
          )
        .def("TopologicalLink",
             (handle<StepShape_VertexPoint> (StepVisual_TessellatedVertex::*)() const) static_cast<handle<StepShape_VertexPoint> (StepVisual_TessellatedVertex::*)() const>(&StepVisual_TessellatedVertex::TopologicalLink),
             R"#(Returns field TopologicalLink)#" 
          )
        .def("SetTopologicalLink",
             (void (StepVisual_TessellatedVertex::*)(  const handle<StepShape_VertexPoint> &  ) ) static_cast<void (StepVisual_TessellatedVertex::*)(  const handle<StepShape_VertexPoint> &  ) >(&StepVisual_TessellatedVertex::SetTopologicalLink),
             R"#(Sets field TopologicalLink)#"  , py::arg("theTopologicalLink")
          )
        .def("HasTopologicalLink",
             (Standard_Boolean (StepVisual_TessellatedVertex::*)() const) static_cast<Standard_Boolean (StepVisual_TessellatedVertex::*)() const>(&StepVisual_TessellatedVertex::HasTopologicalLink),
             R"#(Returns True if optional field TopologicalLink is defined)#" 
          )
        .def("PointIndex",
             (Standard_Integer (StepVisual_TessellatedVertex::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedVertex::*)() const>(&StepVisual_TessellatedVertex::PointIndex),
             R"#(Returns field PointIndex)#" 
          )
        .def("SetPointIndex",
             (void (StepVisual_TessellatedVertex::*)(  const Standard_Integer  ) ) static_cast<void (StepVisual_TessellatedVertex::*)(  const Standard_Integer  ) >(&StepVisual_TessellatedVertex::SetPointIndex),
             R"#(Sets field PointIndex)#"  , py::arg("thePointIndex")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedVertex::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedVertex::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> & (StepVisual_TessellatedVertex::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedVertex::*)() const>(&StepVisual_TessellatedVertex::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TriangulatedSurfaceSet ,opencascade::handle<StepVisual_TriangulatedSurfaceSet>  , StepVisual_TessellatedSurfaceSet >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TriangulatedSurfaceSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray2OfInteger> &  ) ) static_cast<void (StepVisual_TriangulatedSurfaceSet::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray2OfInteger> &  ) >(&StepVisual_TriangulatedSurfaceSet::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItemName"),  py::arg("theTessellatedFaceCoordinates"),  py::arg("theTessellatedFacePnmax"),  py::arg("theTessellatedFaceNormals"),  py::arg("thePnindex"),  py::arg("theTriangles")
          )
        .def("Pnindex",
             ( const handle<TColStd_HArray1OfInteger> (StepVisual_TriangulatedSurfaceSet::*)() const) static_cast< const handle<TColStd_HArray1OfInteger> (StepVisual_TriangulatedSurfaceSet::*)() const>(&StepVisual_TriangulatedSurfaceSet::Pnindex),
             R"#(Returns field Pnindex)#" 
          )
        .def("SetPnindex",
             (void (StepVisual_TriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TriangulatedSurfaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TriangulatedSurfaceSet::SetPnindex),
             R"#(Sets field Pnindex)#"  , py::arg("thePnindex")
          )
        .def("NbPnindex",
             (Standard_Integer (StepVisual_TriangulatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_TriangulatedSurfaceSet::*)() const>(&StepVisual_TriangulatedSurfaceSet::NbPnindex),
             R"#(Returns number of Pnindex)#" 
          )
        .def("PnindexValue",
             (Standard_Integer (StepVisual_TriangulatedSurfaceSet::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_TriangulatedSurfaceSet::*)(  const Standard_Integer  ) const>(&StepVisual_TriangulatedSurfaceSet::PnindexValue),
             R"#(Returns value of Pnindex by its num)#"  , py::arg("theNum")
          )
        .def("Triangles",
             ( const handle<TColStd_HArray2OfInteger> (StepVisual_TriangulatedSurfaceSet::*)() const) static_cast< const handle<TColStd_HArray2OfInteger> (StepVisual_TriangulatedSurfaceSet::*)() const>(&StepVisual_TriangulatedSurfaceSet::Triangles),
             R"#(Returns field Triangles)#" 
          )
        .def("SetTriangles",
             (void (StepVisual_TriangulatedSurfaceSet::*)(  const handle<TColStd_HArray2OfInteger> &  ) ) static_cast<void (StepVisual_TriangulatedSurfaceSet::*)(  const handle<TColStd_HArray2OfInteger> &  ) >(&StepVisual_TriangulatedSurfaceSet::SetTriangles),
             R"#(Sets field Triangles)#"  , py::arg("theTriangles")
          )
        .def("NbTriangles",
             (Standard_Integer (StepVisual_TriangulatedSurfaceSet::*)() const) static_cast<Standard_Integer (StepVisual_TriangulatedSurfaceSet::*)() const>(&StepVisual_TriangulatedSurfaceSet::NbTriangles),
             R"#(Returns number of Triangles)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TriangulatedSurfaceSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TriangulatedSurfaceSet::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> & (StepVisual_TriangulatedSurfaceSet::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TriangulatedSurfaceSet::*)() const>(&StepVisual_TriangulatedSurfaceSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_AnnotationCurveOccurrenceAndGeomReprItem ,opencascade::handle<StepVisual_AnnotationCurveOccurrenceAndGeomReprItem>  , StepVisual_AnnotationCurveOccurrence >>(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 * (*)() >(&StepVisual_AnnotationCurveOccurrenceAndGeomReprItem::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_AnnotationCurveOccurrenceAndGeomReprItem::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> & (StepVisual_AnnotationCurveOccurrenceAndGeomReprItem::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_AnnotationCurveOccurrenceAndGeomReprItem::*)() const>(&StepVisual_AnnotationCurveOccurrenceAndGeomReprItem::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_ComplexTriangulatedFace ,opencascade::handle<StepVisual_ComplexTriangulatedFace>  , StepVisual_TessellatedFace >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray1OfTransient> & ,   const handle<TColStd_HArray1OfTransient> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray1OfTransient> & ,   const handle<TColStd_HArray1OfTransient> &  ) >(&StepVisual_ComplexTriangulatedFace::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theTessellatedFace_Coordinates"),  py::arg("theTessellatedFace_Pnmax"),  py::arg("theTessellatedFace_Normals"),  py::arg("theHasTessellatedFace_GeometricLink"),  py::arg("theTessellatedFace_GeometricLink"),  py::arg("thePnindex"),  py::arg("theTriangleStrips"),  py::arg("theTriangleFans")
          )
        .def("Pnindex",
             (handle<TColStd_HArray1OfInteger> (StepVisual_ComplexTriangulatedFace::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::Pnindex),
             R"#(Returns field Pnindex)#" 
          )
        .def("SetPnindex",
             (void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_ComplexTriangulatedFace::SetPnindex),
             R"#(Sets field Pnindex)#"  , py::arg("thePnindex")
          )
        .def("NbPnindex",
             (Standard_Integer (StepVisual_ComplexTriangulatedFace::*)() const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::NbPnindex),
             R"#(Returns number of Pnindex)#" 
          )
        .def("PnindexValue",
             (Standard_Integer (StepVisual_ComplexTriangulatedFace::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedFace::*)(  const Standard_Integer  ) const>(&StepVisual_ComplexTriangulatedFace::PnindexValue),
             R"#(Returns value of Pnindex by its num)#"  , py::arg("theNum")
          )
        .def("TriangleStrips",
             (handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedFace::*)() const) static_cast<handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::TriangleStrips),
             R"#(Returns field TriangleStrips)#" 
          )
        .def("SetTriangleStrips",
             (void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TColStd_HArray1OfTransient> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TColStd_HArray1OfTransient> &  ) >(&StepVisual_ComplexTriangulatedFace::SetTriangleStrips),
             R"#(Sets field TriangleStrips)#"  , py::arg("theTriangleStrips")
          )
        .def("NbTriangleStrips",
             (Standard_Integer (StepVisual_ComplexTriangulatedFace::*)() const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::NbTriangleStrips),
             R"#(Returns number of TriangleStrips)#" 
          )
        .def("TriangleFans",
             (handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedFace::*)() const) static_cast<handle<TColStd_HArray1OfTransient> (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::TriangleFans),
             R"#(Returns field TriangleFans)#" 
          )
        .def("SetTriangleFans",
             (void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TColStd_HArray1OfTransient> &  ) ) static_cast<void (StepVisual_ComplexTriangulatedFace::*)(  const handle<TColStd_HArray1OfTransient> &  ) >(&StepVisual_ComplexTriangulatedFace::SetTriangleFans),
             R"#(Sets field TriangleFans)#"  , py::arg("theTriangleFans")
          )
        .def("NbTriangleFans",
             (Standard_Integer (StepVisual_ComplexTriangulatedFace::*)() const) static_cast<Standard_Integer (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::NbTriangleFans),
             R"#(Returns number of TriangleFans)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_ComplexTriangulatedFace::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_ComplexTriangulatedFace::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> & (StepVisual_ComplexTriangulatedFace::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_ComplexTriangulatedFace::*)() const>(&StepVisual_ComplexTriangulatedFace::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CubicBezierTessellatedEdge ,opencascade::handle<StepVisual_CubicBezierTessellatedEdge>  , StepVisual_TessellatedEdge >>(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 * (*)() >(&StepVisual_CubicBezierTessellatedEdge::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CubicBezierTessellatedEdge::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> & (StepVisual_CubicBezierTessellatedEdge::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CubicBezierTessellatedEdge::*)() const>(&StepVisual_CubicBezierTessellatedEdge::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_CubicBezierTriangulatedFace ,opencascade::handle<StepVisual_CubicBezierTriangulatedFace>  , StepVisual_TessellatedFace >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_CubicBezierTriangulatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface & ,   const handle<TColStd_HArray2OfInteger> &  ) ) static_cast<void (StepVisual_CubicBezierTriangulatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface & ,   const handle<TColStd_HArray2OfInteger> &  ) >(&StepVisual_CubicBezierTriangulatedFace::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theTessellatedFace_Coordinates"),  py::arg("theTessellatedFace_Pnmax"),  py::arg("theTessellatedFace_Normals"),  py::arg("theHasTessellatedFace_GeometricLink"),  py::arg("theTessellatedFace_GeometricLink"),  py::arg("theCtriangles")
          )
        .def("Ctriangles",
             (handle<TColStd_HArray2OfInteger> (StepVisual_CubicBezierTriangulatedFace::*)() const) static_cast<handle<TColStd_HArray2OfInteger> (StepVisual_CubicBezierTriangulatedFace::*)() const>(&StepVisual_CubicBezierTriangulatedFace::Ctriangles),
             R"#(Returns field Ctriangles)#" 
          )
        .def("SetCtriangles",
             (void (StepVisual_CubicBezierTriangulatedFace::*)(  const handle<TColStd_HArray2OfInteger> &  ) ) static_cast<void (StepVisual_CubicBezierTriangulatedFace::*)(  const handle<TColStd_HArray2OfInteger> &  ) >(&StepVisual_CubicBezierTriangulatedFace::SetCtriangles),
             R"#(Sets field Ctriangles)#"  , py::arg("theCtriangles")
          )
        .def("NbCtriangles",
             (Standard_Integer (StepVisual_CubicBezierTriangulatedFace::*)() const) static_cast<Standard_Integer (StepVisual_CubicBezierTriangulatedFace::*)() const>(&StepVisual_CubicBezierTriangulatedFace::NbCtriangles),
             R"#(Returns number of Ctriangles)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_CubicBezierTriangulatedFace::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_CubicBezierTriangulatedFace::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> & (StepVisual_CubicBezierTriangulatedFace::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_CubicBezierTriangulatedFace::*)() const>(&StepVisual_CubicBezierTriangulatedFace::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TessellatedConnectingEdge ,opencascade::handle<StepVisual_TessellatedConnectingEdge>  , StepVisual_TessellatedEdge >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TessellatedConnectingEdge::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Boolean ,   const StepVisual_EdgeOrCurve & ,   const handle<TColStd_HArray1OfInteger> & ,   const StepData_Logical ,   const handle<StepVisual_TessellatedFace> & ,   const handle<StepVisual_TessellatedFace> & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedConnectingEdge::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Boolean ,   const StepVisual_EdgeOrCurve & ,   const handle<TColStd_HArray1OfInteger> & ,   const StepData_Logical ,   const handle<StepVisual_TessellatedFace> & ,   const handle<StepVisual_TessellatedFace> & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedConnectingEdge::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theTessellatedEdge_Coordinates"),  py::arg("theHasTessellatedEdge_GeometricLink"),  py::arg("theTessellatedEdge_GeometricLink"),  py::arg("theTessellatedEdge_LineStrip"),  py::arg("theSmooth"),  py::arg("theFace1"),  py::arg("theFace2"),  py::arg("theLineStripFace1"),  py::arg("theLineStripFace2")
          )
        .def("Smooth",
             (StepData_Logical (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<StepData_Logical (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::Smooth),
             R"#(Returns field Smooth)#" 
          )
        .def("SetSmooth",
             (void (StepVisual_TessellatedConnectingEdge::*)(  const StepData_Logical  ) ) static_cast<void (StepVisual_TessellatedConnectingEdge::*)(  const StepData_Logical  ) >(&StepVisual_TessellatedConnectingEdge::SetSmooth),
             R"#(Sets field Smooth)#"  , py::arg("theSmooth")
          )
        .def("Face1",
             (handle<StepVisual_TessellatedFace> (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<handle<StepVisual_TessellatedFace> (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::Face1),
             R"#(Returns field Face1)#" 
          )
        .def("SetFace1",
             (void (StepVisual_TessellatedConnectingEdge::*)(  const handle<StepVisual_TessellatedFace> &  ) ) static_cast<void (StepVisual_TessellatedConnectingEdge::*)(  const handle<StepVisual_TessellatedFace> &  ) >(&StepVisual_TessellatedConnectingEdge::SetFace1),
             R"#(Sets field Face1)#"  , py::arg("theFace1")
          )
        .def("Face2",
             (handle<StepVisual_TessellatedFace> (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<handle<StepVisual_TessellatedFace> (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::Face2),
             R"#(Returns field Face2)#" 
          )
        .def("SetFace2",
             (void (StepVisual_TessellatedConnectingEdge::*)(  const handle<StepVisual_TessellatedFace> &  ) ) static_cast<void (StepVisual_TessellatedConnectingEdge::*)(  const handle<StepVisual_TessellatedFace> &  ) >(&StepVisual_TessellatedConnectingEdge::SetFace2),
             R"#(Sets field Face2)#"  , py::arg("theFace2")
          )
        .def("LineStripFace1",
             (handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::LineStripFace1),
             R"#(Returns field LineStripFace1)#" 
          )
        .def("SetLineStripFace1",
             (void (StepVisual_TessellatedConnectingEdge::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedConnectingEdge::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedConnectingEdge::SetLineStripFace1),
             R"#(Sets field LineStripFace1)#"  , py::arg("theLineStripFace1")
          )
        .def("NbLineStripFace1",
             (Standard_Integer (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::NbLineStripFace1),
             R"#(Returns number of LineStripFace1)#" 
          )
        .def("LineStripFace1Value",
             (Standard_Integer (StepVisual_TessellatedConnectingEdge::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_TessellatedConnectingEdge::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedConnectingEdge::LineStripFace1Value),
             R"#(Returns value of LineStripFace1 by its num)#"  , py::arg("theNum")
          )
        .def("LineStripFace2",
             (handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::LineStripFace2),
             R"#(Returns field LineStripFace2)#" 
          )
        .def("SetLineStripFace2",
             (void (StepVisual_TessellatedConnectingEdge::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TessellatedConnectingEdge::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TessellatedConnectingEdge::SetLineStripFace2),
             R"#(Sets field LineStripFace2)#"  , py::arg("theLineStripFace2")
          )
        .def("NbLineStripFace2",
             (Standard_Integer (StepVisual_TessellatedConnectingEdge::*)() const) static_cast<Standard_Integer (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::NbLineStripFace2),
             R"#(Returns number of LineStripFace2)#" 
          )
        .def("LineStripFace2Value",
             (Standard_Integer (StepVisual_TessellatedConnectingEdge::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_TessellatedConnectingEdge::*)(  const Standard_Integer  ) const>(&StepVisual_TessellatedConnectingEdge::LineStripFace2Value),
             R"#(Returns value of LineStripFace2 by its num)#"  , py::arg("theNum")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TessellatedConnectingEdge::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TessellatedConnectingEdge::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> & (StepVisual_TessellatedConnectingEdge::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TessellatedConnectingEdge::*)() const>(&StepVisual_TessellatedConnectingEdge::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<StepVisual_TriangulatedFace ,opencascade::handle<StepVisual_TriangulatedFace>  , StepVisual_TessellatedFace >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Init",
             (void (StepVisual_TriangulatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray2OfInteger> &  ) ) static_cast<void (StepVisual_TriangulatedFace::*)(  const handle<TCollection_HAsciiString> & ,   const handle<StepVisual_CoordinatesList> & ,   const Standard_Integer ,   const handle<TColStd_HArray2OfReal> & ,   const Standard_Boolean ,   const StepVisual_FaceOrSurface & ,   const handle<TColStd_HArray1OfInteger> & ,   const handle<TColStd_HArray2OfInteger> &  ) >(&StepVisual_TriangulatedFace::Init),
             R"#(Initialize all fields (own and inherited))#"  , py::arg("theRepresentationItem_Name"),  py::arg("theTessellatedFace_Coordinates"),  py::arg("theTessellatedFace_Pnmax"),  py::arg("theTessellatedFace_Normals"),  py::arg("theHasTessellatedFace_GeometricLink"),  py::arg("theTessellatedFace_GeometricLink"),  py::arg("thePnindex"),  py::arg("theTriangles")
          )
        .def("Pnindex",
             (handle<TColStd_HArray1OfInteger> (StepVisual_TriangulatedFace::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (StepVisual_TriangulatedFace::*)() const>(&StepVisual_TriangulatedFace::Pnindex),
             R"#(Returns field Pnindex)#" 
          )
        .def("SetPnindex",
             (void (StepVisual_TriangulatedFace::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (StepVisual_TriangulatedFace::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&StepVisual_TriangulatedFace::SetPnindex),
             R"#(Sets field Pnindex)#"  , py::arg("thePnindex")
          )
        .def("NbPnindex",
             (Standard_Integer (StepVisual_TriangulatedFace::*)() const) static_cast<Standard_Integer (StepVisual_TriangulatedFace::*)() const>(&StepVisual_TriangulatedFace::NbPnindex),
             R"#(Returns number of Pnindex)#" 
          )
        .def("PnindexValue",
             (Standard_Integer (StepVisual_TriangulatedFace::*)(  const Standard_Integer  ) const) static_cast<Standard_Integer (StepVisual_TriangulatedFace::*)(  const Standard_Integer  ) const>(&StepVisual_TriangulatedFace::PnindexValue),
             R"#(Returns value of Pnindex by its num)#"  , py::arg("theNum")
          )
        .def("Triangles",
             (handle<TColStd_HArray2OfInteger> (StepVisual_TriangulatedFace::*)() const) static_cast<handle<TColStd_HArray2OfInteger> (StepVisual_TriangulatedFace::*)() const>(&StepVisual_TriangulatedFace::Triangles),
             R"#(Returns field Triangles)#" 
          )
        .def("SetTriangles",
             (void (StepVisual_TriangulatedFace::*)(  const handle<TColStd_HArray2OfInteger> &  ) ) static_cast<void (StepVisual_TriangulatedFace::*)(  const handle<TColStd_HArray2OfInteger> &  ) >(&StepVisual_TriangulatedFace::SetTriangles),
             R"#(Sets field Triangles)#"  , py::arg("theTriangles")
          )
        .def("NbTriangles",
             (Standard_Integer (StepVisual_TriangulatedFace::*)() const) static_cast<Standard_Integer (StepVisual_TriangulatedFace::*)() const>(&StepVisual_TriangulatedFace::NbTriangles),
             R"#(Returns number of Triangles)#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&StepVisual_TriangulatedFace::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&StepVisual_TriangulatedFace::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> & (StepVisual_TriangulatedFace::*)() const) static_cast< const handle<Standard_Type> & (StepVisual_TriangulatedFace::*)() const>(&StepVisual_TriangulatedFace::DynamicType),
             R"#()#"
             
         )
;

// functions

// ./opencascade/StepVisual_AnnotationCurveOccurrence.hxx
// ./opencascade/StepVisual_AnnotationCurveOccurrenceAndGeomReprItem.hxx
// ./opencascade/StepVisual_AnnotationFillArea.hxx
// ./opencascade/StepVisual_AnnotationFillAreaOccurrence.hxx
// ./opencascade/StepVisual_AnnotationOccurrence.hxx
// ./opencascade/StepVisual_AnnotationPlane.hxx
// ./opencascade/StepVisual_AnnotationPlaneElement.hxx
// ./opencascade/StepVisual_AnnotationText.hxx
// ./opencascade/StepVisual_AnnotationTextOccurrence.hxx
// ./opencascade/StepVisual_AreaInSet.hxx
// ./opencascade/StepVisual_AreaOrView.hxx
// ./opencascade/StepVisual_Array1OfAnnotationPlaneElement.hxx
// ./opencascade/StepVisual_Array1OfBoxCharacteristicSelect.hxx
// ./opencascade/StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect.hxx
// ./opencascade/StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect.hxx
// ./opencascade/StepVisual_Array1OfCurveStyleFontPattern.hxx
// ./opencascade/StepVisual_Array1OfDirectionCountSelect.hxx
// ./opencascade/StepVisual_Array1OfDraughtingCalloutElement.hxx
// ./opencascade/StepVisual_Array1OfFillStyleSelect.hxx
// ./opencascade/StepVisual_Array1OfInvisibleItem.hxx
// ./opencascade/StepVisual_Array1OfLayeredItem.hxx
// ./opencascade/StepVisual_Array1OfPresentationStyleAssignment.hxx
// ./opencascade/StepVisual_Array1OfPresentationStyleSelect.hxx
// ./opencascade/StepVisual_Array1OfRenderingPropertiesSelect.hxx
// ./opencascade/StepVisual_Array1OfStyleContextSelect.hxx
// ./opencascade/StepVisual_Array1OfSurfaceStyleElementSelect.hxx
// ./opencascade/StepVisual_Array1OfTessellatedEdgeOrVertex.hxx
// ./opencascade/StepVisual_Array1OfTessellatedStructuredItem.hxx
// ./opencascade/StepVisual_Array1OfTextOrCharacter.hxx
// ./opencascade/StepVisual_BackgroundColour.hxx
// ./opencascade/StepVisual_BoxCharacteristicSelect.hxx
// ./opencascade/StepVisual_CameraImage.hxx
// ./opencascade/StepVisual_CameraImage2dWithScale.hxx
// ./opencascade/StepVisual_CameraImage3dWithScale.hxx
// ./opencascade/StepVisual_CameraModel.hxx
// ./opencascade/StepVisual_CameraModelD2.hxx
// ./opencascade/StepVisual_CameraModelD3.hxx
// ./opencascade/StepVisual_CameraModelD3MultiClipping.hxx
// ./opencascade/StepVisual_CameraModelD3MultiClippingInterectionSelect.hxx
// ./opencascade/StepVisual_CameraModelD3MultiClippingIntersection.hxx
// ./opencascade/StepVisual_CameraModelD3MultiClippingUnion.hxx
// ./opencascade/StepVisual_CameraModelD3MultiClippingUnionSelect.hxx
// ./opencascade/StepVisual_CameraUsage.hxx
// ./opencascade/StepVisual_CentralOrParallel.hxx
// ./opencascade/StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel.hxx
// ./opencascade/StepVisual_Colour.hxx
// ./opencascade/StepVisual_ColourRgb.hxx
// ./opencascade/StepVisual_ColourSpecification.hxx
// ./opencascade/StepVisual_ComplexTriangulatedFace.hxx
// ./opencascade/StepVisual_ComplexTriangulatedSurfaceSet.hxx
// ./opencascade/StepVisual_CompositeText.hxx
// ./opencascade/StepVisual_CompositeTextWithExtent.hxx
// ./opencascade/StepVisual_ContextDependentInvisibility.hxx
// ./opencascade/StepVisual_ContextDependentOverRidingStyledItem.hxx
// ./opencascade/StepVisual_CoordinatesList.hxx
// ./opencascade/StepVisual_CubicBezierTessellatedEdge.hxx
// ./opencascade/StepVisual_CubicBezierTriangulatedFace.hxx
// ./opencascade/StepVisual_CurveStyle.hxx
// ./opencascade/StepVisual_CurveStyleFont.hxx
// ./opencascade/StepVisual_CurveStyleFontPattern.hxx
// ./opencascade/StepVisual_CurveStyleFontSelect.hxx
// ./opencascade/StepVisual_DirectionCountSelect.hxx
// ./opencascade/StepVisual_DraughtingAnnotationOccurrence.hxx
// ./opencascade/StepVisual_DraughtingCallout.hxx
// ./opencascade/StepVisual_DraughtingCalloutElement.hxx
// ./opencascade/StepVisual_DraughtingModel.hxx
// ./opencascade/StepVisual_DraughtingPreDefinedColour.hxx
// ./opencascade/StepVisual_DraughtingPreDefinedCurveFont.hxx
// ./opencascade/StepVisual_EdgeOrCurve.hxx
// ./opencascade/StepVisual_ExternallyDefinedCurveFont.hxx
// ./opencascade/StepVisual_ExternallyDefinedTextFont.hxx
// ./opencascade/StepVisual_FaceOrSurface.hxx
// ./opencascade/StepVisual_FillAreaStyle.hxx
// ./opencascade/StepVisual_FillAreaStyleColour.hxx
// ./opencascade/StepVisual_FillStyleSelect.hxx
// ./opencascade/StepVisual_FontSelect.hxx
// ./opencascade/StepVisual_HArray1OfAnnotationPlaneElement.hxx
// ./opencascade/StepVisual_HArray1OfBoxCharacteristicSelect.hxx
// ./opencascade/StepVisual_HArray1OfCameraModelD3MultiClippingInterectionSelect.hxx
// ./opencascade/StepVisual_HArray1OfCameraModelD3MultiClippingUnionSelect.hxx
// ./opencascade/StepVisual_HArray1OfCurveStyleFontPattern.hxx
// ./opencascade/StepVisual_HArray1OfDirectionCountSelect.hxx
// ./opencascade/StepVisual_HArray1OfDraughtingCalloutElement.hxx
// ./opencascade/StepVisual_HArray1OfFillStyleSelect.hxx
// ./opencascade/StepVisual_HArray1OfInvisibleItem.hxx
// ./opencascade/StepVisual_HArray1OfLayeredItem.hxx
// ./opencascade/StepVisual_HArray1OfPresentationStyleAssignment.hxx
// ./opencascade/StepVisual_HArray1OfPresentationStyleSelect.hxx
// ./opencascade/StepVisual_HArray1OfRenderingPropertiesSelect.hxx
// ./opencascade/StepVisual_HArray1OfStyleContextSelect.hxx
// ./opencascade/StepVisual_HArray1OfSurfaceStyleElementSelect.hxx
// ./opencascade/StepVisual_HArray1OfTessellatedEdgeOrVertex.hxx
// ./opencascade/StepVisual_HArray1OfTessellatedStructuredItem.hxx
// ./opencascade/StepVisual_HArray1OfTextOrCharacter.hxx
// ./opencascade/StepVisual_Invisibility.hxx
// ./opencascade/StepVisual_InvisibilityContext.hxx
// ./opencascade/StepVisual_InvisibleItem.hxx
// ./opencascade/StepVisual_LayeredItem.hxx
// ./opencascade/StepVisual_MarkerMember.hxx
// ./opencascade/StepVisual_MarkerSelect.hxx
// ./opencascade/StepVisual_MarkerType.hxx
// ./opencascade/StepVisual_MechanicalDesignGeometricPresentationArea.hxx
// ./opencascade/StepVisual_MechanicalDesignGeometricPresentationRepresentation.hxx
// ./opencascade/StepVisual_NullStyle.hxx
// ./opencascade/StepVisual_NullStyleMember.hxx
// ./opencascade/StepVisual_OverRidingStyledItem.hxx
// ./opencascade/StepVisual_PathOrCompositeCurve.hxx
// ./opencascade/StepVisual_PlanarBox.hxx
// ./opencascade/StepVisual_PlanarExtent.hxx
// ./opencascade/StepVisual_PointStyle.hxx
// ./opencascade/StepVisual_PreDefinedColour.hxx
// ./opencascade/StepVisual_PreDefinedCurveFont.hxx
// ./opencascade/StepVisual_PreDefinedItem.hxx
// ./opencascade/StepVisual_PreDefinedTextFont.hxx
// ./opencascade/StepVisual_PresentationArea.hxx
// ./opencascade/StepVisual_PresentationLayerAssignment.hxx
// ./opencascade/StepVisual_PresentationLayerUsage.hxx
// ./opencascade/StepVisual_PresentationRepresentation.hxx
// ./opencascade/StepVisual_PresentationRepresentationSelect.hxx
// ./opencascade/StepVisual_PresentationSet.hxx
// ./opencascade/StepVisual_PresentationSize.hxx
// ./opencascade/StepVisual_PresentationSizeAssignmentSelect.hxx
// ./opencascade/StepVisual_PresentationStyleAssignment.hxx
// ./opencascade/StepVisual_PresentationStyleByContext.hxx
// ./opencascade/StepVisual_PresentationStyleSelect.hxx
// ./opencascade/StepVisual_PresentationView.hxx
// ./opencascade/StepVisual_PresentedItem.hxx
// ./opencascade/StepVisual_PresentedItemRepresentation.hxx
// ./opencascade/StepVisual_RenderingPropertiesSelect.hxx
// ./opencascade/StepVisual_RepositionedTessellatedGeometricSet.hxx
// ./opencascade/StepVisual_RepositionedTessellatedItem.hxx
// ./opencascade/StepVisual_ShadingSurfaceMethod.hxx
// ./opencascade/StepVisual_StyleContextSelect.hxx
// ./opencascade/StepVisual_StyledItem.hxx
// ./opencascade/StepVisual_StyledItemTarget.hxx
// ./opencascade/StepVisual_SurfaceSide.hxx
// ./opencascade/StepVisual_SurfaceSideStyle.hxx
// ./opencascade/StepVisual_SurfaceStyleBoundary.hxx
// ./opencascade/StepVisual_SurfaceStyleControlGrid.hxx
// ./opencascade/StepVisual_SurfaceStyleElementSelect.hxx
// ./opencascade/StepVisual_SurfaceStyleFillArea.hxx
// ./opencascade/StepVisual_SurfaceStyleParameterLine.hxx
// ./opencascade/StepVisual_SurfaceStyleReflectanceAmbient.hxx
// ./opencascade/StepVisual_SurfaceStyleRendering.hxx
// ./opencascade/StepVisual_SurfaceStyleRenderingWithProperties.hxx
// ./opencascade/StepVisual_SurfaceStyleSegmentationCurve.hxx
// ./opencascade/StepVisual_SurfaceStyleSilhouette.hxx
// ./opencascade/StepVisual_SurfaceStyleTransparent.hxx
// ./opencascade/StepVisual_SurfaceStyleUsage.hxx
// ./opencascade/StepVisual_Template.hxx
// ./opencascade/StepVisual_TemplateInstance.hxx
// ./opencascade/StepVisual_TessellatedAnnotationOccurrence.hxx
// ./opencascade/StepVisual_TessellatedConnectingEdge.hxx
// ./opencascade/StepVisual_TessellatedCurveSet.hxx
// ./opencascade/StepVisual_TessellatedEdge.hxx
// ./opencascade/StepVisual_TessellatedEdgeOrVertex.hxx
// ./opencascade/StepVisual_TessellatedFace.hxx
// ./opencascade/StepVisual_TessellatedGeometricSet.hxx
// ./opencascade/StepVisual_TessellatedItem.hxx
// ./opencascade/StepVisual_TessellatedPointSet.hxx
// ./opencascade/StepVisual_TessellatedShapeRepresentation.hxx
// ./opencascade/StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx
// ./opencascade/StepVisual_TessellatedShell.hxx
// ./opencascade/StepVisual_TessellatedSolid.hxx
// ./opencascade/StepVisual_TessellatedStructuredItem.hxx
// ./opencascade/StepVisual_TessellatedSurfaceSet.hxx
// ./opencascade/StepVisual_TessellatedVertex.hxx
// ./opencascade/StepVisual_TessellatedWire.hxx
// ./opencascade/StepVisual_TextLiteral.hxx
// ./opencascade/StepVisual_TextOrCharacter.hxx
// ./opencascade/StepVisual_TextPath.hxx
// ./opencascade/StepVisual_TextStyle.hxx
// ./opencascade/StepVisual_TextStyleForDefinedFont.hxx
// ./opencascade/StepVisual_TextStyleWithBoxCharacteristics.hxx
// ./opencascade/StepVisual_TriangulatedFace.hxx
// ./opencascade/StepVisual_TriangulatedSurfaceSet.hxx
// ./opencascade/StepVisual_ViewVolume.hxx

// Additional functions


// operators

// register typdefs
    register_template_NCollection_Array1<StepVisual_AnnotationPlaneElement>(m,"StepVisual_Array1OfAnnotationPlaneElement");
    register_template_NCollection_Array1<StepVisual_BoxCharacteristicSelect>(m,"StepVisual_Array1OfBoxCharacteristicSelect");
    register_template_NCollection_Array1<StepVisual_CameraModelD3MultiClippingInterectionSelect>(m,"StepVisual_Array1OfCameraModelD3MultiClippingInterectionSelect");
    register_template_NCollection_Array1<StepVisual_CameraModelD3MultiClippingUnionSelect>(m,"StepVisual_Array1OfCameraModelD3MultiClippingUnionSelect");
    register_template_NCollection_Array1<opencascade::handle<StepVisual_CurveStyleFontPattern>>(m,"StepVisual_Array1OfCurveStyleFontPattern");
    register_template_NCollection_Array1<StepVisual_DirectionCountSelect>(m,"StepVisual_Array1OfDirectionCountSelect");
    register_template_NCollection_Array1<StepVisual_DraughtingCalloutElement>(m,"StepVisual_Array1OfDraughtingCalloutElement");
    register_template_NCollection_Array1<StepVisual_FillStyleSelect>(m,"StepVisual_Array1OfFillStyleSelect");
    register_template_NCollection_Array1<StepVisual_InvisibleItem>(m,"StepVisual_Array1OfInvisibleItem");
    register_template_NCollection_Array1<StepVisual_LayeredItem>(m,"StepVisual_Array1OfLayeredItem");
    register_template_NCollection_Array1<opencascade::handle<StepVisual_PresentationStyleAssignment>>(m,"StepVisual_Array1OfPresentationStyleAssignment");
    register_template_NCollection_Array1<StepVisual_PresentationStyleSelect>(m,"StepVisual_Array1OfPresentationStyleSelect");
    register_template_NCollection_Array1<StepVisual_RenderingPropertiesSelect>(m,"StepVisual_Array1OfRenderingPropertiesSelect");
    register_template_NCollection_Array1<StepVisual_StyleContextSelect>(m,"StepVisual_Array1OfStyleContextSelect");
    register_template_NCollection_Array1<StepVisual_SurfaceStyleElementSelect>(m,"StepVisual_Array1OfSurfaceStyleElementSelect");
    register_template_NCollection_Array1<StepVisual_TessellatedEdgeOrVertex>(m,"StepVisual_Array1OfTessellatedEdgeOrVertex");
    register_template_NCollection_Array1<opencascade::handle<StepVisual_TessellatedStructuredItem>>(m,"StepVisual_Array1OfTessellatedStructuredItem");
    register_template_NCollection_Array1<StepVisual_TextOrCharacter>(m,"StepVisual_Array1OfTextOrCharacter");
    register_template_NCollection_Vector<opencascade::handle<TColStd_HSequenceOfInteger>>(m,"StepVisual_VectorOfHSequenceOfInteger");
    register_template_NCollection_Array1<opencascade::handle<StepVisual_TessellatedItem>>(m,"StepVisual_Array1OfTessellatedItem");


// exceptions

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

};

// user-defined post-inclusion per module

// user-defined post
