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

#include <gp_XYZ.hxx>
#include <gp_XY.hxx>

// includes to resolve forward declarations
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Standard_Mutex.hxx>
#include <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>

// module includes
#include <NCollection_AccAllocator.hxx>
#include <NCollection_AliasedArray.hxx>
#include <NCollection_AlignedAllocator.hxx>
#include <NCollection_Allocator.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_Array2.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <NCollection_BaseList.hxx>
#include <NCollection_BaseMap.hxx>
#include <NCollection_BasePointerVector.hxx>
#include <NCollection_BaseSequence.hxx>
#include <NCollection_Buffer.hxx>
#include <NCollection_CellFilter.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_DefaultHasher.hxx>
#include <NCollection_DefineAlloc.hxx>
#include <NCollection_DefineHArray1.hxx>
#include <NCollection_DefineHArray2.hxx>
#include <NCollection_DefineHasher.hxx>
#include <NCollection_DefineHSequence.hxx>
#include <NCollection_DoubleMap.hxx>
#include <NCollection_DynamicArray.hxx>
#include <NCollection_EBTree.hxx>
#include <NCollection_Handle.hxx>
#include <NCollection_HArray1.hxx>
#include <NCollection_HArray2.hxx>
#include <NCollection_HeapAllocator.hxx>
#include <NCollection_HSequence.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_IndexedDataMap.hxx>
#include <NCollection_IndexedIterator.hxx>
#include <NCollection_IndexedMap.hxx>
#include <NCollection_Iterator.hxx>
#include <NCollection_Lerp.hxx>
#include <NCollection_List.hxx>
#include <NCollection_ListNode.hxx>
#include <NCollection_LocalArray.hxx>
#include <NCollection_Map.hxx>
#include <NCollection_MapAlgo.hxx>
#include <NCollection_Mat3.hxx>
#include <NCollection_Mat4.hxx>
#include <NCollection_OccAllocator.hxx>
#include <NCollection_Primes.hxx>
#include <NCollection_Sequence.hxx>
#include <NCollection_SparseArray.hxx>
#include <NCollection_SparseArrayBase.hxx>
#include <NCollection_StlIterator.hxx>
#include <NCollection_String.hxx>
#include <NCollection_TListIterator.hxx>
#include <NCollection_TListNode.hxx>
#include <NCollection_TypeDef.hxx>
#include <NCollection_UBTree.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <NCollection_UtfIterator.hxx>
#include <NCollection_UtfString.hxx>
#include <NCollection_Vec2.hxx>
#include <NCollection_Vec3.hxx>
#include <NCollection_Vec4.hxx>
#include <NCollection_Vector.hxx>
#include <NCollection_WinHeapAllocator.hxx>

// template related includes

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

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

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

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

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

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

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

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


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

// user-defined inclusion per module
const size_t DefaultBlockSize = 24600;
const size_t THE_DEFAULT_BLOCK_SIZE = DefaultBlockSize;

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


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

//Python trampoline classes
    class Py_NCollection_SparseArrayBase : public NCollection_SparseArrayBase{
    public:
        using NCollection_SparseArrayBase::NCollection_SparseArrayBase;


        // public pure virtual


        // protected pure virtual
        void createItem(Standard_Address theAddress,Standard_Address theOther) override { using return_type = void;
    PYBIND11_OVERLOAD_PURE(return_type,NCollection_SparseArrayBase,createItem,theAddress,theOther) };
        void destroyItem(Standard_Address theAddress) override { using return_type = void;
    PYBIND11_OVERLOAD_PURE(return_type,NCollection_SparseArrayBase,destroyItem,theAddress) };
        void copyItem(Standard_Address theAddress,Standard_Address theOther) override { using return_type = void;
    PYBIND11_OVERLOAD_PURE(return_type,NCollection_SparseArrayBase,copyItem,theAddress,theOther) };


        // private pure virtual

    };

// classes

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


    // nested enums

    static_cast<py::class_<NCollection_BaseAllocator ,opencascade::handle<NCollection_BaseAllocator>  , Standard_Transient >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("Allocate",
             (void * (NCollection_BaseAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_BaseAllocator::*)(  const size_t  ) >(&NCollection_BaseAllocator::Allocate),
             R"#()#"  , py::arg("theSize")
          )
        .def("AllocateOptimal",
             (void * (NCollection_BaseAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_BaseAllocator::*)(  const size_t  ) >(&NCollection_BaseAllocator::AllocateOptimal),
             R"#()#"  , py::arg("theSize")
          )
        .def("Free",
             (void (NCollection_BaseAllocator::*)( void *  ) ) static_cast<void (NCollection_BaseAllocator::*)( void *  ) >(&NCollection_BaseAllocator::Free),
             R"#()#"  , py::arg("theAddress")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("CommonBaseAllocator_s",
                    ( const handle<NCollection_BaseAllocator> & (*)() ) static_cast< const handle<NCollection_BaseAllocator> & (*)() >(&NCollection_BaseAllocator::CommonBaseAllocator),
                    R"#(CommonBaseAllocator This method is designed to have the only one BaseAllocator (to avoid useless copying of collections). However one can use operator new to create more BaseAllocators, but it is injurious.)#" 
          )
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_BaseAllocator::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_BaseAllocator::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> & (NCollection_BaseAllocator::*)() const) static_cast< const handle<Standard_Type> & (NCollection_BaseAllocator::*)() const>(&NCollection_BaseAllocator::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_BaseList , shared_ptr<NCollection_BaseList>  >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("Extent",
             (Standard_Integer (NCollection_BaseList::*)() const) static_cast<Standard_Integer (NCollection_BaseList::*)() const>(&NCollection_BaseList::Extent),
             R"#()#" 
          )
        .def("IsEmpty",
             (Standard_Boolean (NCollection_BaseList::*)() const) static_cast<Standard_Boolean (NCollection_BaseList::*)() const>(&NCollection_BaseList::IsEmpty),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Allocator",
             ( const handle<NCollection_BaseAllocator> & (NCollection_BaseList::*)() const) static_cast< const handle<NCollection_BaseAllocator> & (NCollection_BaseList::*)() const>(&NCollection_BaseList::Allocator),
             R"#(Returns attached allocator)#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_BaseMap , shared_ptr_nodelete<NCollection_BaseMap>  >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("NbBuckets",
             (Standard_Integer (NCollection_BaseMap::*)() const) static_cast<Standard_Integer (NCollection_BaseMap::*)() const>(&NCollection_BaseMap::NbBuckets),
             R"#(NbBuckets)#" 
          )
        .def("Extent",
             (Standard_Integer (NCollection_BaseMap::*)() const) static_cast<Standard_Integer (NCollection_BaseMap::*)() const>(&NCollection_BaseMap::Extent),
             R"#(Extent)#" 
          )
        .def("IsEmpty",
             (Standard_Boolean (NCollection_BaseMap::*)() const) static_cast<Standard_Boolean (NCollection_BaseMap::*)() const>(&NCollection_BaseMap::IsEmpty),
             R"#(IsEmpty)#" 
          )
        .def("Statistics",
             (void (NCollection_BaseMap::*)( Standard_OStream &  ) const) static_cast<void (NCollection_BaseMap::*)( Standard_OStream &  ) const>(&NCollection_BaseMap::Statistics),
             R"#(Statistics)#"  , py::arg("S")
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Allocator",
             ( const handle<NCollection_BaseAllocator> & (NCollection_BaseMap::*)() const) static_cast< const handle<NCollection_BaseAllocator> & (NCollection_BaseMap::*)() const>(&NCollection_BaseMap::Allocator),
             R"#(Returns attached allocator)#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_BasePointerVector , shared_ptr<NCollection_BasePointerVector>  >>(klass)
    // constructors
        .def(py::init<  >()  )
        .def(py::init<  const NCollection_BasePointerVector & >()  , py::arg("theOther") )
    // custom constructors
    // methods
        .def("IsEmpty",
             (bool (NCollection_BasePointerVector::*)() const) static_cast<bool (NCollection_BasePointerVector::*)() const>(&NCollection_BasePointerVector::IsEmpty),
             R"#(Checks for an empty status)#" 
          )
        .def("Size",
             (size_t (NCollection_BasePointerVector::*)() const) static_cast<size_t (NCollection_BasePointerVector::*)() const>(&NCollection_BasePointerVector::Size),
             R"#(Gets used size)#" 
          )
        .def("Capacity",
             (size_t (NCollection_BasePointerVector::*)() const) static_cast<size_t (NCollection_BasePointerVector::*)() const>(&NCollection_BasePointerVector::Capacity),
             R"#(Gets available capacity)#" 
          )
        .def("RemoveLast",
             (void (NCollection_BasePointerVector::*)() ) static_cast<void (NCollection_BasePointerVector::*)() >(&NCollection_BasePointerVector::RemoveLast),
             R"#(Erases last element, decrements size.)#" 
          )
        .def("Clear",
             (void (NCollection_BasePointerVector::*)(  const bool  ) ) static_cast<void (NCollection_BasePointerVector::*)(  const bool  ) >(&NCollection_BasePointerVector::Clear),
             R"#(Resets the size)#"  , py::arg("theReleaseMemory")=static_cast< const bool>(false)
          )
        .def("GetArray",
             (void * * (NCollection_BasePointerVector::*)() const) static_cast<void * * (NCollection_BasePointerVector::*)() const>(&NCollection_BasePointerVector::GetArray),
             R"#(Gets array, can be null)#" 
          )
        .def("Value",
             (void * (NCollection_BasePointerVector::*)(  const size_t  ) const) static_cast<void * (NCollection_BasePointerVector::*)(  const size_t  ) const>(&NCollection_BasePointerVector::Value),
             R"#(Gets value by index, no access validation)#"  , py::arg("theInd")
          )
        .def("Append",
             (void (NCollection_BasePointerVector::*)(  const void *  ) ) static_cast<void (NCollection_BasePointerVector::*)(  const void *  ) >(&NCollection_BasePointerVector::Append),
             R"#(Inserts new element at the end, increase size, if capacity is not enough, call resize.)#"  , py::arg("thePnt")
          )
        .def("SetValue",
             (void (NCollection_BasePointerVector::*)(  const size_t ,   const void *  ) ) static_cast<void (NCollection_BasePointerVector::*)(  const size_t ,   const void *  ) >(&NCollection_BasePointerVector::SetValue),
             R"#(Updates value of existed element, If index more then size, increase size of container, in this case capacity can be updated.)#"  , py::arg("theInd"),  py::arg("thePnt")
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

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


    // nested enums

    static_cast<py::class_<NCollection_BaseSequence , shared_ptr_nodelete<NCollection_BaseSequence>  >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("IsEmpty",
             (Standard_Boolean (NCollection_BaseSequence::*)() const) static_cast<Standard_Boolean (NCollection_BaseSequence::*)() const>(&NCollection_BaseSequence::IsEmpty),
             R"#()#" 
          )
        .def("Length",
             (Standard_Integer (NCollection_BaseSequence::*)() const) static_cast<Standard_Integer (NCollection_BaseSequence::*)() const>(&NCollection_BaseSequence::Length),
             R"#()#" 
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
       .def("Allocator",
             ( const handle<NCollection_BaseAllocator> & (NCollection_BaseSequence::*)() const) static_cast< const handle<NCollection_BaseAllocator> & (NCollection_BaseSequence::*)() const>(&NCollection_BaseSequence::Allocator),
             R"#(Returns attached allocator)#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_Buffer ,opencascade::handle<NCollection_Buffer>  , Standard_Transient >>(klass)
    // constructors
        .def(py::init<  const handle<NCollection_BaseAllocator> &, const Standard_Size,Standard_Byte * >()  , py::arg("theAlloc"),  py::arg("theSize")=static_cast< const Standard_Size>(0),  py::arg("theData")=static_cast<Standard_Byte *>(NULL) )
    // custom constructors
    // methods
        .def("Data",
             ( const Standard_Byte * (NCollection_Buffer::*)() const) static_cast< const Standard_Byte * (NCollection_Buffer::*)() const>(&NCollection_Buffer::Data),
             R"#(Returns buffer data)#" 
          )
        .def("ChangeData",
             (Standard_Byte * (NCollection_Buffer::*)() ) static_cast<Standard_Byte * (NCollection_Buffer::*)() >(&NCollection_Buffer::ChangeData),
             R"#(Returns buffer data)#" 
          )
        .def("IsEmpty",
             (bool (NCollection_Buffer::*)() const) static_cast<bool (NCollection_Buffer::*)() const>(&NCollection_Buffer::IsEmpty),
             R"#(Returns true if buffer is not allocated)#" 
          )
        .def("Size",
             (Standard_Size (NCollection_Buffer::*)() const) static_cast<Standard_Size (NCollection_Buffer::*)() const>(&NCollection_Buffer::Size),
             R"#(Return buffer length in bytes.)#" 
          )
        .def("SetAllocator",
             (void (NCollection_Buffer::*)(  const handle<NCollection_BaseAllocator> &  ) ) static_cast<void (NCollection_Buffer::*)(  const handle<NCollection_BaseAllocator> &  ) >(&NCollection_Buffer::SetAllocator),
             R"#(Assign new buffer allocator with de-allocation of buffer.)#"  , py::arg("theAlloc")
          )
        .def("Allocate",
             (bool (NCollection_Buffer::*)(  const Standard_Size  ) ) static_cast<bool (NCollection_Buffer::*)(  const Standard_Size  ) >(&NCollection_Buffer::Allocate),
             R"#(Allocate the buffer.)#"  , py::arg("theSize")
          )
        .def("Free",
             (void (NCollection_Buffer::*)() ) static_cast<void (NCollection_Buffer::*)() >(&NCollection_Buffer::Free),
             R"#(De-allocate buffer.)#" 
          )
        .def("DumpJson",
             (void (NCollection_Buffer::*)( Standard_OStream & ,  Standard_Integer  ) const) static_cast<void (NCollection_Buffer::*)( Standard_OStream & ,  Standard_Integer  ) const>(&NCollection_Buffer::DumpJson),
             R"#(Dumps the content of me into the stream)#"  , py::arg("theOStream"),  py::arg("theDepth")=static_cast<Standard_Integer>(- 1)
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_Buffer::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_Buffer::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("Allocator",
             ( const handle<NCollection_BaseAllocator> & (NCollection_Buffer::*)() const) static_cast< const handle<NCollection_BaseAllocator> & (NCollection_Buffer::*)() const>(&NCollection_Buffer::Allocator),
             R"#(Returns buffer allocator)#"
             
         )
       .def("DynamicType",
             ( const handle<Standard_Type> & (NCollection_Buffer::*)() const) static_cast< const handle<Standard_Type> & (NCollection_Buffer::*)() const>(&NCollection_Buffer::DynamicType),
             R"#()#"
             
         )
;

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

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

    // nested enums
        klass.attr("Dimension") = py::cast(int(NCollection_CellFilter_InspectorXY::Dimension));

    static_cast<py::class_<NCollection_CellFilter_InspectorXY , shared_ptr<NCollection_CellFilter_InspectorXY>  >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("Shift",
             (typename NCollection_CellFilter_InspectorXY::Point (NCollection_CellFilter_InspectorXY::*)(  const typename NCollection_CellFilter_InspectorXY::Point & ,  Standard_Real  ) const) static_cast<typename NCollection_CellFilter_InspectorXY::Point (NCollection_CellFilter_InspectorXY::*)(  const typename NCollection_CellFilter_InspectorXY::Point & ,  Standard_Real  ) const>(&NCollection_CellFilter_InspectorXY::Shift),
             R"#(Auxiliary method to shift point by each coordinate on given value; useful for preparing a points range for Inspect with tolerance)#"  , py::arg("thePnt"),  py::arg("theTol")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("Coord_s",
                    (Standard_Real (*)( int ,   const typename NCollection_CellFilter_InspectorXY::Point &  ) ) static_cast<Standard_Real (*)( int ,   const typename NCollection_CellFilter_InspectorXY::Point &  ) >(&NCollection_CellFilter_InspectorXY::Coord),
                    R"#(Access to coordinate)#"  , py::arg("i"),  py::arg("thePnt")
          )
    // 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 NCollection_CellFilter_InspectorXYZ from ./opencascade/NCollection_CellFilter.hxx
    klass = m.attr("NCollection_CellFilter_InspectorXYZ");

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

    // nested enums
        klass.attr("Dimension") = py::cast(int(NCollection_CellFilter_InspectorXYZ::Dimension));

    static_cast<py::class_<NCollection_CellFilter_InspectorXYZ , shared_ptr<NCollection_CellFilter_InspectorXYZ>  >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("Shift",
             (typename NCollection_CellFilter_InspectorXYZ::Point (NCollection_CellFilter_InspectorXYZ::*)(  const typename NCollection_CellFilter_InspectorXYZ::Point & ,  Standard_Real  ) const) static_cast<typename NCollection_CellFilter_InspectorXYZ::Point (NCollection_CellFilter_InspectorXYZ::*)(  const typename NCollection_CellFilter_InspectorXYZ::Point & ,  Standard_Real  ) const>(&NCollection_CellFilter_InspectorXYZ::Shift),
             R"#(Auxiliary method to shift point by each coordinate on given value; useful for preparing a points range for Inspect with tolerance)#"  , py::arg("thePnt"),  py::arg("theTol")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("Coord_s",
                    (Standard_Real (*)( int ,   const typename NCollection_CellFilter_InspectorXYZ::Point &  ) ) static_cast<Standard_Real (*)( int ,   const typename NCollection_CellFilter_InspectorXYZ::Point &  ) >(&NCollection_CellFilter_InspectorXYZ::Coord),
                    R"#(Access to coordinate)#"  , py::arg("i"),  py::arg("thePnt")
          )
    // 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 NCollection_DefaultHasher<bool> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_bool");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<bool> , shared_ptr<NCollection_DefaultHasher<bool>>>(m,"NCollection_DefaultHasher_bool");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<bool> , shared_ptr<NCollection_DefaultHasher<bool>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<bool>::*)(  const bool  ) const) static_cast<size_t (NCollection_DefaultHasher<bool>::*)(  const bool  ) const>(&NCollection_DefaultHasher<bool>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<bool>::*)(  const bool ,   const bool  ) const) static_cast<bool (NCollection_DefaultHasher<bool>::*)(  const bool ,   const bool  ) const>(&NCollection_DefaultHasher<bool>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<char16_t> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_char16_t");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<char16_t> , shared_ptr<NCollection_DefaultHasher<char16_t>>>(m,"NCollection_DefaultHasher_char16_t");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<char16_t> , shared_ptr<NCollection_DefaultHasher<char16_t>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<char16_t>::*)(  const char16_t  ) const) static_cast<size_t (NCollection_DefaultHasher<char16_t>::*)(  const char16_t  ) const>(&NCollection_DefaultHasher<char16_t>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<char16_t>::*)(  const char16_t ,   const char16_t  ) const) static_cast<bool (NCollection_DefaultHasher<char16_t>::*)(  const char16_t ,   const char16_t  ) const>(&NCollection_DefaultHasher<char16_t>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<char32_t> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_char32_t");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<char32_t> , shared_ptr<NCollection_DefaultHasher<char32_t>>>(m,"NCollection_DefaultHasher_char32_t");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<char32_t> , shared_ptr<NCollection_DefaultHasher<char32_t>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<char32_t>::*)(  const char32_t  ) const) static_cast<size_t (NCollection_DefaultHasher<char32_t>::*)(  const char32_t  ) const>(&NCollection_DefaultHasher<char32_t>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<char32_t>::*)(  const char32_t ,   const char32_t  ) const) static_cast<bool (NCollection_DefaultHasher<char32_t>::*)(  const char32_t ,   const char32_t  ) const>(&NCollection_DefaultHasher<char32_t>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<char> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_char");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<char> , shared_ptr<NCollection_DefaultHasher<char>>>(m,"NCollection_DefaultHasher_char");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<char> , shared_ptr<NCollection_DefaultHasher<char>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<char>::*)(  const char  ) const) static_cast<size_t (NCollection_DefaultHasher<char>::*)(  const char  ) const>(&NCollection_DefaultHasher<char>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<char>::*)(  const char ,   const char  ) const) static_cast<bool (NCollection_DefaultHasher<char>::*)(  const char ,   const char  ) const>(&NCollection_DefaultHasher<char>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<int> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_int");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<int> , shared_ptr<NCollection_DefaultHasher<int>>>(m,"NCollection_DefaultHasher_int");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<int> , shared_ptr<NCollection_DefaultHasher<int>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<int>::*)(  const int  ) const) static_cast<size_t (NCollection_DefaultHasher<int>::*)(  const int  ) const>(&NCollection_DefaultHasher<int>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<int>::*)(  const int ,   const int  ) const) static_cast<bool (NCollection_DefaultHasher<int>::*)(  const int ,   const int  ) const>(&NCollection_DefaultHasher<int>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<long long> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_long_long");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<long long> , shared_ptr<NCollection_DefaultHasher<long long>>>(m,"NCollection_DefaultHasher_long_long");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<long long> , shared_ptr<NCollection_DefaultHasher<long long>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<long long>::*)(  const long long  ) const) static_cast<size_t (NCollection_DefaultHasher<long long>::*)(  const long long  ) const>(&NCollection_DefaultHasher<long long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<long long>::*)(  const long long ,   const long long  ) const) static_cast<bool (NCollection_DefaultHasher<long long>::*)(  const long long ,   const long long  ) const>(&NCollection_DefaultHasher<long long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<long> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_long");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<long> , shared_ptr<NCollection_DefaultHasher<long>>>(m,"NCollection_DefaultHasher_long");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<long> , shared_ptr<NCollection_DefaultHasher<long>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<long>::*)(  const long  ) const) static_cast<size_t (NCollection_DefaultHasher<long>::*)(  const long  ) const>(&NCollection_DefaultHasher<long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<long>::*)(  const long ,   const long  ) const) static_cast<bool (NCollection_DefaultHasher<long>::*)(  const long ,   const long  ) const>(&NCollection_DefaultHasher<long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<short> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_short");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<short> , shared_ptr<NCollection_DefaultHasher<short>>>(m,"NCollection_DefaultHasher_short");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<short> , shared_ptr<NCollection_DefaultHasher<short>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<short>::*)(  const short  ) const) static_cast<size_t (NCollection_DefaultHasher<short>::*)(  const short  ) const>(&NCollection_DefaultHasher<short>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<short>::*)(  const short ,   const short  ) const) static_cast<bool (NCollection_DefaultHasher<short>::*)(  const short ,   const short  ) const>(&NCollection_DefaultHasher<short>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<signed char> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_signed_char");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<signed char> , shared_ptr<NCollection_DefaultHasher<signed char>>>(m,"NCollection_DefaultHasher_signed_char");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<signed char> , shared_ptr<NCollection_DefaultHasher<signed char>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<signed char>::*)(  const signed char  ) const) static_cast<size_t (NCollection_DefaultHasher<signed char>::*)(  const signed char  ) const>(&NCollection_DefaultHasher<signed char>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<signed char>::*)(  const signed char ,   const signed char  ) const) static_cast<bool (NCollection_DefaultHasher<signed char>::*)(  const signed char ,   const signed char  ) const>(&NCollection_DefaultHasher<signed char>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<unsigned char> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_unsigned_char");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<unsigned char> , shared_ptr<NCollection_DefaultHasher<unsigned char>>>(m,"NCollection_DefaultHasher_unsigned_char");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<unsigned char> , shared_ptr<NCollection_DefaultHasher<unsigned char>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<unsigned char>::*)(  const unsigned char  ) const) static_cast<size_t (NCollection_DefaultHasher<unsigned char>::*)(  const unsigned char  ) const>(&NCollection_DefaultHasher<unsigned char>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<unsigned char>::*)(  const unsigned char ,   const unsigned char  ) const) static_cast<bool (NCollection_DefaultHasher<unsigned char>::*)(  const unsigned char ,   const unsigned char  ) const>(&NCollection_DefaultHasher<unsigned char>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<unsigned int> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_unsigned_int");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<unsigned int> , shared_ptr<NCollection_DefaultHasher<unsigned int>>>(m,"NCollection_DefaultHasher_unsigned_int");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<unsigned int> , shared_ptr<NCollection_DefaultHasher<unsigned int>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<unsigned int>::*)(  const unsigned int  ) const) static_cast<size_t (NCollection_DefaultHasher<unsigned int>::*)(  const unsigned int  ) const>(&NCollection_DefaultHasher<unsigned int>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<unsigned int>::*)(  const unsigned int ,   const unsigned int  ) const) static_cast<bool (NCollection_DefaultHasher<unsigned int>::*)(  const unsigned int ,   const unsigned int  ) const>(&NCollection_DefaultHasher<unsigned int>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<unsigned long long> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_unsigned_long_long");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<unsigned long long> , shared_ptr<NCollection_DefaultHasher<unsigned long long>>>(m,"NCollection_DefaultHasher_unsigned_long_long");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<unsigned long long> , shared_ptr<NCollection_DefaultHasher<unsigned long long>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<unsigned long long>::*)(  const unsigned long long  ) const) static_cast<size_t (NCollection_DefaultHasher<unsigned long long>::*)(  const unsigned long long  ) const>(&NCollection_DefaultHasher<unsigned long long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<unsigned long long>::*)(  const unsigned long long ,   const unsigned long long  ) const) static_cast<bool (NCollection_DefaultHasher<unsigned long long>::*)(  const unsigned long long ,   const unsigned long long  ) const>(&NCollection_DefaultHasher<unsigned long long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<unsigned long> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_unsigned_long");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<unsigned long> , shared_ptr<NCollection_DefaultHasher<unsigned long>>>(m,"NCollection_DefaultHasher_unsigned_long");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<unsigned long> , shared_ptr<NCollection_DefaultHasher<unsigned long>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<unsigned long>::*)(  const unsigned long  ) const) static_cast<size_t (NCollection_DefaultHasher<unsigned long>::*)(  const unsigned long  ) const>(&NCollection_DefaultHasher<unsigned long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<unsigned long>::*)(  const unsigned long ,   const unsigned long  ) const) static_cast<bool (NCollection_DefaultHasher<unsigned long>::*)(  const unsigned long ,   const unsigned long  ) const>(&NCollection_DefaultHasher<unsigned long>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<unsigned short> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_unsigned_short");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<unsigned short> , shared_ptr<NCollection_DefaultHasher<unsigned short>>>(m,"NCollection_DefaultHasher_unsigned_short");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<unsigned short> , shared_ptr<NCollection_DefaultHasher<unsigned short>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<unsigned short>::*)(  const unsigned short  ) const) static_cast<size_t (NCollection_DefaultHasher<unsigned short>::*)(  const unsigned short  ) const>(&NCollection_DefaultHasher<unsigned short>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<unsigned short>::*)(  const unsigned short ,   const unsigned short  ) const) static_cast<bool (NCollection_DefaultHasher<unsigned short>::*)(  const unsigned short ,   const unsigned short  ) const>(&NCollection_DefaultHasher<unsigned short>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

    // Class NCollection_DefaultHasher<wchar_t> from ./opencascade/NCollection_DefaultHasher.hxx
    klass = m.attr("NCollection_DefaultHasher_wchar_t");

    // default constructor
    register_default_constructor<NCollection_DefaultHasher<wchar_t> , shared_ptr<NCollection_DefaultHasher<wchar_t>>>(m,"NCollection_DefaultHasher_wchar_t");

    // nested enums

    static_cast<py::class_<NCollection_DefaultHasher<wchar_t> , shared_ptr<NCollection_DefaultHasher<wchar_t>>  >>(klass)
    // constructors
    // custom constructors
    // methods
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
        .def("__call__",
             (size_t (NCollection_DefaultHasher<wchar_t>::*)(  const wchar_t  ) const) static_cast<size_t (NCollection_DefaultHasher<wchar_t>::*)(  const wchar_t  ) const>(&NCollection_DefaultHasher<wchar_t>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theKey")
          )
        .def("__call__",
             (bool (NCollection_DefaultHasher<wchar_t>::*)(  const wchar_t ,   const wchar_t  ) const) static_cast<bool (NCollection_DefaultHasher<wchar_t>::*)(  const wchar_t ,   const wchar_t  ) const>(&NCollection_DefaultHasher<wchar_t>::operator()),
             py::is_operator(),
             R"#()#"  , py::arg("theK1"),  py::arg("theK2")
          )
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

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


    // nested enums

    static_cast<py::class_<NCollection_SparseArrayBase , shared_ptr_nodelete<NCollection_SparseArrayBase> ,Py_NCollection_SparseArrayBase >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("Clear",
             (void (NCollection_SparseArrayBase::*)() ) static_cast<void (NCollection_SparseArrayBase::*)() >(&NCollection_SparseArrayBase::Clear),
             R"#(Clears all the data)#" 
          )
        .def("Size",
             (Standard_Size (NCollection_SparseArrayBase::*)() const) static_cast<Standard_Size (NCollection_SparseArrayBase::*)() const>(&NCollection_SparseArrayBase::Size),
             R"#(Returns number of currently contained items)#" 
          )
        .def("HasValue",
             (Standard_Boolean (NCollection_SparseArrayBase::*)(  const Standard_Size  ) const) static_cast<Standard_Boolean (NCollection_SparseArrayBase::*)(  const Standard_Size  ) const>(&NCollection_SparseArrayBase::HasValue),
             R"#(Check whether the value at given index is set)#"  , py::arg("theIndex")
          )
        .def("UnsetValue",
             (Standard_Boolean (NCollection_SparseArrayBase::*)(  const Standard_Size  ) ) static_cast<Standard_Boolean (NCollection_SparseArrayBase::*)(  const Standard_Size  ) >(&NCollection_SparseArrayBase::UnsetValue),
             R"#(Deletes the item from the array; returns True if that item was defined)#"  , py::arg("theIndex")
          )
    // methods using call by reference i.s.o. return
    // static methods
    // static methods using call by reference i.s.o. return
    // operators
    // additional methods and static methods
    // properties
    // methods returning by ref wrapped as properties
;

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


    // nested enums

    static_cast<py::class_<NCollection_UtfStringTool , shared_ptr<NCollection_UtfStringTool>  >>(klass)
    // constructors
        .def(py::init<  >()  )
    // custom constructors
    // methods
        .def("FromLocale",
             (wchar_t * (NCollection_UtfStringTool::*)(  const char *  ) ) static_cast<wchar_t * (NCollection_UtfStringTool::*)(  const char *  ) >(&NCollection_UtfStringTool::FromLocale),
             R"#(Convert the string from current locale into UNICODE (wide characters) using system APIs. Returned pointer will be released by this tool.)#"  , py::arg("theString")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("ToLocale_s",
                    (bool (*)(  const wchar_t * ,  char * ,   const Standard_Integer  ) ) static_cast<bool (*)(  const wchar_t * ,  char * ,   const Standard_Integer  ) >(&NCollection_UtfStringTool::ToLocale),
                    R"#(Convert the UNICODE (wide characters) string into locale using system APIs.)#"  , py::arg("theWideString"),  py::arg("theBuffer"),  py::arg("theSizeBytes")
          )
    // 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 NCollection_AccAllocator from ./opencascade/NCollection_AccAllocator.hxx
    klass = m.attr("NCollection_AccAllocator");


    // nested enums

    static_cast<py::class_<NCollection_AccAllocator ,opencascade::handle<NCollection_AccAllocator>  , NCollection_BaseAllocator >>(klass)
    // constructors
        .def(py::init<  const size_t >()  , py::arg("theBlockSize")=static_cast< const size_t>(DefaultBlockSize) )
    // custom constructors
    // methods
        .def("Allocate",
             (void * (NCollection_AccAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_AccAllocator::*)(  const size_t  ) >(&NCollection_AccAllocator::Allocate),
             R"#(Allocate memory with given size)#"  , py::arg("theSize")
          )
        .def("AllocateOptimal",
             (void * (NCollection_AccAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_AccAllocator::*)(  const size_t  ) >(&NCollection_AccAllocator::AllocateOptimal),
             R"#(Allocate memory with given size)#"  , py::arg("theSize")
          )
        .def("Free",
             (void (NCollection_AccAllocator::*)( void *  ) ) static_cast<void (NCollection_AccAllocator::*)( void *  ) >(&NCollection_AccAllocator::Free),
             R"#(Free a previously allocated memory; memory is returned to the OS when all allocations in some block are freed)#"  , py::arg("theAddress")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_AccAllocator::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_AccAllocator::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> & (NCollection_AccAllocator::*)() const) static_cast< const handle<Standard_Type> & (NCollection_AccAllocator::*)() const>(&NCollection_AccAllocator::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_AlignedAllocator ,opencascade::handle<NCollection_AlignedAllocator>  , NCollection_BaseAllocator >>(klass)
    // constructors
        .def(py::init<  const size_t >()  , py::arg("theAlignment") )
    // custom constructors
    // methods
        .def("Allocate",
             (void * (NCollection_AlignedAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_AlignedAllocator::*)(  const size_t  ) >(&NCollection_AlignedAllocator::Allocate),
             R"#(Allocate memory with given size. Returns NULL on failure.)#"  , py::arg("theSize")
          )
        .def("AllocateOptimal",
             (void * (NCollection_AlignedAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_AlignedAllocator::*)(  const size_t  ) >(&NCollection_AlignedAllocator::AllocateOptimal),
             R"#(Allocate memory with given size. Returns NULL on failure.)#"  , py::arg("theSize")
          )
        .def("Free",
             (void (NCollection_AlignedAllocator::*)( void *  ) ) static_cast<void (NCollection_AlignedAllocator::*)( void *  ) >(&NCollection_AlignedAllocator::Free),
             R"#(Free a previously allocated memory.)#"  , py::arg("thePtr")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_AlignedAllocator::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_AlignedAllocator::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> & (NCollection_AlignedAllocator::*)() const) static_cast< const handle<Standard_Type> & (NCollection_AlignedAllocator::*)() const>(&NCollection_AlignedAllocator::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_HeapAllocator ,opencascade::handle<NCollection_HeapAllocator>  , NCollection_BaseAllocator >>(klass)
    // constructors
    // custom constructors
    // methods
        .def("Allocate",
             (void * (NCollection_HeapAllocator::*)(  const Standard_Size  ) ) static_cast<void * (NCollection_HeapAllocator::*)(  const Standard_Size  ) >(&NCollection_HeapAllocator::Allocate),
             R"#()#"  , py::arg("theSize")
          )
        .def("AllocateOptimal",
             (void * (NCollection_HeapAllocator::*)(  const Standard_Size  ) ) static_cast<void * (NCollection_HeapAllocator::*)(  const Standard_Size  ) >(&NCollection_HeapAllocator::AllocateOptimal),
             R"#()#"  , py::arg("theSize")
          )
        .def("Free",
             (void (NCollection_HeapAllocator::*)( void *  ) ) static_cast<void (NCollection_HeapAllocator::*)( void *  ) >(&NCollection_HeapAllocator::Free),
             R"#()#"  , py::arg("anAddress")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("GlobalHeapAllocator_s",
                    ( const handle<NCollection_HeapAllocator> & (*)() ) static_cast< const handle<NCollection_HeapAllocator> & (*)() >(&NCollection_HeapAllocator::GlobalHeapAllocator),
                    R"#()#" 
          )
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_HeapAllocator::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_HeapAllocator::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> & (NCollection_HeapAllocator::*)() const) static_cast< const handle<Standard_Type> & (NCollection_HeapAllocator::*)() const>(&NCollection_HeapAllocator::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums
        py::enum_<NCollection_IncAllocator::IBlockSizeLevel>(klass, "IBlockSizeLevel_e", R"#(Description ability to next growing size each 5-th new block)#")
            .value("Min", NCollection_IncAllocator::IBlockSizeLevel::Min)
            .value("Small", NCollection_IncAllocator::IBlockSizeLevel::Small)
            .value("Medium", NCollection_IncAllocator::IBlockSizeLevel::Medium)
            .value("Large", NCollection_IncAllocator::IBlockSizeLevel::Large)
            .value("Max", NCollection_IncAllocator::IBlockSizeLevel::Max).export_values();

    static_cast<py::class_<NCollection_IncAllocator ,opencascade::handle<NCollection_IncAllocator>  , NCollection_BaseAllocator >>(klass)
    // constructors
        .def(py::init<  const size_t >()  , py::arg("theBlockSize")=static_cast< const size_t>(THE_DEFAULT_BLOCK_SIZE) )
    // custom constructors
    // methods
        .def("SetThreadSafe",
             (void (NCollection_IncAllocator::*)(  const bool  ) ) static_cast<void (NCollection_IncAllocator::*)(  const bool  ) >(&NCollection_IncAllocator::SetThreadSafe),
             R"#(Setup mutex for thread-safe allocations.)#"  , py::arg("theIsThreadSafe")=static_cast< const bool>(true)
          )
        .def("Allocate",
             (void * (NCollection_IncAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_IncAllocator::*)(  const size_t  ) >(&NCollection_IncAllocator::Allocate),
             R"#(Allocate memory with given size. Returns NULL on failure)#"  , py::arg("size")
          )
        .def("AllocateOptimal",
             (void * (NCollection_IncAllocator::*)(  const size_t  ) ) static_cast<void * (NCollection_IncAllocator::*)(  const size_t  ) >(&NCollection_IncAllocator::AllocateOptimal),
             R"#(Allocate memory with given size. Returns NULL on failure)#"  , py::arg("size")
          )
        .def("Free",
             (void (NCollection_IncAllocator::*)( void *  ) ) static_cast<void (NCollection_IncAllocator::*)( void *  ) >(&NCollection_IncAllocator::Free),
             R"#(Free a previously allocated memory. Does nothing)#"  , py::arg("arg0")
          )
        .def("Reset",
             (void (NCollection_IncAllocator::*)(  const bool  ) ) static_cast<void (NCollection_IncAllocator::*)(  const bool  ) >(&NCollection_IncAllocator::Reset),
             R"#(Re-initialize the allocator so that the next Allocate call should start allocating in the very beginning as though the allocator is just constructed. Warning: make sure that all previously allocated data are no more used in your code!)#"  , py::arg("theReleaseMemory")=static_cast< const bool>(false)
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_IncAllocator::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_IncAllocator::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> & (NCollection_IncAllocator::*)() const) static_cast< const handle<Standard_Type> & (NCollection_IncAllocator::*)() const>(&NCollection_IncAllocator::DynamicType),
             R"#()#"
             
         )
;

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


    // nested enums

    static_cast<py::class_<NCollection_WinHeapAllocator ,opencascade::handle<NCollection_WinHeapAllocator>  , NCollection_BaseAllocator >>(klass)
    // constructors
        .def(py::init<  const size_t >()  , py::arg("theInitSizeBytes")=static_cast< const size_t>(0x80000) )
    // custom constructors
    // methods
        .def("Allocate",
             (void * (NCollection_WinHeapAllocator::*)(  const Standard_Size  ) ) static_cast<void * (NCollection_WinHeapAllocator::*)(  const Standard_Size  ) >(&NCollection_WinHeapAllocator::Allocate),
             R"#(Allocate memory)#"  , py::arg("theSize")
          )
        .def("AllocateOptimal",
             (void * (NCollection_WinHeapAllocator::*)(  const Standard_Size  ) ) static_cast<void * (NCollection_WinHeapAllocator::*)(  const Standard_Size  ) >(&NCollection_WinHeapAllocator::AllocateOptimal),
             R"#(Allocate memory)#"  , py::arg("theSize")
          )
        .def("Free",
             (void (NCollection_WinHeapAllocator::*)( void *  ) ) static_cast<void (NCollection_WinHeapAllocator::*)( void *  ) >(&NCollection_WinHeapAllocator::Free),
             R"#(Release memory)#"  , py::arg("theAddress")
          )
    // methods using call by reference i.s.o. return
    // static methods
        .def_static("get_type_name_s",
                    ( const char * (*)() ) static_cast< const char * (*)() >(&NCollection_WinHeapAllocator::get_type_name),
                    R"#()#" 
          )
        .def_static("get_type_descriptor_s",
                    ( const handle<Standard_Type> & (*)() ) static_cast< const handle<Standard_Type> & (*)() >(&NCollection_WinHeapAllocator::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> & (NCollection_WinHeapAllocator::*)() const) static_cast< const handle<Standard_Type> & (NCollection_WinHeapAllocator::*)() const>(&NCollection_WinHeapAllocator::DynamicType),
             R"#()#"
             
         )
;

// functions
auto mNCollection_MapAlgo = static_cast<py::module>(m.attr("NCollection_MapAlgo"));
auto mNCollection_Primes = static_cast<py::module>(m.attr("NCollection_Primes"));

// ./opencascade/NCollection_AccAllocator.hxx
// ./opencascade/NCollection_AliasedArray.hxx
// ./opencascade/NCollection_AlignedAllocator.hxx
// ./opencascade/NCollection_Allocator.hxx
// ./opencascade/NCollection_Array1.hxx
// ./opencascade/NCollection_Array2.hxx
// ./opencascade/NCollection_BaseAllocator.hxx
// ./opencascade/NCollection_BaseList.hxx
// ./opencascade/NCollection_BaseMap.hxx
// ./opencascade/NCollection_BasePointerVector.hxx
// ./opencascade/NCollection_BaseSequence.hxx
// ./opencascade/NCollection_Buffer.hxx
// ./opencascade/NCollection_CellFilter.hxx
// ./opencascade/NCollection_DataMap.hxx
// ./opencascade/NCollection_DefaultHasher.hxx
// ./opencascade/NCollection_DefineAlloc.hxx
// ./opencascade/NCollection_DefineHArray1.hxx
// ./opencascade/NCollection_DefineHArray2.hxx
// ./opencascade/NCollection_DefineHSequence.hxx
// ./opencascade/NCollection_DefineHasher.hxx
// ./opencascade/NCollection_DoubleMap.hxx
// ./opencascade/NCollection_DynamicArray.hxx
// ./opencascade/NCollection_EBTree.hxx
// ./opencascade/NCollection_HArray1.hxx
// ./opencascade/NCollection_HArray2.hxx
// ./opencascade/NCollection_HSequence.hxx
// ./opencascade/NCollection_Handle.hxx
// ./opencascade/NCollection_HeapAllocator.hxx
// ./opencascade/NCollection_IncAllocator.hxx
// ./opencascade/NCollection_IndexedDataMap.hxx
// ./opencascade/NCollection_IndexedIterator.hxx
// ./opencascade/NCollection_IndexedMap.hxx
// ./opencascade/NCollection_Iterator.hxx
// ./opencascade/NCollection_Lerp.hxx
// ./opencascade/NCollection_List.hxx
// ./opencascade/NCollection_ListNode.hxx
// ./opencascade/NCollection_LocalArray.hxx
// ./opencascade/NCollection_Map.hxx
// ./opencascade/NCollection_MapAlgo.hxx
// ./opencascade/NCollection_Mat3.hxx
// ./opencascade/NCollection_Mat4.hxx
// ./opencascade/NCollection_OccAllocator.hxx
// ./opencascade/NCollection_Primes.hxx
    mNCollection_Primes.def("NextPrimeForMap",
          (int (*)(  const int  ))  static_cast<int (*)(  const int  )>(&NCollection_Primes::NextPrimeForMap),
          R"#(Returns the next prime number greater than or equal to theN.)#"  , py::arg("theN")
          );
// ./opencascade/NCollection_Sequence.hxx
// ./opencascade/NCollection_SparseArray.hxx
// ./opencascade/NCollection_SparseArrayBase.hxx
// ./opencascade/NCollection_StlIterator.hxx
// ./opencascade/NCollection_String.hxx
// ./opencascade/NCollection_TListIterator.hxx
// ./opencascade/NCollection_TListNode.hxx
// ./opencascade/NCollection_TypeDef.hxx
// ./opencascade/NCollection_UBTree.hxx
// ./opencascade/NCollection_UBTreeFiller.hxx
// ./opencascade/NCollection_UtfIterator.hxx
// ./opencascade/NCollection_UtfString.hxx
// ./opencascade/NCollection_Vec2.hxx
// ./opencascade/NCollection_Vec3.hxx
// ./opencascade/NCollection_Vec4.hxx
// ./opencascade/NCollection_Vector.hxx
// ./opencascade/NCollection_WinHeapAllocator.hxx

// Additional functions


// operators

// register typdefs
    register_template_NCollection_UtfIterator<Standard_Utf8Char>(m,"NCollection_Utf8Iter");
    register_template_NCollection_UtfIterator<Standard_Utf16Char>(m,"NCollection_Utf16Iter");
    register_template_NCollection_UtfIterator<Standard_Utf32Char>(m,"NCollection_Utf32Iter");
    register_template_NCollection_UtfIterator<Standard_WideChar>(m,"NCollection_UtfWideIter");
    register_template_NCollection_UtfString<Standard_Utf8Char>(m,"NCollection_Utf8String");
    register_template_NCollection_UtfString<Standard_Utf16Char>(m,"NCollection_Utf16String");
    register_template_NCollection_UtfString<Standard_Utf32Char>(m,"NCollection_Utf32String");
    register_template_NCollection_UtfString<Standard_WideChar>(m,"NCollection_UtfWideString");


// exceptions

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

};

// user-defined post-inclusion per module

// user-defined post
