
// 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 <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 <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 <Vrml_SFImage.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>

// module includes
#include <Vrml.hxx>
#include <Vrml_AsciiText.hxx>
#include <Vrml_AsciiTextJustification.hxx>
#include <Vrml_Cone.hxx>
#include <Vrml_ConeParts.hxx>
#include <Vrml_ConfigurationNode.hxx>
#include <Vrml_Coordinate3.hxx>
#include <Vrml_Cube.hxx>
#include <Vrml_Cylinder.hxx>
#include <Vrml_CylinderParts.hxx>
#include <Vrml_DirectionalLight.hxx>
#include <Vrml_FaceType.hxx>
#include <Vrml_FontStyle.hxx>
#include <Vrml_FontStyleFamily.hxx>
#include <Vrml_FontStyleStyle.hxx>
#include <Vrml_Group.hxx>
#include <Vrml_IndexedFaceSet.hxx>
#include <Vrml_IndexedLineSet.hxx>
#include <Vrml_Info.hxx>
#include <Vrml_Instancing.hxx>
#include <Vrml_LOD.hxx>
#include <Vrml_Material.hxx>
#include <Vrml_MaterialBinding.hxx>
#include <Vrml_MaterialBindingAndNormalBinding.hxx>
#include <Vrml_MatrixTransform.hxx>
#include <Vrml_Normal.hxx>
#include <Vrml_NormalBinding.hxx>
#include <Vrml_OrthographicCamera.hxx>
#include <Vrml_PerspectiveCamera.hxx>
#include <Vrml_PointLight.hxx>
#include <Vrml_PointSet.hxx>
#include <Vrml_Provider.hxx>
#include <Vrml_Rotation.hxx>
#include <Vrml_Scale.hxx>
#include <Vrml_Separator.hxx>
#include <Vrml_SeparatorRenderCulling.hxx>
#include <Vrml_SFImage.hxx>
#include <Vrml_SFImageNumber.hxx>
#include <Vrml_SFRotation.hxx>
#include <Vrml_ShapeHints.hxx>
#include <Vrml_ShapeType.hxx>
#include <Vrml_Sphere.hxx>
#include <Vrml_SpotLight.hxx>
#include <Vrml_Switch.hxx>
#include <Vrml_Texture2.hxx>
#include <Vrml_Texture2Transform.hxx>
#include <Vrml_Texture2Wrap.hxx>
#include <Vrml_TextureCoordinate2.hxx>
#include <Vrml_Transform.hxx>
#include <Vrml_TransformSeparator.hxx>
#include <Vrml_Translation.hxx>
#include <Vrml_VertexOrdering.hxx>
#include <Vrml_WWWAnchor.hxx>
#include <Vrml_WWWAnchorMap.hxx>
#include <Vrml_WWWInline.hxx>

// template related includes


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

// user-defined inclusion per module
        #include <DE_ConfigurationContext.hxx>
        #include <TDocStd_Document.hxx>
        #include <XSControl_WorkSession.hxx>
        #include <TopoDS_Shape.hxx>

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


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

//Python trampoline classes

// classes

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

    // default constructor
    register_default_constructor<Vrml , shared_ptr<Vrml>>(m,"Vrml");

    // nested enums

    static_cast<py::class_<Vrml , shared_ptr<Vrml>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("VrmlHeaderWriter_s",
                    (Standard_OStream & (*)( Standard_OStream &  ) ) static_cast<Standard_OStream & (*)( Standard_OStream &  ) >(&Vrml::VrmlHeaderWriter),
                    R"#(Writes a header in anOStream (VRML file). Writes one line of commentary in anOStream (VRML file).)#"  , py::arg("anOStream")
          )
        .def_static("CommentWriter_s",
                    (Standard_OStream & (*)(  const Standard_CString ,  Standard_OStream &  ) ) static_cast<Standard_OStream & (*)(  const Standard_CString ,  Standard_OStream &  ) >(&Vrml::CommentWriter),
                    R"#()#"  , py::arg("aComment"),  py::arg("anOStream")
          )
    // 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 Vrml_AsciiText from ./opencascade/Vrml_AsciiText.hxx
    klass = m.attr("Vrml_AsciiText");


    // nested enums

    static_cast<py::class_<Vrml_AsciiText ,opencascade::handle<Vrml_AsciiText>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const handle<TColStd_HArray1OfAsciiString> &, const Standard_Real, const Vrml_AsciiTextJustification, const Standard_Real >()  , py::arg("aString"),  py::arg("aSpacing"),  py::arg("aJustification"),  py::arg("aWidth") )
    // custom constructors
    // methods
        .def("SetString",
             (void (Vrml_AsciiText::*)(  const handle<TColStd_HArray1OfAsciiString> &  ) ) static_cast<void (Vrml_AsciiText::*)(  const handle<TColStd_HArray1OfAsciiString> &  ) >(&Vrml_AsciiText::SetString),
             R"#()#"  , py::arg("aString")
          )
        .def("String",
             (handle<TColStd_HArray1OfAsciiString> (Vrml_AsciiText::*)() const) static_cast<handle<TColStd_HArray1OfAsciiString> (Vrml_AsciiText::*)() const>(&Vrml_AsciiText::String),
             R"#()#" 
          )
        .def("SetSpacing",
             (void (Vrml_AsciiText::*)(  const Standard_Real  ) ) static_cast<void (Vrml_AsciiText::*)(  const Standard_Real  ) >(&Vrml_AsciiText::SetSpacing),
             R"#()#"  , py::arg("aSpacing")
          )
        .def("Spacing",
             (Standard_Real (Vrml_AsciiText::*)() const) static_cast<Standard_Real (Vrml_AsciiText::*)() const>(&Vrml_AsciiText::Spacing),
             R"#()#" 
          )
        .def("SetJustification",
             (void (Vrml_AsciiText::*)(  const Vrml_AsciiTextJustification  ) ) static_cast<void (Vrml_AsciiText::*)(  const Vrml_AsciiTextJustification  ) >(&Vrml_AsciiText::SetJustification),
             R"#()#"  , py::arg("aJustification")
          )
        .def("Justification",
             (Vrml_AsciiTextJustification (Vrml_AsciiText::*)() const) static_cast<Vrml_AsciiTextJustification (Vrml_AsciiText::*)() const>(&Vrml_AsciiText::Justification),
             R"#()#" 
          )
        .def("SetWidth",
             (void (Vrml_AsciiText::*)(  const Standard_Real  ) ) static_cast<void (Vrml_AsciiText::*)(  const Standard_Real  ) >(&Vrml_AsciiText::SetWidth),
             R"#()#"  , py::arg("aWidth")
          )
        .def("Width",
             (Standard_Real (Vrml_AsciiText::*)() const) static_cast<Standard_Real (Vrml_AsciiText::*)() const>(&Vrml_AsciiText::Width),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_AsciiText::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_AsciiText::*)( Standard_OStream &  ) const>(&Vrml_AsciiText::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_AsciiText::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_AsciiText::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> & (Vrml_AsciiText::*)() const) static_cast< const handle<Standard_Type> & (Vrml_AsciiText::*)() const>(&Vrml_AsciiText::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_Cone , shared_ptr<Vrml_Cone>  >>(klass)
    // constructors
        .def(py::init<  const Vrml_ConeParts, const Standard_Real, const Standard_Real >()  , py::arg("aParts")=static_cast< const Vrml_ConeParts>(Vrml_ConeALL),  py::arg("aBottomRadius")=static_cast< const Standard_Real>(1),  py::arg("aHeight")=static_cast< const Standard_Real>(2) )
    // custom constructors
    // methods
        .def("SetParts",
             (void (Vrml_Cone::*)(  const Vrml_ConeParts  ) ) static_cast<void (Vrml_Cone::*)(  const Vrml_ConeParts  ) >(&Vrml_Cone::SetParts),
             R"#()#"  , py::arg("aParts")
          )
        .def("Parts",
             (Vrml_ConeParts (Vrml_Cone::*)() const) static_cast<Vrml_ConeParts (Vrml_Cone::*)() const>(&Vrml_Cone::Parts),
             R"#()#" 
          )
        .def("SetBottomRadius",
             (void (Vrml_Cone::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cone::*)(  const Standard_Real  ) >(&Vrml_Cone::SetBottomRadius),
             R"#()#"  , py::arg("aBottomRadius")
          )
        .def("BottomRadius",
             (Standard_Real (Vrml_Cone::*)() const) static_cast<Standard_Real (Vrml_Cone::*)() const>(&Vrml_Cone::BottomRadius),
             R"#()#" 
          )
        .def("SetHeight",
             (void (Vrml_Cone::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cone::*)(  const Standard_Real  ) >(&Vrml_Cone::SetHeight),
             R"#()#"  , py::arg("aHeight")
          )
        .def("Height",
             (Standard_Real (Vrml_Cone::*)() const) static_cast<Standard_Real (Vrml_Cone::*)() const>(&Vrml_Cone::Height),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Cone::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Cone::*)( Standard_OStream &  ) const>(&Vrml_Cone::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Coordinate3 from ./opencascade/Vrml_Coordinate3.hxx
    klass = m.attr("Vrml_Coordinate3");


    // nested enums

    static_cast<py::class_<Vrml_Coordinate3 ,opencascade::handle<Vrml_Coordinate3>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  const handle<TColgp_HArray1OfVec> & >()  , py::arg("aPoint") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetPoint",
             (void (Vrml_Coordinate3::*)(  const handle<TColgp_HArray1OfVec> &  ) ) static_cast<void (Vrml_Coordinate3::*)(  const handle<TColgp_HArray1OfVec> &  ) >(&Vrml_Coordinate3::SetPoint),
             R"#()#"  , py::arg("aPoint")
          )
        .def("Point",
             (handle<TColgp_HArray1OfVec> (Vrml_Coordinate3::*)() const) static_cast<handle<TColgp_HArray1OfVec> (Vrml_Coordinate3::*)() const>(&Vrml_Coordinate3::Point),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Coordinate3::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Coordinate3::*)( Standard_OStream &  ) const>(&Vrml_Coordinate3::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_Coordinate3::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_Coordinate3::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> & (Vrml_Coordinate3::*)() const) static_cast< const handle<Standard_Type> & (Vrml_Coordinate3::*)() const>(&Vrml_Coordinate3::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_Cube , shared_ptr<Vrml_Cube>  >>(klass)
    // constructors
        .def(py::init<  const Standard_Real, const Standard_Real, const Standard_Real >()  , py::arg("aWidth")=static_cast< const Standard_Real>(2),  py::arg("aHeight")=static_cast< const Standard_Real>(2),  py::arg("aDepth")=static_cast< const Standard_Real>(2) )
    // custom constructors
    // methods
        .def("SetWidth",
             (void (Vrml_Cube::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cube::*)(  const Standard_Real  ) >(&Vrml_Cube::SetWidth),
             R"#()#"  , py::arg("aWidth")
          )
        .def("Width",
             (Standard_Real (Vrml_Cube::*)() const) static_cast<Standard_Real (Vrml_Cube::*)() const>(&Vrml_Cube::Width),
             R"#()#" 
          )
        .def("SetHeight",
             (void (Vrml_Cube::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cube::*)(  const Standard_Real  ) >(&Vrml_Cube::SetHeight),
             R"#()#"  , py::arg("aHeight")
          )
        .def("Height",
             (Standard_Real (Vrml_Cube::*)() const) static_cast<Standard_Real (Vrml_Cube::*)() const>(&Vrml_Cube::Height),
             R"#()#" 
          )
        .def("SetDepth",
             (void (Vrml_Cube::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cube::*)(  const Standard_Real  ) >(&Vrml_Cube::SetDepth),
             R"#()#"  , py::arg("aDepth")
          )
        .def("Depth",
             (Standard_Real (Vrml_Cube::*)() const) static_cast<Standard_Real (Vrml_Cube::*)() const>(&Vrml_Cube::Depth),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Cube::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Cube::*)( Standard_OStream &  ) const>(&Vrml_Cube::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Cylinder from ./opencascade/Vrml_Cylinder.hxx
    klass = m.attr("Vrml_Cylinder");


    // nested enums

    static_cast<py::class_<Vrml_Cylinder , shared_ptr<Vrml_Cylinder>  >>(klass)
    // constructors
        .def(py::init<  const Vrml_CylinderParts, const Standard_Real, const Standard_Real >()  , py::arg("aParts")=static_cast< const Vrml_CylinderParts>(Vrml_CylinderALL),  py::arg("aRadius")=static_cast< const Standard_Real>(1),  py::arg("aHeight")=static_cast< const Standard_Real>(2) )
    // custom constructors
    // methods
        .def("SetParts",
             (void (Vrml_Cylinder::*)(  const Vrml_CylinderParts  ) ) static_cast<void (Vrml_Cylinder::*)(  const Vrml_CylinderParts  ) >(&Vrml_Cylinder::SetParts),
             R"#()#"  , py::arg("aParts")
          )
        .def("Parts",
             (Vrml_CylinderParts (Vrml_Cylinder::*)() const) static_cast<Vrml_CylinderParts (Vrml_Cylinder::*)() const>(&Vrml_Cylinder::Parts),
             R"#()#" 
          )
        .def("SetRadius",
             (void (Vrml_Cylinder::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cylinder::*)(  const Standard_Real  ) >(&Vrml_Cylinder::SetRadius),
             R"#()#"  , py::arg("aRadius")
          )
        .def("Radius",
             (Standard_Real (Vrml_Cylinder::*)() const) static_cast<Standard_Real (Vrml_Cylinder::*)() const>(&Vrml_Cylinder::Radius),
             R"#()#" 
          )
        .def("SetHeight",
             (void (Vrml_Cylinder::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Cylinder::*)(  const Standard_Real  ) >(&Vrml_Cylinder::SetHeight),
             R"#()#"  , py::arg("aHeight")
          )
        .def("Height",
             (Standard_Real (Vrml_Cylinder::*)() const) static_cast<Standard_Real (Vrml_Cylinder::*)() const>(&Vrml_Cylinder::Height),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Cylinder::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Cylinder::*)( Standard_OStream &  ) const>(&Vrml_Cylinder::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_DirectionalLight from ./opencascade/Vrml_DirectionalLight.hxx
    klass = m.attr("Vrml_DirectionalLight");


    // nested enums

    static_cast<py::class_<Vrml_DirectionalLight , shared_ptr<Vrml_DirectionalLight>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Boolean, const Standard_Real, const Quantity_Color &, const gp_Vec & >()  , py::arg("aOnOff"),  py::arg("aIntensity"),  py::arg("aColor"),  py::arg("aDirection") )
    // custom constructors
    // methods
        .def("SetOnOff",
             (void (Vrml_DirectionalLight::*)(  const Standard_Boolean  ) ) static_cast<void (Vrml_DirectionalLight::*)(  const Standard_Boolean  ) >(&Vrml_DirectionalLight::SetOnOff),
             R"#()#"  , py::arg("aOnOff")
          )
        .def("OnOff",
             (Standard_Boolean (Vrml_DirectionalLight::*)() const) static_cast<Standard_Boolean (Vrml_DirectionalLight::*)() const>(&Vrml_DirectionalLight::OnOff),
             R"#()#" 
          )
        .def("SetIntensity",
             (void (Vrml_DirectionalLight::*)(  const Standard_Real  ) ) static_cast<void (Vrml_DirectionalLight::*)(  const Standard_Real  ) >(&Vrml_DirectionalLight::SetIntensity),
             R"#()#"  , py::arg("aIntensity")
          )
        .def("Intensity",
             (Standard_Real (Vrml_DirectionalLight::*)() const) static_cast<Standard_Real (Vrml_DirectionalLight::*)() const>(&Vrml_DirectionalLight::Intensity),
             R"#()#" 
          )
        .def("SetColor",
             (void (Vrml_DirectionalLight::*)(  const Quantity_Color &  ) ) static_cast<void (Vrml_DirectionalLight::*)(  const Quantity_Color &  ) >(&Vrml_DirectionalLight::SetColor),
             R"#()#"  , py::arg("aColor")
          )
        .def("Color",
             (Quantity_Color (Vrml_DirectionalLight::*)() const) static_cast<Quantity_Color (Vrml_DirectionalLight::*)() const>(&Vrml_DirectionalLight::Color),
             R"#()#" 
          )
        .def("SetDirection",
             (void (Vrml_DirectionalLight::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_DirectionalLight::*)(  const gp_Vec &  ) >(&Vrml_DirectionalLight::SetDirection),
             R"#()#"  , py::arg("aDirection")
          )
        .def("Direction",
             (gp_Vec (Vrml_DirectionalLight::*)() const) static_cast<gp_Vec (Vrml_DirectionalLight::*)() const>(&Vrml_DirectionalLight::Direction),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_DirectionalLight::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_DirectionalLight::*)( Standard_OStream &  ) const>(&Vrml_DirectionalLight::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_FontStyle from ./opencascade/Vrml_FontStyle.hxx
    klass = m.attr("Vrml_FontStyle");


    // nested enums

    static_cast<py::class_<Vrml_FontStyle , shared_ptr<Vrml_FontStyle>  >>(klass)
    // constructors
        .def(py::init<  const Standard_Real, const Vrml_FontStyleFamily, const Vrml_FontStyleStyle >()  , py::arg("aSize")=static_cast< const Standard_Real>(10),  py::arg("aFamily")=static_cast< const Vrml_FontStyleFamily>(Vrml_SERIF),  py::arg("aStyle")=static_cast< const Vrml_FontStyleStyle>(Vrml_NONE) )
    // custom constructors
    // methods
        .def("SetSize",
             (void (Vrml_FontStyle::*)(  const Standard_Real  ) ) static_cast<void (Vrml_FontStyle::*)(  const Standard_Real  ) >(&Vrml_FontStyle::SetSize),
             R"#()#"  , py::arg("aSize")
          )
        .def("Size",
             (Standard_Real (Vrml_FontStyle::*)() const) static_cast<Standard_Real (Vrml_FontStyle::*)() const>(&Vrml_FontStyle::Size),
             R"#()#" 
          )
        .def("SetFamily",
             (void (Vrml_FontStyle::*)(  const Vrml_FontStyleFamily  ) ) static_cast<void (Vrml_FontStyle::*)(  const Vrml_FontStyleFamily  ) >(&Vrml_FontStyle::SetFamily),
             R"#()#"  , py::arg("aFamily")
          )
        .def("Family",
             (Vrml_FontStyleFamily (Vrml_FontStyle::*)() const) static_cast<Vrml_FontStyleFamily (Vrml_FontStyle::*)() const>(&Vrml_FontStyle::Family),
             R"#()#" 
          )
        .def("SetStyle",
             (void (Vrml_FontStyle::*)(  const Vrml_FontStyleStyle  ) ) static_cast<void (Vrml_FontStyle::*)(  const Vrml_FontStyleStyle  ) >(&Vrml_FontStyle::SetStyle),
             R"#()#"  , py::arg("aStyle")
          )
        .def("Style",
             (Vrml_FontStyleStyle (Vrml_FontStyle::*)() const) static_cast<Vrml_FontStyleStyle (Vrml_FontStyle::*)() const>(&Vrml_FontStyle::Style),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_FontStyle::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_FontStyle::*)( Standard_OStream &  ) const>(&Vrml_FontStyle::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Group from ./opencascade/Vrml_Group.hxx
    klass = m.attr("Vrml_Group");


    // nested enums

    static_cast<py::class_<Vrml_Group , shared_ptr<Vrml_Group>  >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Print",
             (Standard_OStream & (Vrml_Group::*)( Standard_OStream &  ) ) static_cast<Standard_OStream & (Vrml_Group::*)( Standard_OStream &  ) >(&Vrml_Group::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_IndexedFaceSet from ./opencascade/Vrml_IndexedFaceSet.hxx
    klass = m.attr("Vrml_IndexedFaceSet");


    // nested enums

    static_cast<py::class_<Vrml_IndexedFaceSet ,opencascade::handle<Vrml_IndexedFaceSet>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  const handle<TColStd_HArray1OfInteger> &, const handle<TColStd_HArray1OfInteger> &, const handle<TColStd_HArray1OfInteger> &, const handle<TColStd_HArray1OfInteger> & >()  , py::arg("aCoordIndex"),  py::arg("aMaterialIndex"),  py::arg("aNormalIndex"),  py::arg("aTextureCoordIndex") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetCoordIndex",
             (void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedFaceSet::SetCoordIndex),
             R"#()#"  , py::arg("aCoordIndex")
          )
        .def("CoordIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const>(&Vrml_IndexedFaceSet::CoordIndex),
             R"#()#" 
          )
        .def("SetMaterialIndex",
             (void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedFaceSet::SetMaterialIndex),
             R"#()#"  , py::arg("aMaterialIndex")
          )
        .def("MaterialIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const>(&Vrml_IndexedFaceSet::MaterialIndex),
             R"#()#" 
          )
        .def("SetNormalIndex",
             (void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedFaceSet::SetNormalIndex),
             R"#()#"  , py::arg("aNormalIndex")
          )
        .def("NormalIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const>(&Vrml_IndexedFaceSet::NormalIndex),
             R"#()#" 
          )
        .def("SetTextureCoordIndex",
             (void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedFaceSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedFaceSet::SetTextureCoordIndex),
             R"#()#"  , py::arg("aTextureCoordIndex")
          )
        .def("TextureCoordIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedFaceSet::*)() const>(&Vrml_IndexedFaceSet::TextureCoordIndex),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_IndexedFaceSet::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_IndexedFaceSet::*)( Standard_OStream &  ) const>(&Vrml_IndexedFaceSet::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_IndexedFaceSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_IndexedFaceSet::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> & (Vrml_IndexedFaceSet::*)() const) static_cast< const handle<Standard_Type> & (Vrml_IndexedFaceSet::*)() const>(&Vrml_IndexedFaceSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_IndexedLineSet ,opencascade::handle<Vrml_IndexedLineSet>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  const handle<TColStd_HArray1OfInteger> &, const handle<TColStd_HArray1OfInteger> &, const handle<TColStd_HArray1OfInteger> &, const handle<TColStd_HArray1OfInteger> & >()  , py::arg("aCoordIndex"),  py::arg("aMaterialIndex"),  py::arg("aNormalIndex"),  py::arg("aTextureCoordIndex") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetCoordIndex",
             (void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedLineSet::SetCoordIndex),
             R"#()#"  , py::arg("aCoordIndex")
          )
        .def("CoordIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const>(&Vrml_IndexedLineSet::CoordIndex),
             R"#()#" 
          )
        .def("SetMaterialIndex",
             (void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedLineSet::SetMaterialIndex),
             R"#()#"  , py::arg("aMaterialIndex")
          )
        .def("MaterialIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const>(&Vrml_IndexedLineSet::MaterialIndex),
             R"#()#" 
          )
        .def("SetNormalIndex",
             (void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedLineSet::SetNormalIndex),
             R"#()#"  , py::arg("aNormalIndex")
          )
        .def("NormalIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const>(&Vrml_IndexedLineSet::NormalIndex),
             R"#()#" 
          )
        .def("SetTextureCoordIndex",
             (void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_IndexedLineSet::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_IndexedLineSet::SetTextureCoordIndex),
             R"#()#"  , py::arg("aTextureCoordIndex")
          )
        .def("TextureCoordIndex",
             (handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_IndexedLineSet::*)() const>(&Vrml_IndexedLineSet::TextureCoordIndex),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_IndexedLineSet::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_IndexedLineSet::*)( Standard_OStream &  ) const>(&Vrml_IndexedLineSet::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_IndexedLineSet::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_IndexedLineSet::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> & (Vrml_IndexedLineSet::*)() const) static_cast< const handle<Standard_Type> & (Vrml_IndexedLineSet::*)() const>(&Vrml_IndexedLineSet::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_Info , shared_ptr<Vrml_Info>  >>(klass)
    // constructors
        .def(py::init<  const TCollection_AsciiString & >()  , py::arg("aString")=static_cast< const TCollection_AsciiString &>("<Undefined info>") )
    // custom constructors
    // methods
        .def("SetString",
             (void (Vrml_Info::*)(  const TCollection_AsciiString &  ) ) static_cast<void (Vrml_Info::*)(  const TCollection_AsciiString &  ) >(&Vrml_Info::SetString),
             R"#()#"  , py::arg("aString")
          )
        .def("String",
             (TCollection_AsciiString (Vrml_Info::*)() const) static_cast<TCollection_AsciiString (Vrml_Info::*)() const>(&Vrml_Info::String),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Info::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Info::*)( Standard_OStream &  ) const>(&Vrml_Info::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Instancing from ./opencascade/Vrml_Instancing.hxx
    klass = m.attr("Vrml_Instancing");


    // nested enums

    static_cast<py::class_<Vrml_Instancing , shared_ptr<Vrml_Instancing>  >>(klass)
    // constructors
        .def(py::init<  const TCollection_AsciiString & >()  , py::arg("aString") )
    // custom constructors
    // methods
        .def("DEF",
             (Standard_OStream & (Vrml_Instancing::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Instancing::*)( Standard_OStream &  ) const>(&Vrml_Instancing::DEF),
             R"#(Adds "USE <myName>" in anOStream (VRML file).)#"  , py::arg("anOStream")
          )
        .def("USE",
             (Standard_OStream & (Vrml_Instancing::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Instancing::*)( Standard_OStream &  ) const>(&Vrml_Instancing::USE),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_LOD from ./opencascade/Vrml_LOD.hxx
    klass = m.attr("Vrml_LOD");


    // nested enums

    static_cast<py::class_<Vrml_LOD ,opencascade::handle<Vrml_LOD>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const handle<TColStd_HArray1OfReal> &, const gp_Vec & >()  , py::arg("aRange"),  py::arg("aCenter") )
    // custom constructors
    // methods
        .def("SetRange",
             (void (Vrml_LOD::*)(  const handle<TColStd_HArray1OfReal> &  ) ) static_cast<void (Vrml_LOD::*)(  const handle<TColStd_HArray1OfReal> &  ) >(&Vrml_LOD::SetRange),
             R"#()#"  , py::arg("aRange")
          )
        .def("Range",
             (handle<TColStd_HArray1OfReal> (Vrml_LOD::*)() const) static_cast<handle<TColStd_HArray1OfReal> (Vrml_LOD::*)() const>(&Vrml_LOD::Range),
             R"#()#" 
          )
        .def("SetCenter",
             (void (Vrml_LOD::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_LOD::*)(  const gp_Vec &  ) >(&Vrml_LOD::SetCenter),
             R"#()#"  , py::arg("aCenter")
          )
        .def("Center",
             (gp_Vec (Vrml_LOD::*)() const) static_cast<gp_Vec (Vrml_LOD::*)() const>(&Vrml_LOD::Center),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_LOD::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_LOD::*)( Standard_OStream &  ) const>(&Vrml_LOD::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_LOD::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_LOD::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> & (Vrml_LOD::*)() const) static_cast< const handle<Standard_Type> & (Vrml_LOD::*)() const>(&Vrml_LOD::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_Material ,opencascade::handle<Vrml_Material>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  const handle<Quantity_HArray1OfColor> &, const handle<Quantity_HArray1OfColor> &, const handle<Quantity_HArray1OfColor> &, const handle<Quantity_HArray1OfColor> &, const handle<TColStd_HArray1OfReal> &, const handle<TColStd_HArray1OfReal> & >()  , py::arg("aAmbientColor"),  py::arg("aDiffuseColor"),  py::arg("aSpecularColor"),  py::arg("aEmissiveColor"),  py::arg("aShininess"),  py::arg("aTransparency") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetAmbientColor",
             (void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) ) static_cast<void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) >(&Vrml_Material::SetAmbientColor),
             R"#()#"  , py::arg("aAmbientColor")
          )
        .def("AmbientColor",
             (handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const) static_cast<handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const>(&Vrml_Material::AmbientColor),
             R"#()#" 
          )
        .def("SetDiffuseColor",
             (void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) ) static_cast<void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) >(&Vrml_Material::SetDiffuseColor),
             R"#()#"  , py::arg("aDiffuseColor")
          )
        .def("DiffuseColor",
             (handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const) static_cast<handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const>(&Vrml_Material::DiffuseColor),
             R"#()#" 
          )
        .def("SetSpecularColor",
             (void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) ) static_cast<void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) >(&Vrml_Material::SetSpecularColor),
             R"#()#"  , py::arg("aSpecularColor")
          )
        .def("SpecularColor",
             (handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const) static_cast<handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const>(&Vrml_Material::SpecularColor),
             R"#()#" 
          )
        .def("SetEmissiveColor",
             (void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) ) static_cast<void (Vrml_Material::*)(  const handle<Quantity_HArray1OfColor> &  ) >(&Vrml_Material::SetEmissiveColor),
             R"#()#"  , py::arg("aEmissiveColor")
          )
        .def("EmissiveColor",
             (handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const) static_cast<handle<Quantity_HArray1OfColor> (Vrml_Material::*)() const>(&Vrml_Material::EmissiveColor),
             R"#()#" 
          )
        .def("SetShininess",
             (void (Vrml_Material::*)(  const handle<TColStd_HArray1OfReal> &  ) ) static_cast<void (Vrml_Material::*)(  const handle<TColStd_HArray1OfReal> &  ) >(&Vrml_Material::SetShininess),
             R"#()#"  , py::arg("aShininess")
          )
        .def("Shininess",
             (handle<TColStd_HArray1OfReal> (Vrml_Material::*)() const) static_cast<handle<TColStd_HArray1OfReal> (Vrml_Material::*)() const>(&Vrml_Material::Shininess),
             R"#()#" 
          )
        .def("SetTransparency",
             (void (Vrml_Material::*)(  const handle<TColStd_HArray1OfReal> &  ) ) static_cast<void (Vrml_Material::*)(  const handle<TColStd_HArray1OfReal> &  ) >(&Vrml_Material::SetTransparency),
             R"#()#"  , py::arg("aTransparency")
          )
        .def("Transparency",
             (handle<TColStd_HArray1OfReal> (Vrml_Material::*)() const) static_cast<handle<TColStd_HArray1OfReal> (Vrml_Material::*)() const>(&Vrml_Material::Transparency),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Material::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Material::*)( Standard_OStream &  ) const>(&Vrml_Material::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_Material::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_Material::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> & (Vrml_Material::*)() const) static_cast< const handle<Standard_Type> & (Vrml_Material::*)() const>(&Vrml_Material::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_MaterialBinding , shared_ptr<Vrml_MaterialBinding>  >>(klass)
    // constructors
        .def(py::init<  const Vrml_MaterialBindingAndNormalBinding >()  , py::arg("aValue") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetValue",
             (void (Vrml_MaterialBinding::*)(  const Vrml_MaterialBindingAndNormalBinding  ) ) static_cast<void (Vrml_MaterialBinding::*)(  const Vrml_MaterialBindingAndNormalBinding  ) >(&Vrml_MaterialBinding::SetValue),
             R"#()#"  , py::arg("aValue")
          )
        .def("Value",
             (Vrml_MaterialBindingAndNormalBinding (Vrml_MaterialBinding::*)() const) static_cast<Vrml_MaterialBindingAndNormalBinding (Vrml_MaterialBinding::*)() const>(&Vrml_MaterialBinding::Value),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_MaterialBinding::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_MaterialBinding::*)( Standard_OStream &  ) const>(&Vrml_MaterialBinding::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_MatrixTransform from ./opencascade/Vrml_MatrixTransform.hxx
    klass = m.attr("Vrml_MatrixTransform");


    // nested enums

    static_cast<py::class_<Vrml_MatrixTransform , shared_ptr<Vrml_MatrixTransform>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Trsf & >()  , py::arg("aMatrix") )
    // custom constructors
    // methods
        .def("SetMatrix",
             (void (Vrml_MatrixTransform::*)(  const gp_Trsf &  ) ) static_cast<void (Vrml_MatrixTransform::*)(  const gp_Trsf &  ) >(&Vrml_MatrixTransform::SetMatrix),
             R"#()#"  , py::arg("aMatrix")
          )
        .def("Matrix",
             (gp_Trsf (Vrml_MatrixTransform::*)() const) static_cast<gp_Trsf (Vrml_MatrixTransform::*)() const>(&Vrml_MatrixTransform::Matrix),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_MatrixTransform::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_MatrixTransform::*)( Standard_OStream &  ) const>(&Vrml_MatrixTransform::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Normal from ./opencascade/Vrml_Normal.hxx
    klass = m.attr("Vrml_Normal");


    // nested enums

    static_cast<py::class_<Vrml_Normal ,opencascade::handle<Vrml_Normal>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  const handle<TColgp_HArray1OfVec> & >()  , py::arg("aVector") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetVector",
             (void (Vrml_Normal::*)(  const handle<TColgp_HArray1OfVec> &  ) ) static_cast<void (Vrml_Normal::*)(  const handle<TColgp_HArray1OfVec> &  ) >(&Vrml_Normal::SetVector),
             R"#()#"  , py::arg("aVector")
          )
        .def("Vector",
             (handle<TColgp_HArray1OfVec> (Vrml_Normal::*)() const) static_cast<handle<TColgp_HArray1OfVec> (Vrml_Normal::*)() const>(&Vrml_Normal::Vector),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Normal::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Normal::*)( Standard_OStream &  ) const>(&Vrml_Normal::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_Normal::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_Normal::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> & (Vrml_Normal::*)() const) static_cast< const handle<Standard_Type> & (Vrml_Normal::*)() const>(&Vrml_Normal::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_NormalBinding , shared_ptr<Vrml_NormalBinding>  >>(klass)
    // constructors
        .def(py::init<  const Vrml_MaterialBindingAndNormalBinding >()  , py::arg("aValue") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetValue",
             (void (Vrml_NormalBinding::*)(  const Vrml_MaterialBindingAndNormalBinding  ) ) static_cast<void (Vrml_NormalBinding::*)(  const Vrml_MaterialBindingAndNormalBinding  ) >(&Vrml_NormalBinding::SetValue),
             R"#()#"  , py::arg("aValue")
          )
        .def("Value",
             (Vrml_MaterialBindingAndNormalBinding (Vrml_NormalBinding::*)() const) static_cast<Vrml_MaterialBindingAndNormalBinding (Vrml_NormalBinding::*)() const>(&Vrml_NormalBinding::Value),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_NormalBinding::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_NormalBinding::*)( Standard_OStream &  ) const>(&Vrml_NormalBinding::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_OrthographicCamera from ./opencascade/Vrml_OrthographicCamera.hxx
    klass = m.attr("Vrml_OrthographicCamera");


    // nested enums

    static_cast<py::class_<Vrml_OrthographicCamera , shared_ptr<Vrml_OrthographicCamera>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Vec &, const Vrml_SFRotation &, const Standard_Real, const Standard_Real >()  , py::arg("aPosition"),  py::arg("aOrientation"),  py::arg("aFocalDistance"),  py::arg("aHeight") )
    // custom constructors
    // methods
        .def("SetPosition",
             (void (Vrml_OrthographicCamera::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_OrthographicCamera::*)(  const gp_Vec &  ) >(&Vrml_OrthographicCamera::SetPosition),
             R"#()#"  , py::arg("aPosition")
          )
        .def("Position",
             (gp_Vec (Vrml_OrthographicCamera::*)() const) static_cast<gp_Vec (Vrml_OrthographicCamera::*)() const>(&Vrml_OrthographicCamera::Position),
             R"#()#" 
          )
        .def("SetOrientation",
             (void (Vrml_OrthographicCamera::*)(  const Vrml_SFRotation &  ) ) static_cast<void (Vrml_OrthographicCamera::*)(  const Vrml_SFRotation &  ) >(&Vrml_OrthographicCamera::SetOrientation),
             R"#()#"  , py::arg("aOrientation")
          )
        .def("Orientation",
             (Vrml_SFRotation (Vrml_OrthographicCamera::*)() const) static_cast<Vrml_SFRotation (Vrml_OrthographicCamera::*)() const>(&Vrml_OrthographicCamera::Orientation),
             R"#()#" 
          )
        .def("SetFocalDistance",
             (void (Vrml_OrthographicCamera::*)(  const Standard_Real  ) ) static_cast<void (Vrml_OrthographicCamera::*)(  const Standard_Real  ) >(&Vrml_OrthographicCamera::SetFocalDistance),
             R"#()#"  , py::arg("aFocalDistance")
          )
        .def("FocalDistance",
             (Standard_Real (Vrml_OrthographicCamera::*)() const) static_cast<Standard_Real (Vrml_OrthographicCamera::*)() const>(&Vrml_OrthographicCamera::FocalDistance),
             R"#()#" 
          )
        .def("SetHeight",
             (void (Vrml_OrthographicCamera::*)(  const Standard_Real  ) ) static_cast<void (Vrml_OrthographicCamera::*)(  const Standard_Real  ) >(&Vrml_OrthographicCamera::SetHeight),
             R"#()#"  , py::arg("aHeight")
          )
        .def("Height",
             (Standard_Real (Vrml_OrthographicCamera::*)() const) static_cast<Standard_Real (Vrml_OrthographicCamera::*)() const>(&Vrml_OrthographicCamera::Height),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_OrthographicCamera::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_OrthographicCamera::*)( Standard_OStream &  ) const>(&Vrml_OrthographicCamera::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_PerspectiveCamera from ./opencascade/Vrml_PerspectiveCamera.hxx
    klass = m.attr("Vrml_PerspectiveCamera");


    // nested enums

    static_cast<py::class_<Vrml_PerspectiveCamera , shared_ptr<Vrml_PerspectiveCamera>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Vec &, const Vrml_SFRotation &, const Standard_Real, const Standard_Real >()  , py::arg("aPosition"),  py::arg("aOrientation"),  py::arg("aFocalDistance"),  py::arg("aHeightAngle") )
    // custom constructors
    // methods
        .def("SetPosition",
             (void (Vrml_PerspectiveCamera::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_PerspectiveCamera::*)(  const gp_Vec &  ) >(&Vrml_PerspectiveCamera::SetPosition),
             R"#()#"  , py::arg("aPosition")
          )
        .def("Position",
             (gp_Vec (Vrml_PerspectiveCamera::*)() const) static_cast<gp_Vec (Vrml_PerspectiveCamera::*)() const>(&Vrml_PerspectiveCamera::Position),
             R"#()#" 
          )
        .def("SetOrientation",
             (void (Vrml_PerspectiveCamera::*)(  const Vrml_SFRotation &  ) ) static_cast<void (Vrml_PerspectiveCamera::*)(  const Vrml_SFRotation &  ) >(&Vrml_PerspectiveCamera::SetOrientation),
             R"#()#"  , py::arg("aOrientation")
          )
        .def("Orientation",
             (Vrml_SFRotation (Vrml_PerspectiveCamera::*)() const) static_cast<Vrml_SFRotation (Vrml_PerspectiveCamera::*)() const>(&Vrml_PerspectiveCamera::Orientation),
             R"#()#" 
          )
        .def("SetFocalDistance",
             (void (Vrml_PerspectiveCamera::*)(  const Standard_Real  ) ) static_cast<void (Vrml_PerspectiveCamera::*)(  const Standard_Real  ) >(&Vrml_PerspectiveCamera::SetFocalDistance),
             R"#()#"  , py::arg("aFocalDistance")
          )
        .def("FocalDistance",
             (Standard_Real (Vrml_PerspectiveCamera::*)() const) static_cast<Standard_Real (Vrml_PerspectiveCamera::*)() const>(&Vrml_PerspectiveCamera::FocalDistance),
             R"#()#" 
          )
        .def("SetAngle",
             (void (Vrml_PerspectiveCamera::*)(  const Standard_Real  ) ) static_cast<void (Vrml_PerspectiveCamera::*)(  const Standard_Real  ) >(&Vrml_PerspectiveCamera::SetAngle),
             R"#()#"  , py::arg("aHeightAngle")
          )
        .def("Angle",
             (Standard_Real (Vrml_PerspectiveCamera::*)() const) static_cast<Standard_Real (Vrml_PerspectiveCamera::*)() const>(&Vrml_PerspectiveCamera::Angle),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_PerspectiveCamera::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_PerspectiveCamera::*)( Standard_OStream &  ) const>(&Vrml_PerspectiveCamera::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_PointLight from ./opencascade/Vrml_PointLight.hxx
    klass = m.attr("Vrml_PointLight");


    // nested enums

    static_cast<py::class_<Vrml_PointLight , shared_ptr<Vrml_PointLight>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Boolean, const Standard_Real, const Quantity_Color &, const gp_Vec & >()  , py::arg("aOnOff"),  py::arg("aIntensity"),  py::arg("aColor"),  py::arg("aLocation") )
    // custom constructors
    // methods
        .def("SetOnOff",
             (void (Vrml_PointLight::*)(  const Standard_Boolean  ) ) static_cast<void (Vrml_PointLight::*)(  const Standard_Boolean  ) >(&Vrml_PointLight::SetOnOff),
             R"#()#"  , py::arg("aOnOff")
          )
        .def("OnOff",
             (Standard_Boolean (Vrml_PointLight::*)() const) static_cast<Standard_Boolean (Vrml_PointLight::*)() const>(&Vrml_PointLight::OnOff),
             R"#()#" 
          )
        .def("SetIntensity",
             (void (Vrml_PointLight::*)(  const Standard_Real  ) ) static_cast<void (Vrml_PointLight::*)(  const Standard_Real  ) >(&Vrml_PointLight::SetIntensity),
             R"#()#"  , py::arg("aIntensity")
          )
        .def("Intensity",
             (Standard_Real (Vrml_PointLight::*)() const) static_cast<Standard_Real (Vrml_PointLight::*)() const>(&Vrml_PointLight::Intensity),
             R"#()#" 
          )
        .def("SetColor",
             (void (Vrml_PointLight::*)(  const Quantity_Color &  ) ) static_cast<void (Vrml_PointLight::*)(  const Quantity_Color &  ) >(&Vrml_PointLight::SetColor),
             R"#()#"  , py::arg("aColor")
          )
        .def("Color",
             (Quantity_Color (Vrml_PointLight::*)() const) static_cast<Quantity_Color (Vrml_PointLight::*)() const>(&Vrml_PointLight::Color),
             R"#()#" 
          )
        .def("SetLocation",
             (void (Vrml_PointLight::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_PointLight::*)(  const gp_Vec &  ) >(&Vrml_PointLight::SetLocation),
             R"#()#"  , py::arg("aLocation")
          )
        .def("Location",
             (gp_Vec (Vrml_PointLight::*)() const) static_cast<gp_Vec (Vrml_PointLight::*)() const>(&Vrml_PointLight::Location),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_PointLight::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_PointLight::*)( Standard_OStream &  ) const>(&Vrml_PointLight::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_PointSet from ./opencascade/Vrml_PointSet.hxx
    klass = m.attr("Vrml_PointSet");


    // nested enums

    static_cast<py::class_<Vrml_PointSet , shared_ptr<Vrml_PointSet>  >>(klass)
    // constructors
        .def(py::init<  const Standard_Integer, const Standard_Integer >()  , py::arg("aStartIndex")=static_cast< const Standard_Integer>(0),  py::arg("aNumPoints")=static_cast< const Standard_Integer>(- 1) )
    // custom constructors
    // methods
        .def("SetStartIndex",
             (void (Vrml_PointSet::*)(  const Standard_Integer  ) ) static_cast<void (Vrml_PointSet::*)(  const Standard_Integer  ) >(&Vrml_PointSet::SetStartIndex),
             R"#()#"  , py::arg("aStartIndex")
          )
        .def("StartIndex",
             (Standard_Integer (Vrml_PointSet::*)() const) static_cast<Standard_Integer (Vrml_PointSet::*)() const>(&Vrml_PointSet::StartIndex),
             R"#()#" 
          )
        .def("SetNumPoints",
             (void (Vrml_PointSet::*)(  const Standard_Integer  ) ) static_cast<void (Vrml_PointSet::*)(  const Standard_Integer  ) >(&Vrml_PointSet::SetNumPoints),
             R"#()#"  , py::arg("aNumPoints")
          )
        .def("NumPoints",
             (Standard_Integer (Vrml_PointSet::*)() const) static_cast<Standard_Integer (Vrml_PointSet::*)() const>(&Vrml_PointSet::NumPoints),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_PointSet::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_PointSet::*)( Standard_OStream &  ) const>(&Vrml_PointSet::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Rotation from ./opencascade/Vrml_Rotation.hxx
    klass = m.attr("Vrml_Rotation");


    // nested enums

    static_cast<py::class_<Vrml_Rotation , shared_ptr<Vrml_Rotation>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Vrml_SFRotation & >()  , py::arg("aRotation") )
    // custom constructors
    // methods
        .def("SetRotation",
             (void (Vrml_Rotation::*)(  const Vrml_SFRotation &  ) ) static_cast<void (Vrml_Rotation::*)(  const Vrml_SFRotation &  ) >(&Vrml_Rotation::SetRotation),
             R"#()#"  , py::arg("aRotation")
          )
        .def("Rotation",
             (Vrml_SFRotation (Vrml_Rotation::*)() const) static_cast<Vrml_SFRotation (Vrml_Rotation::*)() const>(&Vrml_Rotation::Rotation),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Rotation::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Rotation::*)( Standard_OStream &  ) const>(&Vrml_Rotation::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_SFImage from ./opencascade/Vrml_SFImage.hxx
    klass = m.attr("Vrml_SFImage");


    // nested enums

    static_cast<py::class_<Vrml_SFImage ,opencascade::handle<Vrml_SFImage>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Integer, const Standard_Integer, const Vrml_SFImageNumber, const handle<TColStd_HArray1OfInteger> & >()  , py::arg("aWidth"),  py::arg("aHeight"),  py::arg("aNumber"),  py::arg("anArray") )
    // custom constructors
    // methods
        .def("SetWidth",
             (void (Vrml_SFImage::*)(  const Standard_Integer  ) ) static_cast<void (Vrml_SFImage::*)(  const Standard_Integer  ) >(&Vrml_SFImage::SetWidth),
             R"#()#"  , py::arg("aWidth")
          )
        .def("Width",
             (Standard_Integer (Vrml_SFImage::*)() const) static_cast<Standard_Integer (Vrml_SFImage::*)() const>(&Vrml_SFImage::Width),
             R"#()#" 
          )
        .def("SetHeight",
             (void (Vrml_SFImage::*)(  const Standard_Integer  ) ) static_cast<void (Vrml_SFImage::*)(  const Standard_Integer  ) >(&Vrml_SFImage::SetHeight),
             R"#()#"  , py::arg("aHeight")
          )
        .def("Height",
             (Standard_Integer (Vrml_SFImage::*)() const) static_cast<Standard_Integer (Vrml_SFImage::*)() const>(&Vrml_SFImage::Height),
             R"#()#" 
          )
        .def("SetNumber",
             (void (Vrml_SFImage::*)(  const Vrml_SFImageNumber  ) ) static_cast<void (Vrml_SFImage::*)(  const Vrml_SFImageNumber  ) >(&Vrml_SFImage::SetNumber),
             R"#()#"  , py::arg("aNumber")
          )
        .def("Number",
             (Vrml_SFImageNumber (Vrml_SFImage::*)() const) static_cast<Vrml_SFImageNumber (Vrml_SFImage::*)() const>(&Vrml_SFImage::Number),
             R"#()#" 
          )
        .def("SetArray",
             (void (Vrml_SFImage::*)(  const handle<TColStd_HArray1OfInteger> &  ) ) static_cast<void (Vrml_SFImage::*)(  const handle<TColStd_HArray1OfInteger> &  ) >(&Vrml_SFImage::SetArray),
             R"#()#"  , py::arg("anArray")
          )
        .def("Array",
             (handle<TColStd_HArray1OfInteger> (Vrml_SFImage::*)() const) static_cast<handle<TColStd_HArray1OfInteger> (Vrml_SFImage::*)() const>(&Vrml_SFImage::Array),
             R"#()#" 
          )
        .def("ArrayFlag",
             (Standard_Boolean (Vrml_SFImage::*)() const) static_cast<Standard_Boolean (Vrml_SFImage::*)() const>(&Vrml_SFImage::ArrayFlag),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_SFImage::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_SFImage::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> & (Vrml_SFImage::*)() const) static_cast< const handle<Standard_Type> & (Vrml_SFImage::*)() const>(&Vrml_SFImage::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_SFRotation , shared_ptr<Vrml_SFRotation>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Real, const Standard_Real, const Standard_Real, const Standard_Real >()  , py::arg("aRotationX"),  py::arg("aRotationY"),  py::arg("aRotationZ"),  py::arg("anAngle") )
    // custom constructors
    // methods
        .def("SetRotationX",
             (void (Vrml_SFRotation::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SFRotation::*)(  const Standard_Real  ) >(&Vrml_SFRotation::SetRotationX),
             R"#()#"  , py::arg("aRotationX")
          )
        .def("RotationX",
             (Standard_Real (Vrml_SFRotation::*)() const) static_cast<Standard_Real (Vrml_SFRotation::*)() const>(&Vrml_SFRotation::RotationX),
             R"#()#" 
          )
        .def("SetRotationY",
             (void (Vrml_SFRotation::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SFRotation::*)(  const Standard_Real  ) >(&Vrml_SFRotation::SetRotationY),
             R"#()#"  , py::arg("aRotationY")
          )
        .def("RotationY",
             (Standard_Real (Vrml_SFRotation::*)() const) static_cast<Standard_Real (Vrml_SFRotation::*)() const>(&Vrml_SFRotation::RotationY),
             R"#()#" 
          )
        .def("SetRotationZ",
             (void (Vrml_SFRotation::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SFRotation::*)(  const Standard_Real  ) >(&Vrml_SFRotation::SetRotationZ),
             R"#()#"  , py::arg("aRotationZ")
          )
        .def("RotationZ",
             (Standard_Real (Vrml_SFRotation::*)() const) static_cast<Standard_Real (Vrml_SFRotation::*)() const>(&Vrml_SFRotation::RotationZ),
             R"#()#" 
          )
        .def("SetAngle",
             (void (Vrml_SFRotation::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SFRotation::*)(  const Standard_Real  ) >(&Vrml_SFRotation::SetAngle),
             R"#()#"  , py::arg("anAngle")
          )
        .def("Angle",
             (Standard_Real (Vrml_SFRotation::*)() const) static_cast<Standard_Real (Vrml_SFRotation::*)() const>(&Vrml_SFRotation::Angle),
             R"#()#" 
          )
    // 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 Vrml_Scale from ./opencascade/Vrml_Scale.hxx
    klass = m.attr("Vrml_Scale");


    // nested enums

    static_cast<py::class_<Vrml_Scale , shared_ptr<Vrml_Scale>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Vec & >()  , py::arg("aScaleFactor") )
    // custom constructors
    // methods
        .def("SetScaleFactor",
             (void (Vrml_Scale::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_Scale::*)(  const gp_Vec &  ) >(&Vrml_Scale::SetScaleFactor),
             R"#()#"  , py::arg("aScaleFactor")
          )
        .def("ScaleFactor",
             (gp_Vec (Vrml_Scale::*)() const) static_cast<gp_Vec (Vrml_Scale::*)() const>(&Vrml_Scale::ScaleFactor),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Scale::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Scale::*)( Standard_OStream &  ) const>(&Vrml_Scale::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Separator from ./opencascade/Vrml_Separator.hxx
    klass = m.attr("Vrml_Separator");


    // nested enums

    static_cast<py::class_<Vrml_Separator , shared_ptr<Vrml_Separator>  >>(klass)
    // constructors
        .def(py::init<  const Vrml_SeparatorRenderCulling >()  , py::arg("aRenderCulling") )
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("SetRenderCulling",
             (void (Vrml_Separator::*)(  const Vrml_SeparatorRenderCulling  ) ) static_cast<void (Vrml_Separator::*)(  const Vrml_SeparatorRenderCulling  ) >(&Vrml_Separator::SetRenderCulling),
             R"#()#"  , py::arg("aRenderCulling")
          )
        .def("RenderCulling",
             (Vrml_SeparatorRenderCulling (Vrml_Separator::*)() const) static_cast<Vrml_SeparatorRenderCulling (Vrml_Separator::*)() const>(&Vrml_Separator::RenderCulling),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Separator::*)( Standard_OStream &  ) ) static_cast<Standard_OStream & (Vrml_Separator::*)( Standard_OStream &  ) >(&Vrml_Separator::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_ShapeHints from ./opencascade/Vrml_ShapeHints.hxx
    klass = m.attr("Vrml_ShapeHints");


    // nested enums

    static_cast<py::class_<Vrml_ShapeHints , shared_ptr<Vrml_ShapeHints>  >>(klass)
    // constructors
        .def(py::init<  const Vrml_VertexOrdering, const Vrml_ShapeType, const Vrml_FaceType, const Standard_Real >()  , py::arg("aVertexOrdering")=static_cast< const Vrml_VertexOrdering>(Vrml_UNKNOWN_ORDERING),  py::arg("aShapeType")=static_cast< const Vrml_ShapeType>(Vrml_UNKNOWN_SHAPE_TYPE),  py::arg("aFaceType")=static_cast< const Vrml_FaceType>(Vrml_CONVEX),  py::arg("aAngle")=static_cast< const Standard_Real>(0.5) )
    // custom constructors
    // methods
        .def("SetVertexOrdering",
             (void (Vrml_ShapeHints::*)(  const Vrml_VertexOrdering  ) ) static_cast<void (Vrml_ShapeHints::*)(  const Vrml_VertexOrdering  ) >(&Vrml_ShapeHints::SetVertexOrdering),
             R"#()#"  , py::arg("aVertexOrdering")
          )
        .def("VertexOrdering",
             (Vrml_VertexOrdering (Vrml_ShapeHints::*)() const) static_cast<Vrml_VertexOrdering (Vrml_ShapeHints::*)() const>(&Vrml_ShapeHints::VertexOrdering),
             R"#()#" 
          )
        .def("SetShapeType",
             (void (Vrml_ShapeHints::*)(  const Vrml_ShapeType  ) ) static_cast<void (Vrml_ShapeHints::*)(  const Vrml_ShapeType  ) >(&Vrml_ShapeHints::SetShapeType),
             R"#()#"  , py::arg("aShapeType")
          )
        .def("ShapeType",
             (Vrml_ShapeType (Vrml_ShapeHints::*)() const) static_cast<Vrml_ShapeType (Vrml_ShapeHints::*)() const>(&Vrml_ShapeHints::ShapeType),
             R"#()#" 
          )
        .def("SetFaceType",
             (void (Vrml_ShapeHints::*)(  const Vrml_FaceType  ) ) static_cast<void (Vrml_ShapeHints::*)(  const Vrml_FaceType  ) >(&Vrml_ShapeHints::SetFaceType),
             R"#()#"  , py::arg("aFaceType")
          )
        .def("FaceType",
             (Vrml_FaceType (Vrml_ShapeHints::*)() const) static_cast<Vrml_FaceType (Vrml_ShapeHints::*)() const>(&Vrml_ShapeHints::FaceType),
             R"#()#" 
          )
        .def("SetAngle",
             (void (Vrml_ShapeHints::*)(  const Standard_Real  ) ) static_cast<void (Vrml_ShapeHints::*)(  const Standard_Real  ) >(&Vrml_ShapeHints::SetAngle),
             R"#()#"  , py::arg("aAngle")
          )
        .def("Angle",
             (Standard_Real (Vrml_ShapeHints::*)() const) static_cast<Standard_Real (Vrml_ShapeHints::*)() const>(&Vrml_ShapeHints::Angle),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_ShapeHints::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_ShapeHints::*)( Standard_OStream &  ) const>(&Vrml_ShapeHints::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Sphere from ./opencascade/Vrml_Sphere.hxx
    klass = m.attr("Vrml_Sphere");


    // nested enums

    static_cast<py::class_<Vrml_Sphere , shared_ptr<Vrml_Sphere>  >>(klass)
    // constructors
        .def(py::init<  const Standard_Real >()  , py::arg("aRadius")=static_cast< const Standard_Real>(1) )
    // custom constructors
    // methods
        .def("SetRadius",
             (void (Vrml_Sphere::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Sphere::*)(  const Standard_Real  ) >(&Vrml_Sphere::SetRadius),
             R"#()#"  , py::arg("aRadius")
          )
        .def("Radius",
             (Standard_Real (Vrml_Sphere::*)() const) static_cast<Standard_Real (Vrml_Sphere::*)() const>(&Vrml_Sphere::Radius),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Sphere::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Sphere::*)( Standard_OStream &  ) const>(&Vrml_Sphere::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_SpotLight from ./opencascade/Vrml_SpotLight.hxx
    klass = m.attr("Vrml_SpotLight");


    // nested enums

    static_cast<py::class_<Vrml_SpotLight , shared_ptr<Vrml_SpotLight>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const Standard_Boolean, const Standard_Real, const Quantity_Color &, const gp_Vec &, const gp_Vec &, const Standard_Real, const Standard_Real >()  , py::arg("aOnOff"),  py::arg("aIntensity"),  py::arg("aColor"),  py::arg("aLocation"),  py::arg("aDirection"),  py::arg("aDropOffRate"),  py::arg("aCutOffAngle") )
    // custom constructors
    // methods
        .def("SetOnOff",
             (void (Vrml_SpotLight::*)(  const Standard_Boolean  ) ) static_cast<void (Vrml_SpotLight::*)(  const Standard_Boolean  ) >(&Vrml_SpotLight::SetOnOff),
             R"#()#"  , py::arg("anOnOff")
          )
        .def("OnOff",
             (Standard_Boolean (Vrml_SpotLight::*)() const) static_cast<Standard_Boolean (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::OnOff),
             R"#()#" 
          )
        .def("SetIntensity",
             (void (Vrml_SpotLight::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SpotLight::*)(  const Standard_Real  ) >(&Vrml_SpotLight::SetIntensity),
             R"#()#"  , py::arg("aIntensity")
          )
        .def("Intensity",
             (Standard_Real (Vrml_SpotLight::*)() const) static_cast<Standard_Real (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::Intensity),
             R"#()#" 
          )
        .def("SetColor",
             (void (Vrml_SpotLight::*)(  const Quantity_Color &  ) ) static_cast<void (Vrml_SpotLight::*)(  const Quantity_Color &  ) >(&Vrml_SpotLight::SetColor),
             R"#()#"  , py::arg("aColor")
          )
        .def("Color",
             (Quantity_Color (Vrml_SpotLight::*)() const) static_cast<Quantity_Color (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::Color),
             R"#()#" 
          )
        .def("SetLocation",
             (void (Vrml_SpotLight::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_SpotLight::*)(  const gp_Vec &  ) >(&Vrml_SpotLight::SetLocation),
             R"#()#"  , py::arg("aLocation")
          )
        .def("Location",
             (gp_Vec (Vrml_SpotLight::*)() const) static_cast<gp_Vec (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::Location),
             R"#()#" 
          )
        .def("SetDirection",
             (void (Vrml_SpotLight::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_SpotLight::*)(  const gp_Vec &  ) >(&Vrml_SpotLight::SetDirection),
             R"#()#"  , py::arg("aDirection")
          )
        .def("Direction",
             (gp_Vec (Vrml_SpotLight::*)() const) static_cast<gp_Vec (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::Direction),
             R"#()#" 
          )
        .def("SetDropOffRate",
             (void (Vrml_SpotLight::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SpotLight::*)(  const Standard_Real  ) >(&Vrml_SpotLight::SetDropOffRate),
             R"#()#"  , py::arg("aDropOffRate")
          )
        .def("DropOffRate",
             (Standard_Real (Vrml_SpotLight::*)() const) static_cast<Standard_Real (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::DropOffRate),
             R"#()#" 
          )
        .def("SetCutOffAngle",
             (void (Vrml_SpotLight::*)(  const Standard_Real  ) ) static_cast<void (Vrml_SpotLight::*)(  const Standard_Real  ) >(&Vrml_SpotLight::SetCutOffAngle),
             R"#()#"  , py::arg("aCutOffAngle")
          )
        .def("CutOffAngle",
             (Standard_Real (Vrml_SpotLight::*)() const) static_cast<Standard_Real (Vrml_SpotLight::*)() const>(&Vrml_SpotLight::CutOffAngle),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_SpotLight::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_SpotLight::*)( Standard_OStream &  ) const>(&Vrml_SpotLight::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Switch from ./opencascade/Vrml_Switch.hxx
    klass = m.attr("Vrml_Switch");


    // nested enums

    static_cast<py::class_<Vrml_Switch , shared_ptr<Vrml_Switch>  >>(klass)
    // constructors
        .def(py::init<  const Standard_Integer >()  , py::arg("aWhichChild")=static_cast< const Standard_Integer>(- 1) )
    // custom constructors
    // methods
        .def("SetWhichChild",
             (void (Vrml_Switch::*)(  const Standard_Integer  ) ) static_cast<void (Vrml_Switch::*)(  const Standard_Integer  ) >(&Vrml_Switch::SetWhichChild),
             R"#()#"  , py::arg("aWhichChild")
          )
        .def("WhichChild",
             (Standard_Integer (Vrml_Switch::*)() const) static_cast<Standard_Integer (Vrml_Switch::*)() const>(&Vrml_Switch::WhichChild),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Switch::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Switch::*)( Standard_OStream &  ) const>(&Vrml_Switch::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Texture2 from ./opencascade/Vrml_Texture2.hxx
    klass = m.attr("Vrml_Texture2");


    // nested enums

    static_cast<py::class_<Vrml_Texture2 , shared_ptr<Vrml_Texture2>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const TCollection_AsciiString &, const handle<Vrml_SFImage> &, const Vrml_Texture2Wrap, const Vrml_Texture2Wrap >()  , py::arg("aFilename"),  py::arg("aImage"),  py::arg("aWrapS"),  py::arg("aWrapT") )
    // custom constructors
    // methods
        .def("SetFilename",
             (void (Vrml_Texture2::*)(  const TCollection_AsciiString &  ) ) static_cast<void (Vrml_Texture2::*)(  const TCollection_AsciiString &  ) >(&Vrml_Texture2::SetFilename),
             R"#()#"  , py::arg("aFilename")
          )
        .def("Filename",
             (TCollection_AsciiString (Vrml_Texture2::*)() const) static_cast<TCollection_AsciiString (Vrml_Texture2::*)() const>(&Vrml_Texture2::Filename),
             R"#()#" 
          )
        .def("SetImage",
             (void (Vrml_Texture2::*)(  const handle<Vrml_SFImage> &  ) ) static_cast<void (Vrml_Texture2::*)(  const handle<Vrml_SFImage> &  ) >(&Vrml_Texture2::SetImage),
             R"#()#"  , py::arg("aImage")
          )
        .def("Image",
             (handle<Vrml_SFImage> (Vrml_Texture2::*)() const) static_cast<handle<Vrml_SFImage> (Vrml_Texture2::*)() const>(&Vrml_Texture2::Image),
             R"#()#" 
          )
        .def("SetWrapS",
             (void (Vrml_Texture2::*)(  const Vrml_Texture2Wrap  ) ) static_cast<void (Vrml_Texture2::*)(  const Vrml_Texture2Wrap  ) >(&Vrml_Texture2::SetWrapS),
             R"#()#"  , py::arg("aWrapS")
          )
        .def("WrapS",
             (Vrml_Texture2Wrap (Vrml_Texture2::*)() const) static_cast<Vrml_Texture2Wrap (Vrml_Texture2::*)() const>(&Vrml_Texture2::WrapS),
             R"#()#" 
          )
        .def("SetWrapT",
             (void (Vrml_Texture2::*)(  const Vrml_Texture2Wrap  ) ) static_cast<void (Vrml_Texture2::*)(  const Vrml_Texture2Wrap  ) >(&Vrml_Texture2::SetWrapT),
             R"#()#"  , py::arg("aWrapT")
          )
        .def("WrapT",
             (Vrml_Texture2Wrap (Vrml_Texture2::*)() const) static_cast<Vrml_Texture2Wrap (Vrml_Texture2::*)() const>(&Vrml_Texture2::WrapT),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Texture2::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Texture2::*)( Standard_OStream &  ) const>(&Vrml_Texture2::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Texture2Transform from ./opencascade/Vrml_Texture2Transform.hxx
    klass = m.attr("Vrml_Texture2Transform");


    // nested enums

    static_cast<py::class_<Vrml_Texture2Transform , shared_ptr<Vrml_Texture2Transform>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Vec2d &, const Standard_Real, const gp_Vec2d &, const gp_Vec2d & >()  , py::arg("aTranslation"),  py::arg("aRotation"),  py::arg("aScaleFactor"),  py::arg("aCenter") )
    // custom constructors
    // methods
        .def("SetTranslation",
             (void (Vrml_Texture2Transform::*)(  const gp_Vec2d &  ) ) static_cast<void (Vrml_Texture2Transform::*)(  const gp_Vec2d &  ) >(&Vrml_Texture2Transform::SetTranslation),
             R"#()#"  , py::arg("aTranslation")
          )
        .def("Translation",
             (gp_Vec2d (Vrml_Texture2Transform::*)() const) static_cast<gp_Vec2d (Vrml_Texture2Transform::*)() const>(&Vrml_Texture2Transform::Translation),
             R"#()#" 
          )
        .def("SetRotation",
             (void (Vrml_Texture2Transform::*)(  const Standard_Real  ) ) static_cast<void (Vrml_Texture2Transform::*)(  const Standard_Real  ) >(&Vrml_Texture2Transform::SetRotation),
             R"#()#"  , py::arg("aRotation")
          )
        .def("Rotation",
             (Standard_Real (Vrml_Texture2Transform::*)() const) static_cast<Standard_Real (Vrml_Texture2Transform::*)() const>(&Vrml_Texture2Transform::Rotation),
             R"#()#" 
          )
        .def("SetScaleFactor",
             (void (Vrml_Texture2Transform::*)(  const gp_Vec2d &  ) ) static_cast<void (Vrml_Texture2Transform::*)(  const gp_Vec2d &  ) >(&Vrml_Texture2Transform::SetScaleFactor),
             R"#()#"  , py::arg("aScaleFactor")
          )
        .def("ScaleFactor",
             (gp_Vec2d (Vrml_Texture2Transform::*)() const) static_cast<gp_Vec2d (Vrml_Texture2Transform::*)() const>(&Vrml_Texture2Transform::ScaleFactor),
             R"#()#" 
          )
        .def("SetCenter",
             (void (Vrml_Texture2Transform::*)(  const gp_Vec2d &  ) ) static_cast<void (Vrml_Texture2Transform::*)(  const gp_Vec2d &  ) >(&Vrml_Texture2Transform::SetCenter),
             R"#()#"  , py::arg("aCenter")
          )
        .def("Center",
             (gp_Vec2d (Vrml_Texture2Transform::*)() const) static_cast<gp_Vec2d (Vrml_Texture2Transform::*)() const>(&Vrml_Texture2Transform::Center),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Texture2Transform::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Texture2Transform::*)( Standard_OStream &  ) const>(&Vrml_Texture2Transform::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_TextureCoordinate2 from ./opencascade/Vrml_TextureCoordinate2.hxx
    klass = m.attr("Vrml_TextureCoordinate2");


    // nested enums

    static_cast<py::class_<Vrml_TextureCoordinate2 ,opencascade::handle<Vrml_TextureCoordinate2>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const handle<TColgp_HArray1OfVec2d> & >()  , py::arg("aPoint") )
    // custom constructors
    // methods
        .def("SetPoint",
             (void (Vrml_TextureCoordinate2::*)(  const handle<TColgp_HArray1OfVec2d> &  ) ) static_cast<void (Vrml_TextureCoordinate2::*)(  const handle<TColgp_HArray1OfVec2d> &  ) >(&Vrml_TextureCoordinate2::SetPoint),
             R"#()#"  , py::arg("aPoint")
          )
        .def("Point",
             (handle<TColgp_HArray1OfVec2d> (Vrml_TextureCoordinate2::*)() const) static_cast<handle<TColgp_HArray1OfVec2d> (Vrml_TextureCoordinate2::*)() const>(&Vrml_TextureCoordinate2::Point),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_TextureCoordinate2::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_TextureCoordinate2::*)( Standard_OStream &  ) const>(&Vrml_TextureCoordinate2::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&Vrml_TextureCoordinate2::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&Vrml_TextureCoordinate2::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> & (Vrml_TextureCoordinate2::*)() const) static_cast< const handle<Standard_Type> & (Vrml_TextureCoordinate2::*)() const>(&Vrml_TextureCoordinate2::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<Vrml_Transform , shared_ptr<Vrml_Transform>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Vec &, const Vrml_SFRotation &, const gp_Vec &, const Vrml_SFRotation &, const gp_Vec & >()  , py::arg("aTranslation"),  py::arg("aRotation"),  py::arg("aScaleFactor"),  py::arg("aScaleOrientation"),  py::arg("aCenter") )
    // custom constructors
    // methods
        .def("SetTranslation",
             (void (Vrml_Transform::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_Transform::*)(  const gp_Vec &  ) >(&Vrml_Transform::SetTranslation),
             R"#()#"  , py::arg("aTranslation")
          )
        .def("Translation",
             (gp_Vec (Vrml_Transform::*)() const) static_cast<gp_Vec (Vrml_Transform::*)() const>(&Vrml_Transform::Translation),
             R"#()#" 
          )
        .def("SetRotation",
             (void (Vrml_Transform::*)(  const Vrml_SFRotation &  ) ) static_cast<void (Vrml_Transform::*)(  const Vrml_SFRotation &  ) >(&Vrml_Transform::SetRotation),
             R"#()#"  , py::arg("aRotation")
          )
        .def("Rotation",
             (Vrml_SFRotation (Vrml_Transform::*)() const) static_cast<Vrml_SFRotation (Vrml_Transform::*)() const>(&Vrml_Transform::Rotation),
             R"#()#" 
          )
        .def("SetScaleFactor",
             (void (Vrml_Transform::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_Transform::*)(  const gp_Vec &  ) >(&Vrml_Transform::SetScaleFactor),
             R"#()#"  , py::arg("aScaleFactor")
          )
        .def("ScaleFactor",
             (gp_Vec (Vrml_Transform::*)() const) static_cast<gp_Vec (Vrml_Transform::*)() const>(&Vrml_Transform::ScaleFactor),
             R"#()#" 
          )
        .def("SetScaleOrientation",
             (void (Vrml_Transform::*)(  const Vrml_SFRotation &  ) ) static_cast<void (Vrml_Transform::*)(  const Vrml_SFRotation &  ) >(&Vrml_Transform::SetScaleOrientation),
             R"#()#"  , py::arg("aScaleOrientation")
          )
        .def("ScaleOrientation",
             (Vrml_SFRotation (Vrml_Transform::*)() const) static_cast<Vrml_SFRotation (Vrml_Transform::*)() const>(&Vrml_Transform::ScaleOrientation),
             R"#()#" 
          )
        .def("SetCenter",
             (void (Vrml_Transform::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_Transform::*)(  const gp_Vec &  ) >(&Vrml_Transform::SetCenter),
             R"#()#"  , py::arg("aCenter")
          )
        .def("Center",
             (gp_Vec (Vrml_Transform::*)() const) static_cast<gp_Vec (Vrml_Transform::*)() const>(&Vrml_Transform::Center),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Transform::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Transform::*)( Standard_OStream &  ) const>(&Vrml_Transform::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_TransformSeparator from ./opencascade/Vrml_TransformSeparator.hxx
    klass = m.attr("Vrml_TransformSeparator");


    // nested enums

    static_cast<py::class_<Vrml_TransformSeparator , shared_ptr<Vrml_TransformSeparator>  >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("Print",
             (Standard_OStream & (Vrml_TransformSeparator::*)( Standard_OStream &  ) ) static_cast<Standard_OStream & (Vrml_TransformSeparator::*)( Standard_OStream &  ) >(&Vrml_TransformSeparator::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_Translation from ./opencascade/Vrml_Translation.hxx
    klass = m.attr("Vrml_Translation");


    // nested enums

    static_cast<py::class_<Vrml_Translation , shared_ptr<Vrml_Translation>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const gp_Vec & >()  , py::arg("aTranslation") )
    // custom constructors
    // methods
        .def("SetTranslation",
             (void (Vrml_Translation::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_Translation::*)(  const gp_Vec &  ) >(&Vrml_Translation::SetTranslation),
             R"#()#"  , py::arg("aTranslation")
          )
        .def("Translation",
             (gp_Vec (Vrml_Translation::*)() const) static_cast<gp_Vec (Vrml_Translation::*)() const>(&Vrml_Translation::Translation),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_Translation::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_Translation::*)( Standard_OStream &  ) const>(&Vrml_Translation::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_WWWAnchor from ./opencascade/Vrml_WWWAnchor.hxx
    klass = m.attr("Vrml_WWWAnchor");


    // nested enums

    static_cast<py::class_<Vrml_WWWAnchor , shared_ptr<Vrml_WWWAnchor>  >>(klass)
    // constructors
        .def(py::init<  const TCollection_AsciiString &, const TCollection_AsciiString &, const Vrml_WWWAnchorMap >()  , py::arg("aName")=static_cast< const TCollection_AsciiString &>(""),  py::arg("aDescription")=static_cast< const TCollection_AsciiString &>(""),  py::arg("aMap")=static_cast< const Vrml_WWWAnchorMap>(Vrml_MAP_NONE) )
    // custom constructors
    // methods
        .def("SetName",
             (void (Vrml_WWWAnchor::*)(  const TCollection_AsciiString &  ) ) static_cast<void (Vrml_WWWAnchor::*)(  const TCollection_AsciiString &  ) >(&Vrml_WWWAnchor::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (TCollection_AsciiString (Vrml_WWWAnchor::*)() const) static_cast<TCollection_AsciiString (Vrml_WWWAnchor::*)() const>(&Vrml_WWWAnchor::Name),
             R"#()#" 
          )
        .def("SetDescription",
             (void (Vrml_WWWAnchor::*)(  const TCollection_AsciiString &  ) ) static_cast<void (Vrml_WWWAnchor::*)(  const TCollection_AsciiString &  ) >(&Vrml_WWWAnchor::SetDescription),
             R"#()#"  , py::arg("aDescription")
          )
        .def("Description",
             (TCollection_AsciiString (Vrml_WWWAnchor::*)() const) static_cast<TCollection_AsciiString (Vrml_WWWAnchor::*)() const>(&Vrml_WWWAnchor::Description),
             R"#()#" 
          )
        .def("SetMap",
             (void (Vrml_WWWAnchor::*)(  const Vrml_WWWAnchorMap  ) ) static_cast<void (Vrml_WWWAnchor::*)(  const Vrml_WWWAnchorMap  ) >(&Vrml_WWWAnchor::SetMap),
             R"#()#"  , py::arg("aMap")
          )
        .def("Map",
             (Vrml_WWWAnchorMap (Vrml_WWWAnchor::*)() const) static_cast<Vrml_WWWAnchorMap (Vrml_WWWAnchor::*)() const>(&Vrml_WWWAnchor::Map),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_WWWAnchor::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_WWWAnchor::*)( Standard_OStream &  ) const>(&Vrml_WWWAnchor::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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 Vrml_WWWInline from ./opencascade/Vrml_WWWInline.hxx
    klass = m.attr("Vrml_WWWInline");


    // nested enums

    static_cast<py::class_<Vrml_WWWInline , shared_ptr<Vrml_WWWInline>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const TCollection_AsciiString &, const gp_Vec &, const gp_Vec & >()  , py::arg("aName"),  py::arg("aBboxSize"),  py::arg("aBboxCenter") )
    // custom constructors
    // methods
        .def("SetName",
             (void (Vrml_WWWInline::*)(  const TCollection_AsciiString &  ) ) static_cast<void (Vrml_WWWInline::*)(  const TCollection_AsciiString &  ) >(&Vrml_WWWInline::SetName),
             R"#()#"  , py::arg("aName")
          )
        .def("Name",
             (TCollection_AsciiString (Vrml_WWWInline::*)() const) static_cast<TCollection_AsciiString (Vrml_WWWInline::*)() const>(&Vrml_WWWInline::Name),
             R"#()#" 
          )
        .def("SetBboxSize",
             (void (Vrml_WWWInline::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_WWWInline::*)(  const gp_Vec &  ) >(&Vrml_WWWInline::SetBboxSize),
             R"#()#"  , py::arg("aBboxSize")
          )
        .def("BboxSize",
             (gp_Vec (Vrml_WWWInline::*)() const) static_cast<gp_Vec (Vrml_WWWInline::*)() const>(&Vrml_WWWInline::BboxSize),
             R"#()#" 
          )
        .def("SetBboxCenter",
             (void (Vrml_WWWInline::*)(  const gp_Vec &  ) ) static_cast<void (Vrml_WWWInline::*)(  const gp_Vec &  ) >(&Vrml_WWWInline::SetBboxCenter),
             R"#()#"  , py::arg("aBboxCenter")
          )
        .def("BboxCenter",
             (gp_Vec (Vrml_WWWInline::*)() const) static_cast<gp_Vec (Vrml_WWWInline::*)() const>(&Vrml_WWWInline::BboxCenter),
             R"#()#" 
          )
        .def("Print",
             (Standard_OStream & (Vrml_WWWInline::*)( Standard_OStream &  ) const) static_cast<Standard_OStream & (Vrml_WWWInline::*)( Standard_OStream &  ) const>(&Vrml_WWWInline::Print),
             R"#()#"  , py::arg("anOStream")
          )
    // 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
;

// functions

// ./opencascade/Vrml.hxx
// ./opencascade/Vrml_AsciiText.hxx
// ./opencascade/Vrml_AsciiTextJustification.hxx
// ./opencascade/Vrml_Cone.hxx
// ./opencascade/Vrml_ConeParts.hxx
// ./opencascade/Vrml_ConfigurationNode.hxx
// ./opencascade/Vrml_Coordinate3.hxx
// ./opencascade/Vrml_Cube.hxx
// ./opencascade/Vrml_Cylinder.hxx
// ./opencascade/Vrml_CylinderParts.hxx
// ./opencascade/Vrml_DirectionalLight.hxx
// ./opencascade/Vrml_FaceType.hxx
// ./opencascade/Vrml_FontStyle.hxx
// ./opencascade/Vrml_FontStyleFamily.hxx
// ./opencascade/Vrml_FontStyleStyle.hxx
// ./opencascade/Vrml_Group.hxx
// ./opencascade/Vrml_IndexedFaceSet.hxx
// ./opencascade/Vrml_IndexedLineSet.hxx
// ./opencascade/Vrml_Info.hxx
// ./opencascade/Vrml_Instancing.hxx
// ./opencascade/Vrml_LOD.hxx
// ./opencascade/Vrml_Material.hxx
// ./opencascade/Vrml_MaterialBinding.hxx
// ./opencascade/Vrml_MaterialBindingAndNormalBinding.hxx
// ./opencascade/Vrml_MatrixTransform.hxx
// ./opencascade/Vrml_Normal.hxx
// ./opencascade/Vrml_NormalBinding.hxx
// ./opencascade/Vrml_OrthographicCamera.hxx
// ./opencascade/Vrml_PerspectiveCamera.hxx
// ./opencascade/Vrml_PointLight.hxx
// ./opencascade/Vrml_PointSet.hxx
// ./opencascade/Vrml_Provider.hxx
// ./opencascade/Vrml_Rotation.hxx
// ./opencascade/Vrml_SFImage.hxx
// ./opencascade/Vrml_SFImageNumber.hxx
// ./opencascade/Vrml_SFRotation.hxx
// ./opencascade/Vrml_Scale.hxx
// ./opencascade/Vrml_Separator.hxx
// ./opencascade/Vrml_SeparatorRenderCulling.hxx
// ./opencascade/Vrml_ShapeHints.hxx
// ./opencascade/Vrml_ShapeType.hxx
// ./opencascade/Vrml_Sphere.hxx
// ./opencascade/Vrml_SpotLight.hxx
// ./opencascade/Vrml_Switch.hxx
// ./opencascade/Vrml_Texture2.hxx
// ./opencascade/Vrml_Texture2Transform.hxx
// ./opencascade/Vrml_Texture2Wrap.hxx
// ./opencascade/Vrml_TextureCoordinate2.hxx
// ./opencascade/Vrml_Transform.hxx
// ./opencascade/Vrml_TransformSeparator.hxx
// ./opencascade/Vrml_Translation.hxx
// ./opencascade/Vrml_VertexOrdering.hxx
// ./opencascade/Vrml_WWWAnchor.hxx
// ./opencascade/Vrml_WWWAnchorMap.hxx
// ./opencascade/Vrml_WWWInline.hxx

// Additional functions


// operators

// register typdefs


// exceptions

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

};

// user-defined post-inclusion per module

// user-defined post
