
// 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 <XmlMDF_ADriverTable.hxx>
#include <Message_Messenger.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TDF_Attribute.hxx>
#include <XmlObjMgt_Persistent.hxx>

// module includes
#include <XmlMDataStd.hxx>
#include <XmlMDataStd_AsciiStringDriver.hxx>
#include <XmlMDataStd_BooleanArrayDriver.hxx>
#include <XmlMDataStd_BooleanListDriver.hxx>
#include <XmlMDataStd_ByteArrayDriver.hxx>
#include <XmlMDataStd_ExpressionDriver.hxx>
#include <XmlMDataStd_ExtStringArrayDriver.hxx>
#include <XmlMDataStd_ExtStringListDriver.hxx>
#include <XmlMDataStd_GenericEmptyDriver.hxx>
#include <XmlMDataStd_GenericExtStringDriver.hxx>
#include <XmlMDataStd_IntegerArrayDriver.hxx>
#include <XmlMDataStd_IntegerDriver.hxx>
#include <XmlMDataStd_IntegerListDriver.hxx>
#include <XmlMDataStd_IntPackedMapDriver.hxx>
#include <XmlMDataStd_NamedDataDriver.hxx>
#include <XmlMDataStd_RealArrayDriver.hxx>
#include <XmlMDataStd_RealDriver.hxx>
#include <XmlMDataStd_RealListDriver.hxx>
#include <XmlMDataStd_ReferenceArrayDriver.hxx>
#include <XmlMDataStd_ReferenceListDriver.hxx>
#include <XmlMDataStd_TreeNodeDriver.hxx>
#include <XmlMDataStd_UAttributeDriver.hxx>
#include <XmlMDataStd_VariableDriver.hxx>

// template related includes


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

// user-defined inclusion per module

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


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

//Python trampoline classes

// classes

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

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

    // nested enums

    static_cast<py::class_<XmlMDataStd , shared_ptr<XmlMDataStd>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("AddDrivers_s",
                    (void (*)(  const handle<XmlMDF_ADriverTable> & ,   const handle<Message_Messenger> &  ) ) static_cast<void (*)(  const handle<XmlMDF_ADriverTable> & ,   const handle<Message_Messenger> &  ) >(&XmlMDataStd::AddDrivers),
                    R"#(Adds the attribute drivers to <aDriverTable>.)#"  , py::arg("aDriverTable"),  py::arg("anMsgDrv")
          )
    // 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 XmlMDataStd_AsciiStringDriver from ./opencascade/XmlMDataStd_AsciiStringDriver.hxx
    klass = m.attr("XmlMDataStd_AsciiStringDriver");


    // nested enums

    static_cast<py::class_<XmlMDataStd_AsciiStringDriver ,opencascade::handle<XmlMDataStd_AsciiStringDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_AsciiStringDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_AsciiStringDriver::*)() const>(&XmlMDataStd_AsciiStringDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_AsciiStringDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_AsciiStringDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_AsciiStringDriver::Paste),
             R"#(persistent -> transient (retrieve))#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_AsciiStringDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_AsciiStringDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_AsciiStringDriver::Paste),
             R"#(transient -> persistent (store))#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_AsciiStringDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_AsciiStringDriver::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> & (XmlMDataStd_AsciiStringDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_AsciiStringDriver::*)() const>(&XmlMDataStd_AsciiStringDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_BooleanArrayDriver ,opencascade::handle<XmlMDataStd_BooleanArrayDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_BooleanArrayDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_BooleanArrayDriver::*)() const>(&XmlMDataStd_BooleanArrayDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_BooleanArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_BooleanArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_BooleanArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_BooleanArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_BooleanArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_BooleanArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_BooleanArrayDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_BooleanArrayDriver::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> & (XmlMDataStd_BooleanArrayDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_BooleanArrayDriver::*)() const>(&XmlMDataStd_BooleanArrayDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_BooleanListDriver ,opencascade::handle<XmlMDataStd_BooleanListDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_BooleanListDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_BooleanListDriver::*)() const>(&XmlMDataStd_BooleanListDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_BooleanListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_BooleanListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_BooleanListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_BooleanListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_BooleanListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_BooleanListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_BooleanListDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_BooleanListDriver::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> & (XmlMDataStd_BooleanListDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_BooleanListDriver::*)() const>(&XmlMDataStd_BooleanListDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_ByteArrayDriver ,opencascade::handle<XmlMDataStd_ByteArrayDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_ByteArrayDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_ByteArrayDriver::*)() const>(&XmlMDataStd_ByteArrayDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_ByteArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_ByteArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_ByteArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_ByteArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_ByteArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_ByteArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_ByteArrayDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_ByteArrayDriver::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> & (XmlMDataStd_ByteArrayDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_ByteArrayDriver::*)() const>(&XmlMDataStd_ByteArrayDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_ExpressionDriver ,opencascade::handle<XmlMDataStd_ExpressionDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_ExpressionDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_ExpressionDriver::*)() const>(&XmlMDataStd_ExpressionDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_ExpressionDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_ExpressionDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_ExpressionDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_ExpressionDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_ExpressionDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_ExpressionDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_ExpressionDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_ExpressionDriver::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> & (XmlMDataStd_ExpressionDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_ExpressionDriver::*)() const>(&XmlMDataStd_ExpressionDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_ExtStringArrayDriver ,opencascade::handle<XmlMDataStd_ExtStringArrayDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_ExtStringArrayDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_ExtStringArrayDriver::*)() const>(&XmlMDataStd_ExtStringArrayDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_ExtStringArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_ExtStringArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_ExtStringArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_ExtStringArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_ExtStringArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_ExtStringArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_ExtStringArrayDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_ExtStringArrayDriver::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> & (XmlMDataStd_ExtStringArrayDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_ExtStringArrayDriver::*)() const>(&XmlMDataStd_ExtStringArrayDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_ExtStringListDriver ,opencascade::handle<XmlMDataStd_ExtStringListDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_ExtStringListDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_ExtStringListDriver::*)() const>(&XmlMDataStd_ExtStringListDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_ExtStringListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_ExtStringListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_ExtStringListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_ExtStringListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_ExtStringListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_ExtStringListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_ExtStringListDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_ExtStringListDriver::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> & (XmlMDataStd_ExtStringListDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_ExtStringListDriver::*)() const>(&XmlMDataStd_ExtStringListDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_GenericEmptyDriver ,opencascade::handle<XmlMDataStd_GenericEmptyDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_GenericEmptyDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_GenericEmptyDriver::*)() const>(&XmlMDataStd_GenericEmptyDriver::NewEmpty),
             R"#()#" 
          )
        .def("SourceType",
             (handle<Standard_Type> (XmlMDataStd_GenericEmptyDriver::*)() const) static_cast<handle<Standard_Type> (XmlMDataStd_GenericEmptyDriver::*)() const>(&XmlMDataStd_GenericEmptyDriver::SourceType),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_GenericEmptyDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_GenericEmptyDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_GenericEmptyDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_GenericEmptyDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_GenericEmptyDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_GenericEmptyDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_GenericEmptyDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_GenericEmptyDriver::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> & (XmlMDataStd_GenericEmptyDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_GenericEmptyDriver::*)() const>(&XmlMDataStd_GenericEmptyDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_GenericExtStringDriver ,opencascade::handle<XmlMDataStd_GenericExtStringDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_GenericExtStringDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_GenericExtStringDriver::*)() const>(&XmlMDataStd_GenericExtStringDriver::NewEmpty),
             R"#()#" 
          )
        .def("SourceType",
             (handle<Standard_Type> (XmlMDataStd_GenericExtStringDriver::*)() const) static_cast<handle<Standard_Type> (XmlMDataStd_GenericExtStringDriver::*)() const>(&XmlMDataStd_GenericExtStringDriver::SourceType),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_GenericExtStringDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_GenericExtStringDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_GenericExtStringDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_GenericExtStringDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_GenericExtStringDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_GenericExtStringDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_GenericExtStringDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_GenericExtStringDriver::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> & (XmlMDataStd_GenericExtStringDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_GenericExtStringDriver::*)() const>(&XmlMDataStd_GenericExtStringDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_IntPackedMapDriver ,opencascade::handle<XmlMDataStd_IntPackedMapDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_IntPackedMapDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_IntPackedMapDriver::*)() const>(&XmlMDataStd_IntPackedMapDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_IntPackedMapDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_IntPackedMapDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_IntPackedMapDriver::Paste),
             R"#(persistent -> transient (retrieve))#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_IntPackedMapDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_IntPackedMapDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_IntPackedMapDriver::Paste),
             R"#(transient -> persistent (store))#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_IntPackedMapDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_IntPackedMapDriver::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> & (XmlMDataStd_IntPackedMapDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_IntPackedMapDriver::*)() const>(&XmlMDataStd_IntPackedMapDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_IntegerArrayDriver ,opencascade::handle<XmlMDataStd_IntegerArrayDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_IntegerArrayDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_IntegerArrayDriver::*)() const>(&XmlMDataStd_IntegerArrayDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_IntegerArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_IntegerArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_IntegerArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_IntegerArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_IntegerArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_IntegerArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_IntegerArrayDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_IntegerArrayDriver::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> & (XmlMDataStd_IntegerArrayDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_IntegerArrayDriver::*)() const>(&XmlMDataStd_IntegerArrayDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_IntegerDriver ,opencascade::handle<XmlMDataStd_IntegerDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_IntegerDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_IntegerDriver::*)() const>(&XmlMDataStd_IntegerDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_IntegerDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_IntegerDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_IntegerDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_IntegerDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_IntegerDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_IntegerDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_IntegerDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_IntegerDriver::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> & (XmlMDataStd_IntegerDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_IntegerDriver::*)() const>(&XmlMDataStd_IntegerDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_IntegerListDriver ,opencascade::handle<XmlMDataStd_IntegerListDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_IntegerListDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_IntegerListDriver::*)() const>(&XmlMDataStd_IntegerListDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_IntegerListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_IntegerListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_IntegerListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_IntegerListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_IntegerListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_IntegerListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_IntegerListDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_IntegerListDriver::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> & (XmlMDataStd_IntegerListDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_IntegerListDriver::*)() const>(&XmlMDataStd_IntegerListDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_NamedDataDriver ,opencascade::handle<XmlMDataStd_NamedDataDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_NamedDataDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_NamedDataDriver::*)() const>(&XmlMDataStd_NamedDataDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_NamedDataDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_NamedDataDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_NamedDataDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_NamedDataDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_NamedDataDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_NamedDataDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_NamedDataDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_NamedDataDriver::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> & (XmlMDataStd_NamedDataDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_NamedDataDriver::*)() const>(&XmlMDataStd_NamedDataDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_RealArrayDriver ,opencascade::handle<XmlMDataStd_RealArrayDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_RealArrayDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_RealArrayDriver::*)() const>(&XmlMDataStd_RealArrayDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_RealArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_RealArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_RealArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_RealArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_RealArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_RealArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_RealArrayDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_RealArrayDriver::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> & (XmlMDataStd_RealArrayDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_RealArrayDriver::*)() const>(&XmlMDataStd_RealArrayDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_RealDriver ,opencascade::handle<XmlMDataStd_RealDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_RealDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_RealDriver::*)() const>(&XmlMDataStd_RealDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_RealDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_RealDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_RealDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_RealDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_RealDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_RealDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_RealDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_RealDriver::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> & (XmlMDataStd_RealDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_RealDriver::*)() const>(&XmlMDataStd_RealDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_RealListDriver ,opencascade::handle<XmlMDataStd_RealListDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_RealListDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_RealListDriver::*)() const>(&XmlMDataStd_RealListDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_RealListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_RealListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_RealListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_RealListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_RealListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_RealListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_RealListDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_RealListDriver::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> & (XmlMDataStd_RealListDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_RealListDriver::*)() const>(&XmlMDataStd_RealListDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_ReferenceArrayDriver ,opencascade::handle<XmlMDataStd_ReferenceArrayDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_ReferenceArrayDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_ReferenceArrayDriver::*)() const>(&XmlMDataStd_ReferenceArrayDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_ReferenceArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_ReferenceArrayDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_ReferenceArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_ReferenceArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_ReferenceArrayDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_ReferenceArrayDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_ReferenceArrayDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_ReferenceArrayDriver::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> & (XmlMDataStd_ReferenceArrayDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_ReferenceArrayDriver::*)() const>(&XmlMDataStd_ReferenceArrayDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_ReferenceListDriver ,opencascade::handle<XmlMDataStd_ReferenceListDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_ReferenceListDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_ReferenceListDriver::*)() const>(&XmlMDataStd_ReferenceListDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_ReferenceListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_ReferenceListDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_ReferenceListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_ReferenceListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_ReferenceListDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_ReferenceListDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_ReferenceListDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_ReferenceListDriver::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> & (XmlMDataStd_ReferenceListDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_ReferenceListDriver::*)() const>(&XmlMDataStd_ReferenceListDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_TreeNodeDriver ,opencascade::handle<XmlMDataStd_TreeNodeDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_TreeNodeDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_TreeNodeDriver::*)() const>(&XmlMDataStd_TreeNodeDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_TreeNodeDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_TreeNodeDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_TreeNodeDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_TreeNodeDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_TreeNodeDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_TreeNodeDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_TreeNodeDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_TreeNodeDriver::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> & (XmlMDataStd_TreeNodeDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_TreeNodeDriver::*)() const>(&XmlMDataStd_TreeNodeDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_UAttributeDriver ,opencascade::handle<XmlMDataStd_UAttributeDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_UAttributeDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_UAttributeDriver::*)() const>(&XmlMDataStd_UAttributeDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_UAttributeDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_UAttributeDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_UAttributeDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_UAttributeDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_UAttributeDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_UAttributeDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_UAttributeDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_UAttributeDriver::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> & (XmlMDataStd_UAttributeDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_UAttributeDriver::*)() const>(&XmlMDataStd_UAttributeDriver::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<XmlMDataStd_VariableDriver ,opencascade::handle<XmlMDataStd_VariableDriver>  , XmlMDF_ADriver >>(klass)
    // constructors
        .def(py::init<  const handle<Message_Messenger> & >()  , py::arg("theMessageDriver") )
    // custom constructors
    // methods
        .def("NewEmpty",
             (handle<TDF_Attribute> (XmlMDataStd_VariableDriver::*)() const) static_cast<handle<TDF_Attribute> (XmlMDataStd_VariableDriver::*)() const>(&XmlMDataStd_VariableDriver::NewEmpty),
             R"#()#" 
          )
        .def("Paste",
             (Standard_Boolean (XmlMDataStd_VariableDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const) static_cast<Standard_Boolean (XmlMDataStd_VariableDriver::*)(  const XmlObjMgt_Persistent & ,   const handle<TDF_Attribute> & ,  XmlObjMgt_RRelocationTable &  ) const>(&XmlMDataStd_VariableDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
        .def("Paste",
             (void (XmlMDataStd_VariableDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const) static_cast<void (XmlMDataStd_VariableDriver::*)(  const handle<TDF_Attribute> & ,  XmlObjMgt_Persistent & ,  XmlObjMgt_SRelocationTable &  ) const>(&XmlMDataStd_VariableDriver::Paste),
             R"#()#"  , py::arg("Source"),  py::arg("Target"),  py::arg("RelocTable")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&XmlMDataStd_VariableDriver::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&XmlMDataStd_VariableDriver::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> & (XmlMDataStd_VariableDriver::*)() const) static_cast< const handle<Standard_Type> & (XmlMDataStd_VariableDriver::*)() const>(&XmlMDataStd_VariableDriver::DynamicType),
             R"#()#"
             
         )
;

// functions

// ./opencascade/XmlMDataStd.hxx
// ./opencascade/XmlMDataStd_AsciiStringDriver.hxx
// ./opencascade/XmlMDataStd_BooleanArrayDriver.hxx
// ./opencascade/XmlMDataStd_BooleanListDriver.hxx
// ./opencascade/XmlMDataStd_ByteArrayDriver.hxx
// ./opencascade/XmlMDataStd_ExpressionDriver.hxx
// ./opencascade/XmlMDataStd_ExtStringArrayDriver.hxx
// ./opencascade/XmlMDataStd_ExtStringListDriver.hxx
// ./opencascade/XmlMDataStd_GenericEmptyDriver.hxx
// ./opencascade/XmlMDataStd_GenericExtStringDriver.hxx
// ./opencascade/XmlMDataStd_IntPackedMapDriver.hxx
// ./opencascade/XmlMDataStd_IntegerArrayDriver.hxx
// ./opencascade/XmlMDataStd_IntegerDriver.hxx
// ./opencascade/XmlMDataStd_IntegerListDriver.hxx
// ./opencascade/XmlMDataStd_NamedDataDriver.hxx
// ./opencascade/XmlMDataStd_RealArrayDriver.hxx
// ./opencascade/XmlMDataStd_RealDriver.hxx
// ./opencascade/XmlMDataStd_RealListDriver.hxx
// ./opencascade/XmlMDataStd_ReferenceArrayDriver.hxx
// ./opencascade/XmlMDataStd_ReferenceListDriver.hxx
// ./opencascade/XmlMDataStd_TreeNodeDriver.hxx
// ./opencascade/XmlMDataStd_UAttributeDriver.hxx
// ./opencascade/XmlMDataStd_VariableDriver.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
