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

namespace py = pybind11;


// Standard Handle
#include <Standard_Handle.hxx>

// user-defined inclusion per module before includes

// 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_enums(py::module &main_module) {


py::module m = main_module.def_submodule("Vrml", R"#()#");

// user-defined inclusion per module in the body

// enums
    py::enum_<Vrml_FaceType>(m, "Vrml_FaceType",R"#(None)#")
        .value("Vrml_UNKNOWN_FACE_TYPE",Vrml_FaceType::Vrml_UNKNOWN_FACE_TYPE)
        .value("Vrml_CONVEX",Vrml_FaceType::Vrml_CONVEX).export_values();
    py::enum_<Vrml_AsciiTextJustification>(m, "Vrml_AsciiTextJustification",R"#(None)#")
        .value("Vrml_LEFT",Vrml_AsciiTextJustification::Vrml_LEFT)
        .value("Vrml_CENTER",Vrml_AsciiTextJustification::Vrml_CENTER)
        .value("Vrml_RIGHT",Vrml_AsciiTextJustification::Vrml_RIGHT).export_values();
    py::enum_<Vrml_VertexOrdering>(m, "Vrml_VertexOrdering",R"#(None)#")
        .value("Vrml_UNKNOWN_ORDERING",Vrml_VertexOrdering::Vrml_UNKNOWN_ORDERING)
        .value("Vrml_CLOCKWISE",Vrml_VertexOrdering::Vrml_CLOCKWISE)
        .value("Vrml_COUNTERCLOCKWISE",Vrml_VertexOrdering::Vrml_COUNTERCLOCKWISE).export_values();
    py::enum_<Vrml_Texture2Wrap>(m, "Vrml_Texture2Wrap",R"#(None)#")
        .value("Vrml_REPEAT",Vrml_Texture2Wrap::Vrml_REPEAT)
        .value("Vrml_CLAMP",Vrml_Texture2Wrap::Vrml_CLAMP).export_values();
    py::enum_<Vrml_SeparatorRenderCulling>(m, "Vrml_SeparatorRenderCulling",R"#(None)#")
        .value("Vrml_OFF",Vrml_SeparatorRenderCulling::Vrml_OFF)
        .value("Vrml_ON",Vrml_SeparatorRenderCulling::Vrml_ON)
        .value("Vrml_AUTO",Vrml_SeparatorRenderCulling::Vrml_AUTO).export_values();
    py::enum_<Vrml_ConeParts>(m, "Vrml_ConeParts",R"#(None)#")
        .value("Vrml_ConeSIDES",Vrml_ConeParts::Vrml_ConeSIDES)
        .value("Vrml_ConeBOTTOM",Vrml_ConeParts::Vrml_ConeBOTTOM)
        .value("Vrml_ConeALL",Vrml_ConeParts::Vrml_ConeALL).export_values();
    py::enum_<Vrml_MaterialBindingAndNormalBinding>(m, "Vrml_MaterialBindingAndNormalBinding",R"#(None)#")
        .value("Vrml_DEFAULT",Vrml_MaterialBindingAndNormalBinding::Vrml_DEFAULT)
        .value("Vrml_OVERALL",Vrml_MaterialBindingAndNormalBinding::Vrml_OVERALL)
        .value("Vrml_PER_PART",Vrml_MaterialBindingAndNormalBinding::Vrml_PER_PART)
        .value("Vrml_PER_PART_INDEXED",Vrml_MaterialBindingAndNormalBinding::Vrml_PER_PART_INDEXED)
        .value("Vrml_PER_FACE",Vrml_MaterialBindingAndNormalBinding::Vrml_PER_FACE)
        .value("Vrml_PER_FACE_INDEXED",Vrml_MaterialBindingAndNormalBinding::Vrml_PER_FACE_INDEXED)
        .value("Vrml_PER_VERTEX",Vrml_MaterialBindingAndNormalBinding::Vrml_PER_VERTEX)
        .value("Vrml_PER_VERTEX_INDEXED",Vrml_MaterialBindingAndNormalBinding::Vrml_PER_VERTEX_INDEXED).export_values();
    py::enum_<Vrml_CylinderParts>(m, "Vrml_CylinderParts",R"#(None)#")
        .value("Vrml_CylinderSIDES",Vrml_CylinderParts::Vrml_CylinderSIDES)
        .value("Vrml_CylinderTOP",Vrml_CylinderParts::Vrml_CylinderTOP)
        .value("Vrml_CylinderBOTTOM",Vrml_CylinderParts::Vrml_CylinderBOTTOM)
        .value("Vrml_CylinderALL",Vrml_CylinderParts::Vrml_CylinderALL).export_values();
    py::enum_<Vrml_FontStyleFamily>(m, "Vrml_FontStyleFamily",R"#(None)#")
        .value("Vrml_SERIF",Vrml_FontStyleFamily::Vrml_SERIF)
        .value("Vrml_SANS",Vrml_FontStyleFamily::Vrml_SANS)
        .value("Vrml_TYPEWRITER",Vrml_FontStyleFamily::Vrml_TYPEWRITER).export_values();
    py::enum_<Vrml_WWWAnchorMap>(m, "Vrml_WWWAnchorMap",R"#(None)#")
        .value("Vrml_MAP_NONE",Vrml_WWWAnchorMap::Vrml_MAP_NONE)
        .value("Vrml_POINT",Vrml_WWWAnchorMap::Vrml_POINT).export_values();
    py::enum_<Vrml_FontStyleStyle>(m, "Vrml_FontStyleStyle",R"#(None)#")
        .value("Vrml_NONE",Vrml_FontStyleStyle::Vrml_NONE)
        .value("Vrml_BOLD",Vrml_FontStyleStyle::Vrml_BOLD)
        .value("Vrml_ITALIC",Vrml_FontStyleStyle::Vrml_ITALIC).export_values();
    py::enum_<Vrml_SFImageNumber>(m, "Vrml_SFImageNumber",R"#(qualifies VRML geometry shapes.)#")
        .value("Vrml_NULL",Vrml_SFImageNumber::Vrml_NULL)
        .value("Vrml_ONE",Vrml_SFImageNumber::Vrml_ONE)
        .value("Vrml_TWO",Vrml_SFImageNumber::Vrml_TWO)
        .value("Vrml_THREE",Vrml_SFImageNumber::Vrml_THREE)
        .value("Vrml_FOUR",Vrml_SFImageNumber::Vrml_FOUR).export_values();
    py::enum_<Vrml_ShapeType>(m, "Vrml_ShapeType",R"#(None)#")
        .value("Vrml_UNKNOWN_SHAPE_TYPE",Vrml_ShapeType::Vrml_UNKNOWN_SHAPE_TYPE)
        .value("Vrml_SOLID",Vrml_ShapeType::Vrml_SOLID).export_values();

//Python trampoline classes

// pre-register typdefs+classes (topologically sorted)
    py::class_<Vrml , shared_ptr<Vrml>  >(m,"Vrml",R"#(Vrml package implements the specification of the VRML ( Virtual Reality Modeling Language ). VRML is a standard language for describing interactive 3-D objects and worlds delivered across Internet. Actual version of Vrml package have made for objects of VRML version 1.0. This package is used by VrmlConverter package. The developer should already be familiar with VRML specification before using this package.)#");
    py::class_<Vrml_Cone , shared_ptr<Vrml_Cone>  >(m,"Vrml_Cone",R"#(defines a Cone node of VRML specifying geometry shapes. This node represents a simple cone, whose central axis is aligned with the y-axis. By default , the cone is centred at (0,0,0) and has size of -1 to +1 in the all three directions. the cone has a radius of 1 at the bottom and height of 2, with its apex at 1 and its bottom at -1. The cone has two parts: the sides and the bottom)#");
    py::class_<Vrml_Cube , shared_ptr<Vrml_Cube>  >(m,"Vrml_Cube",R"#(defines a Cube node of VRML specifying geometry shapes. This node represents a cuboid aligned with the coordinate axes. By default , the cube is centred at (0,0,0) and measures 2 units in each dimension, from -1 to +1. A cube's width is its extent along its object-space X axis, its height is its extent along the object-space Y axis, and its depth is its extent along its object-space Z axis.)#");
    py::class_<Vrml_Cylinder , shared_ptr<Vrml_Cylinder>  >(m,"Vrml_Cylinder",R"#(defines a Cylinder node of VRML specifying geometry shapes. This node represents a simple capped cylinder centred around the y-axis. By default , the cylinder is centred at (0,0,0) and has size of -1 to +1 in the all three dimensions. The cylinder has three parts: the sides, the top (y=+1) and the bottom (y=-1))#");
    py::class_<Vrml_DirectionalLight , shared_ptr<Vrml_DirectionalLight>  >(m,"Vrml_DirectionalLight",R"#(defines a directional light node of VRML specifying properties of lights. This node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector Color is written as an RGB triple. Light intensity must be in the range 0.0 to 1.0, inclusive.)#");
    py::class_<Vrml_FontStyle , shared_ptr<Vrml_FontStyle>  >(m,"Vrml_FontStyle",R"#(defines a FontStyle node of VRML of properties of geometry and its appearance. The size field specifies the height (in object space units) of glyphs rendered and determines the vertical spacing of adjacent lines of text.)#");
    py::class_<Vrml_Group , shared_ptr<Vrml_Group>  >(m,"Vrml_Group",R"#(defines a Group node of VRML specifying group properties. This node defines the base class for all group nodes. Group is a node that contains an ordered list of child nodes. This node is simply a container for the child nodes and does not alter the traversal state in any way. During traversal, state accumulated for a child is passed on to each successive child and then to the parents of the group (Group does not push or pop traversal state as separator does).)#");
    py::class_<Vrml_Info , shared_ptr<Vrml_Info>  >(m,"Vrml_Info",R"#(defines a Info node of VRML specifying properties of geometry and its appearance. It is used to store information in the scene graph, Typically for application-specific purposes, copyright messages, or other strings.)#");
    py::class_<Vrml_Instancing , shared_ptr<Vrml_Instancing>  >(m,"Vrml_Instancing",R"#(defines "instancing" - using the same instance of a node multiple times. It is accomplished by using the "DEF" and "USE" keywords. The DEF keyword both defines a named node, and creates a single instance of it. The USE keyword indicates that the most recently defined instance should be used again. If several nades were given the same name, then the last DEF encountered during parsing "wins". DEF/USE is limited to a single file.)#");
    py::class_<Vrml_MaterialBinding , shared_ptr<Vrml_MaterialBinding>  >(m,"Vrml_MaterialBinding",R"#(defines a MaterialBinding node of VRML specifying properties of geometry and its appearance. Material nodes may contain more than one material. This node specifies how the current materials are bound to shapes that follow in the scene graph. Each shape node may interpret bindings differently. For example, a Sphere node is always drawn using the first material in the material node, no matter what the current MaterialBinding, while a Cube node may use six different materials to draw each of its six faces, depending on the MaterialBinding.)#");
    py::class_<Vrml_MatrixTransform , shared_ptr<Vrml_MatrixTransform>  >(m,"Vrml_MatrixTransform",R"#(defines a MatrixTransform node of VRML specifying matrix and transform properties. This node defines 3D transformation with a 4 by 4 matrix. By default : a11=1 a12=0 a13=0 a14=0 a21=0 a22=1 a23=0 a24=0 a31=0 a32=0 a33=1 a34=0 a41=0 a42=0 a43=0 a44=1 It is written to the file in row-major order as 16 Real numbers separated by whitespace. For example , matrix expressing a translation of 7.3 units along the X axis is written as: 1 0 0 0 0 1 0 0 0 0 1 0 7.3 0 0 1)#");
    py::class_<Vrml_NormalBinding , shared_ptr<Vrml_NormalBinding>  >(m,"Vrml_NormalBinding",R"#(defines a NormalBinding node of VRML specifying properties of geometry and its appearance. This node specifies how the current normals are bound to shapes that follow in the scene graph. Each shape node may interpret bindings differently. The bindings for faces and vertices are meaningful only for shapes that are made from faces and vertices. Similarly, the indexed bindings are only used by the shapes that allow indexing. For bindings that require multiple normals, be sure to have at least as many normals defined as are necessary; otherwise, errors will occur.)#");
    py::class_<Vrml_OrthographicCamera , shared_ptr<Vrml_OrthographicCamera>  >(m,"Vrml_OrthographicCamera",R"#(specifies a OrthographicCamera node of VRML specifying properties of cameras. An orthographic camera defines a parallel projection from a viewpoint. This camera does not diminish objects with distance, as a PerspectiveCamera does. The viewing volume for an orthographic camera is a rectangular parallelepiped (a box).)#");
    py::class_<Vrml_PerspectiveCamera , shared_ptr<Vrml_PerspectiveCamera>  >(m,"Vrml_PerspectiveCamera",R"#(specifies a PerspectiveCamera node of VRML specifying properties of cameras. A perspective camera defines a perspective projection from a viewpoint. The viewing volume for a perspective camera is a truncated right pyramid.)#");
    py::class_<Vrml_PointLight , shared_ptr<Vrml_PointLight>  >(m,"Vrml_PointLight",R"#(defines a point light node of VRML specifying properties of lights. This node defines a point light source at a fixed 3D location A point source illuminates equally in all directions; that is omni-directional. Color is written as an RGB triple. Light intensity must be in the range 0.0 to 1.0, inclusive.)#");
    py::class_<Vrml_PointSet , shared_ptr<Vrml_PointSet>  >(m,"Vrml_PointSet",R"#(defines a PointSet node of VRML specifying geometry shapes.)#");
    py::class_<Vrml_Rotation , shared_ptr<Vrml_Rotation>  >(m,"Vrml_Rotation",R"#(defines a Rotation node of VRML specifying matrix and transform properties. This node defines a 3D rotation about an arbitrary axis through the origin. By default : myRotation = (0 0 1 0))#");
    py::class_<Vrml_SFRotation , shared_ptr<Vrml_SFRotation>  >(m,"Vrml_SFRotation",R"#(defines SFRotation type of VRML field types. The 4 values represent an axis of rotation followed by amount of right-handed rotation about the that axis, in radians.)#");
    py::class_<Vrml_Scale , shared_ptr<Vrml_Scale>  >(m,"Vrml_Scale",R"#(defines a Scale node of VRML specifying transform properties. This node defines a 3D scaling about the origin. By default : myRotation = (1 1 1))#");
    py::class_<Vrml_Separator , shared_ptr<Vrml_Separator>  >(m,"Vrml_Separator",R"#(defines a Separator node of VRML specifying group properties. This group node performs a push (save) of the traversal state before traversing its children and a pop (restore) after traversing them. This isolates the separator's children from the rest of the scene graph. A separator can include lights, cameras, coordinates, normals, bindings, and all other properties. Separators can also perform render culling. Render culling skips over traversal of the separator's children if they are not going to be rendered, based on the comparison of the separator's bounding box with the current view volume. Culling is controlled by the renderCulling field. These are set to AUTO by default, allowing the implementation to decide whether or not to cull.)#");
    py::class_<Vrml_ShapeHints , shared_ptr<Vrml_ShapeHints>  >(m,"Vrml_ShapeHints",R"#(defines a ShapeHints node of VRML specifying properties of geometry and its appearance. The ShapeHints node indicates that IndexedFaceSets are solid, contain ordered vertices, or contain convex faces. These hints allow VRML implementations to optimize certain rendering features. Optimizations that may be performed include enabling back-face culling and disabling two-sided lighting. For example, if an object is solid and has ordered vertices, an implementation may turn on backface culling and turn off two-sided lighting. To ensure that an IndexedFaceSet can be viewed from either direction, set shapeType to be UNKNOWN_SHAPE_TYPE. If you know that your shapes are closed and will alwsys be viewed from the outside, set vertexOrdering to be either CLOCKWISE or COUNTERCLOCKWISE (depending on how you built your object), and set shapeType to be SOLID. Placing this near the top of your VRML file will allow the scene to be rendered much faster. The ShapeHints node also affects how default normals are generated. When an IndexedFaceSet has to generate default normals, it uses the creaseAngle field to determine which edges should be smoothly shaded and which ones should have a sharp crease. The crease angle is the angle between surface normals on adjacent polygons. For example, a crease angle of .5 radians (the default value) means that an edge between two adjacent polygonal faces will be smooth shaded if the normals to the two faces form an angle that is less than .5 radians (about 30 degrees). Otherwise, it will be faceted.)#");
    py::class_<Vrml_Sphere , shared_ptr<Vrml_Sphere>  >(m,"Vrml_Sphere",R"#(defines a Sphere node of VRML specifying geometry shapes. This node represents a sphere. By default , the sphere is centred at (0,0,0) and has a radius of 1.)#");
    py::class_<Vrml_SpotLight , shared_ptr<Vrml_SpotLight>  >(m,"Vrml_SpotLight",R"#(specifies a spot light node of VRML nodes specifying properties of lights. This node defines a spotlight light source. A spotlight is placed at a fixed location in 3D-space and illuminates in a cone along a particular direction. The intensity of the illumination drops off exponentially as a ray of light diverges from this direction toward the edges of cone. The rate of drop-off and agle of the cone are controlled by the dropOfRate and cutOffAngle Color is written as an RGB triple. Light intensity must be in the range 0.0 to 1.0, inclusive.)#");
    py::class_<Vrml_Switch , shared_ptr<Vrml_Switch>  >(m,"Vrml_Switch",R"#(defines a Switch node of VRML specifying group properties. This group node traverses one, none, or all of its children. One can use this node to switch on and off the effects of some properties or to switch between different properties. The whichChild field specifies the index of the child to traverse, where the first child has index 0. A value of -1 (the default) means do not traverse any children. A value of -3 traverses all children, making the switch behave exactly like a regular Group.)#");
    py::class_<Vrml_Texture2 , shared_ptr<Vrml_Texture2>  >(m,"Vrml_Texture2",R"#(defines a Texture2 node of VRML specifying properties of geometry and its appearance. This property node defines a texture map and parameters for that map The texture can be read from the URL specified by the filename field. To turn off texturing, set the filename field to an empty string (""). Textures can alsobe specified inline by setting the image field to contain the texture data. By default : myFilename ("") myImage (0 0 0) myWrapS (Vrml_REPEAT) myWrapT (Vrml_REPEAT))#");
    py::class_<Vrml_Texture2Transform , shared_ptr<Vrml_Texture2Transform>  >(m,"Vrml_Texture2Transform",R"#(defines a Texture2Transform node of VRML specifying properties of geometry and its appearance. This node defines a 2D transformation applied to texture coordinates. This affect the way textures are applied to the surfaces of subsequent shapes. Transformation consisits of(in order) a non-uniform scale about an arbitrary center point, a rotation about that same point, and a translation. This allows a user to change the size and position of the textures on the shape. By default : myTranslation (0 0) myRotation (0) myScaleFactor (1 1) myCenter (0 0))#");
    py::class_<Vrml_Transform , shared_ptr<Vrml_Transform>  >(m,"Vrml_Transform",R"#(defines a Transform of VRML specifying transform properties. This node defines a geometric 3D transformation consisting of (in order) a (possibly) non-uniform scale about an arbitrary point, a rotation about an arbitrary point and axis and translation. By default : myTranslation (0,0,0) myRotation (0,0,1,0) myScaleFactor (1,1,1) myScaleOrientation (0,0,1,0) myCenter (0,0,0))#");
    py::class_<Vrml_TransformSeparator , shared_ptr<Vrml_TransformSeparator>  >(m,"Vrml_TransformSeparator",R"#(defines a TransformSeparator node of VRML specifying group properties. This group node is similar to separator node in that it saves state before traversing its children and restores it afterwards. This node can be used to isolate transformations to light sources or objects.)#");
    py::class_<Vrml_Translation , shared_ptr<Vrml_Translation>  >(m,"Vrml_Translation",R"#(defines a Translation of VRML specifying transform properties. This node defines a translation by 3D vector. By default : myTranslation (0,0,0))#");
    py::class_<Vrml_WWWAnchor , shared_ptr<Vrml_WWWAnchor>  >(m,"Vrml_WWWAnchor",R"#(defines a WWWAnchor node of VRML specifying group properties. The WWWAnchor group node loads a new scene into a VRML browser when one of its children is closen. Exactly how a user "chooses" a child of the WWWAnchor is up to the VRML browser. WWWAnchor with an empty ("") name does nothing when its children are chosen. WWWAnchor behaves like a Separator, pushing the traversal state before traversing its children and popping it afterwards.)#");
    py::class_<Vrml_WWWInline , shared_ptr<Vrml_WWWInline>  >(m,"Vrml_WWWInline",R"#(defines a WWWInline node of VRML specifying group properties. The WWWInline group node reads its children from anywhere in the World Wide Web. Exactly when its children are read is not defined; reading the children may be delayed until the WWWInline is actually displayed. WWWInline with an empty ("") name does nothing. WWWInline behaves like a Separator, pushing the traversal state before traversing its children and popping it afterwards. By defaults: myName ("") myBboxSize (0,0,0) myBboxCenter (0,0,0))#");
    py::class_<Vrml_AsciiText ,opencascade::handle<Vrml_AsciiText>  , Standard_Transient >(m,"Vrml_AsciiText",R"#(defines a AsciiText node of VRML specifying geometry shapes. This node represents strings of text characters from ASCII coded character set. All subsequent strings advance y by -( size * spacing). The justification field determines the placement of the strings in the x dimension. LEFT (the default) places the left edge of each string at x=0. CENTER places the center of each string at x=0. RIGHT places the right edge of each string at x=0. Text is rendered from left to right, top to bottom in the font set by FontStyle. The default value for the wigth field indicates the natural width should be used for that string.defines a AsciiText node of VRML specifying geometry shapes. This node represents strings of text characters from ASCII coded character set. All subsequent strings advance y by -( size * spacing). The justification field determines the placement of the strings in the x dimension. LEFT (the default) places the left edge of each string at x=0. CENTER places the center of each string at x=0. RIGHT places the right edge of each string at x=0. Text is rendered from left to right, top to bottom in the font set by FontStyle. The default value for the wigth field indicates the natural width should be used for that string.defines a AsciiText node of VRML specifying geometry shapes. This node represents strings of text characters from ASCII coded character set. All subsequent strings advance y by -( size * spacing). The justification field determines the placement of the strings in the x dimension. LEFT (the default) places the left edge of each string at x=0. CENTER places the center of each string at x=0. RIGHT places the right edge of each string at x=0. Text is rendered from left to right, top to bottom in the font set by FontStyle. The default value for the wigth field indicates the natural width should be used for that string.)#");
    py::class_<Vrml_ConfigurationNode ,opencascade::handle<Vrml_ConfigurationNode>  , DE_ConfigurationNode >(m,"Vrml_ConfigurationNode",R"#(The purpose of this class is to configure the transfer process for VRML format Stores the necessary settings for Vrml_Provider. Configures and creates special provider to transfer VRML files.)#");
    py::class_<Vrml_Coordinate3 ,opencascade::handle<Vrml_Coordinate3>  , Standard_Transient >(m,"Vrml_Coordinate3",R"#(defines a Coordinate3 node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D coordinates to be used by a subsequent IndexedFaceSet, IndexedLineSet, or PointSet node. This node does not produce a visible result during rendering; it simply replaces the current coordinates in the rendering state for subsequent nodes to use.defines a Coordinate3 node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D coordinates to be used by a subsequent IndexedFaceSet, IndexedLineSet, or PointSet node. This node does not produce a visible result during rendering; it simply replaces the current coordinates in the rendering state for subsequent nodes to use.defines a Coordinate3 node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D coordinates to be used by a subsequent IndexedFaceSet, IndexedLineSet, or PointSet node. This node does not produce a visible result during rendering; it simply replaces the current coordinates in the rendering state for subsequent nodes to use.)#");
    py::class_<Vrml_IndexedFaceSet ,opencascade::handle<Vrml_IndexedFaceSet>  , Standard_Transient >(m,"Vrml_IndexedFaceSet",R"#(defines a IndexedFaceSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing faces (polygons) from vertices located at the current coordinates. IndexedFaceSet uses the indices in its coordIndex to define polygonal faces. An index of -1 separates faces (so a -1 at the end of the list is optional).defines a IndexedFaceSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing faces (polygons) from vertices located at the current coordinates. IndexedFaceSet uses the indices in its coordIndex to define polygonal faces. An index of -1 separates faces (so a -1 at the end of the list is optional).defines a IndexedFaceSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing faces (polygons) from vertices located at the current coordinates. IndexedFaceSet uses the indices in its coordIndex to define polygonal faces. An index of -1 separates faces (so a -1 at the end of the list is optional).)#");
    py::class_<Vrml_IndexedLineSet ,opencascade::handle<Vrml_IndexedLineSet>  , Standard_Transient >(m,"Vrml_IndexedLineSet",R"#(defines a IndexedLineSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing polylines from vertices located at the current coordinates. IndexedLineSet uses the indices in its coordIndex field to specify the polylines. An index of -1 separates one polyline from the next (thus, a final -1 is optional). the current polyline has ended and the next one begins. Treatment of the current material and normal binding is as follows: The PER_PART binding specifies a material or normal for each segment of the line. The PER_FACE binding specifies a material or normal for each polyline. PER_VERTEX specifies a material or normal for each vertex. The corresponding _INDEXED bindings are the same, but use the materialIndex or normalIndex indices. The DEFAULT material binding is equal to OVERALL. The DEFAULT normal binding is equal to PER_VERTEX_INDEXED; if insufficient normals exist in the state, the lines will be drawn unlit. The same rules for texture coordinate generation as IndexedFaceSet are used.defines a IndexedLineSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing polylines from vertices located at the current coordinates. IndexedLineSet uses the indices in its coordIndex field to specify the polylines. An index of -1 separates one polyline from the next (thus, a final -1 is optional). the current polyline has ended and the next one begins. Treatment of the current material and normal binding is as follows: The PER_PART binding specifies a material or normal for each segment of the line. The PER_FACE binding specifies a material or normal for each polyline. PER_VERTEX specifies a material or normal for each vertex. The corresponding _INDEXED bindings are the same, but use the materialIndex or normalIndex indices. The DEFAULT material binding is equal to OVERALL. The DEFAULT normal binding is equal to PER_VERTEX_INDEXED; if insufficient normals exist in the state, the lines will be drawn unlit. The same rules for texture coordinate generation as IndexedFaceSet are used.defines a IndexedLineSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing polylines from vertices located at the current coordinates. IndexedLineSet uses the indices in its coordIndex field to specify the polylines. An index of -1 separates one polyline from the next (thus, a final -1 is optional). the current polyline has ended and the next one begins. Treatment of the current material and normal binding is as follows: The PER_PART binding specifies a material or normal for each segment of the line. The PER_FACE binding specifies a material or normal for each polyline. PER_VERTEX specifies a material or normal for each vertex. The corresponding _INDEXED bindings are the same, but use the materialIndex or normalIndex indices. The DEFAULT material binding is equal to OVERALL. The DEFAULT normal binding is equal to PER_VERTEX_INDEXED; if insufficient normals exist in the state, the lines will be drawn unlit. The same rules for texture coordinate generation as IndexedFaceSet are used.)#");
    py::class_<Vrml_LOD ,opencascade::handle<Vrml_LOD>  , Standard_Transient >(m,"Vrml_LOD",R"#(defines a LOD (level of detailization) node of VRML specifying properties of geometry and its appearance. This group node is used to allow applications to switch between various representations of objects automatically. The children of this node typically represent the same object or objects at the varying of Levels Of Detail (LOD), from highest detail to lowest.defines a LOD (level of detailization) node of VRML specifying properties of geometry and its appearance. This group node is used to allow applications to switch between various representations of objects automatically. The children of this node typically represent the same object or objects at the varying of Levels Of Detail (LOD), from highest detail to lowest.defines a LOD (level of detailization) node of VRML specifying properties of geometry and its appearance. This group node is used to allow applications to switch between various representations of objects automatically. The children of this node typically represent the same object or objects at the varying of Levels Of Detail (LOD), from highest detail to lowest.)#");
    py::class_<Vrml_Material ,opencascade::handle<Vrml_Material>  , Standard_Transient >(m,"Vrml_Material",R"#(defines a Material node of VRML specifying properties of geometry and its appearance. This node defines the current surface material properties for all subsequent shapes. Material sets several components of the current material during traversal. Different shapes interpret materials with multiple values differently. To bind materials to shapes, use a MaterialBinding node.defines a Material node of VRML specifying properties of geometry and its appearance. This node defines the current surface material properties for all subsequent shapes. Material sets several components of the current material during traversal. Different shapes interpret materials with multiple values differently. To bind materials to shapes, use a MaterialBinding node.defines a Material node of VRML specifying properties of geometry and its appearance. This node defines the current surface material properties for all subsequent shapes. Material sets several components of the current material during traversal. Different shapes interpret materials with multiple values differently. To bind materials to shapes, use a MaterialBinding node.)#");
    py::class_<Vrml_Normal ,opencascade::handle<Vrml_Normal>  , Standard_Transient >(m,"Vrml_Normal",R"#(defines a Normal node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D surface normal vectors to be used by vertex-based shape nodes (IndexedFaceSet, IndexedLineSet, PointSet) that follow it in the scene graph. This node does not produce a visible result during rendering; it simply replaces the current normals in the rendering state for subsequent nodes to use. This node contains one multiple-valued field that contains the normal vectors.defines a Normal node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D surface normal vectors to be used by vertex-based shape nodes (IndexedFaceSet, IndexedLineSet, PointSet) that follow it in the scene graph. This node does not produce a visible result during rendering; it simply replaces the current normals in the rendering state for subsequent nodes to use. This node contains one multiple-valued field that contains the normal vectors.defines a Normal node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D surface normal vectors to be used by vertex-based shape nodes (IndexedFaceSet, IndexedLineSet, PointSet) that follow it in the scene graph. This node does not produce a visible result during rendering; it simply replaces the current normals in the rendering state for subsequent nodes to use. This node contains one multiple-valued field that contains the normal vectors.)#");
    py::class_<Vrml_Provider ,opencascade::handle<Vrml_Provider>  , DE_Provider >(m,"Vrml_Provider",R"#(The class to transfer VRML files. Reads and Writes any VRML files into/from OCCT. Each operation needs configuration node.)#");
    py::class_<Vrml_SFImage ,opencascade::handle<Vrml_SFImage>  , Standard_Transient >(m,"Vrml_SFImage",R"#(defines SFImage type of VRML field types.defines SFImage type of VRML field types.defines SFImage type of VRML field types.)#");
    py::class_<Vrml_TextureCoordinate2 ,opencascade::handle<Vrml_TextureCoordinate2>  , Standard_Transient >(m,"Vrml_TextureCoordinate2",R"#(defines a TextureCoordinate2 node of VRML specifying properties of geometry and its appearance. This node defines a set of 2D coordinates to be used to map textures to the vertices of subsequent PointSet, IndexedLineSet, or IndexedFaceSet objects. It replaces the current texture coordinates in the rendering state for the shapes to use. Texture coordinates range from 0 to 1 across the texture. The horizontal coordinate, called S, is specified first, followed by vertical coordinate, T. By default : myPoint (0 0)defines a TextureCoordinate2 node of VRML specifying properties of geometry and its appearance. This node defines a set of 2D coordinates to be used to map textures to the vertices of subsequent PointSet, IndexedLineSet, or IndexedFaceSet objects. It replaces the current texture coordinates in the rendering state for the shapes to use. Texture coordinates range from 0 to 1 across the texture. The horizontal coordinate, called S, is specified first, followed by vertical coordinate, T. By default : myPoint (0 0)defines a TextureCoordinate2 node of VRML specifying properties of geometry and its appearance. This node defines a set of 2D coordinates to be used to map textures to the vertices of subsequent PointSet, IndexedLineSet, or IndexedFaceSet objects. It replaces the current texture coordinates in the rendering state for the shapes to use. Texture coordinates range from 0 to 1 across the texture. The horizontal coordinate, called S, is specified first, followed by vertical coordinate, T. By default : myPoint (0 0))#");

};

// user-defined post-inclusion per module

// user-defined post