from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers

def register_types(module):

    root_module = module.get_root()

    ## lte-helper.h: ns3::LteHelper [class]

    module.add_class('LteHelper')

    ## lte-helper.h: ns3::LteHelper::NetDeviceType [enumeration]

    module.add_enum('NetDeviceType', ['DEVICE_TYPE_USER_EQUIPMENT', 'DEVICE_TYPE_ENODEB'], outer_class=root_module['ns3::LteHelper'])

    ## lte-spectrum-value-helper.h: ns3::LteSpectrumValueHelper [class]

    module.add_class('LteSpectrumValueHelper')

    ## lte-mac-header.h: ns3::LteMacHeader [class]

    module.add_class('LteMacHeader', parent=root_module['ns3::Header'])

    ## packet-scheduler.h: ns3::PacketScheduler [class]

    module.add_class('PacketScheduler', parent=root_module['ns3::Object'])

    ## radio-bearer-instance.h: ns3::RadioBearerInstance [class]

    module.add_class('RadioBearerInstance', parent=root_module['ns3::Object'])

    ## radio-bearer-instance.h: ns3::RadioBearerInstance::BearerDirection [enumeration]

    module.add_enum('BearerDirection', ['DIRECTION_TYPE_UL', 'DIRECTION_TYPE_DL'], outer_class=root_module['ns3::RadioBearerInstance'])

    ## radio-bearer-instance.h: ns3::RadioBearerInstance::BearerType [enumeration]

    module.add_enum('BearerType', ['BEARER_TYPE_SRB1', 'BEARER_TYPE_SRB2', 'BEARER_TYPE_DRB'], outer_class=root_module['ns3::RadioBearerInstance'])

    ## rlc-entity.h: ns3::RlcEntity [class]

    module.add_class('RlcEntity', parent=root_module['ns3::Object'])

    ## rrc-entity.h: ns3::RrcEntity [class]

    module.add_class('RrcEntity', parent=root_module['ns3::Object'])

    ## simple-packet-scheduler.h: ns3::SimplePacketScheduler [class]

    module.add_class('SimplePacketScheduler', parent=root_module['ns3::PacketScheduler'])

    ## simple-ref-count.h: ns3::SimpleRefCount<ns3::IdealControlMessage, ns3::empty, ns3::DefaultDeleter<ns3::IdealControlMessage> > [class]

    module.add_class('SimpleRefCount', automatic_type_narrowing=True, template_parameters=['ns3::IdealControlMessage', 'ns3::empty', 'ns3::DefaultDeleter<ns3::IdealControlMessage>'], parent=root_module['ns3::empty'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

    ## ue-manager.h: ns3::UeManager [class]

    module.add_class('UeManager', parent=root_module['ns3::Object'])

    ## ue-record.h: ns3::UeRecord [class]

    module.add_class('UeRecord', parent=root_module['ns3::Object'])

    ## ue-record.h: ns3::UeRecord::CqiFeedback [struct]

    module.add_class('CqiFeedback', outer_class=root_module['ns3::UeRecord'])

    ## amc-module.h: ns3::AmcModule [class]

    module.add_class('AmcModule', parent=root_module['ns3::Object'])

    ## bearer-qos-parameters.h: ns3::BearerQosParameters [class]

    module.add_class('BearerQosParameters', parent=root_module['ns3::Object'])

    ## bearer-qos-parameters.h: ns3::BearerQosParameters::BearerQosType [enumeration]

    module.add_enum('BearerQosType', ['BEARER_TYPE_GBR', 'BEARER_TYPE_NGBR'], outer_class=root_module['ns3::BearerQosParameters'])

    ## channel-realization.h: ns3::ChannelRealization [class]

    module.add_class('ChannelRealization', parent=root_module['ns3::Object'])

    ## discrete-time-loss-model.h: ns3::DiscreteTimeLossModel [class]

    module.add_class('DiscreteTimeLossModel', parent=root_module['ns3::Object'])

    ## ideal-control-messages.h: ns3::IdealControlMessage [class]

    module.add_class('IdealControlMessage', parent=root_module['ns3::SimpleRefCount< ns3::IdealControlMessage, ns3::empty, ns3::DefaultDeleter<ns3::IdealControlMessage> >'])

    ## ideal-control-messages.h: ns3::IdealControlMessage::MessageType [enumeration]

    module.add_enum('MessageType', ['CQI_FEEDBACKS', 'ALLOCATION_MAP'], outer_class=root_module['ns3::IdealControlMessage'])

    ## jakes-fading-loss-model.h: ns3::JakesFadingLossModel [class]

    module.add_class('JakesFadingLossModel', parent=root_module['ns3::DiscreteTimeLossModel'])

    ## lte-mac-queue.h: ns3::LteMacQueue [class]

    module.add_class('LteMacQueue', parent=root_module['ns3::Object'])

    ## lte-phy.h: ns3::LtePhy [class]

    module.add_class('LtePhy', parent=root_module['ns3::Object'])

    ## lte-propagation-loss-model.h: ns3::LtePropagationLossModel [class]

    module.add_class('LtePropagationLossModel', parent=root_module['ns3::SpectrumPropagationLossModel'])

    ## lte-spectrum-phy.h: ns3::LteSpectrumPhy [class]

    module.add_class('LteSpectrumPhy', parent=root_module['ns3::SpectrumPhy'])

    ## lte-spectrum-phy.h: ns3::LteSpectrumPhy::State [enumeration]

    module.add_enum('State', ['IDLE', 'TX', 'RX'], outer_class=root_module['ns3::LteSpectrumPhy'])

    ## mac-entity.h: ns3::MacEntity [class]

    module.add_class('MacEntity', parent=root_module['ns3::Object'])

    ## path-loss-model.h: ns3::PathLossModel [class]

    module.add_class('PathLossModel', parent=root_module['ns3::DiscreteTimeLossModel'])

    ## ideal-control-messages.h: ns3::PdcchMapIdealControlMessage [class]

    module.add_class('PdcchMapIdealControlMessage', parent=root_module['ns3::IdealControlMessage'])

    ## ideal-control-messages.h: ns3::PdcchMapIdealControlMessage::Direction [enumeration]

    module.add_enum('Direction', ['DOWNLINK', 'UPLINK'], outer_class=root_module['ns3::PdcchMapIdealControlMessage'])

    ## ideal-control-messages.h: ns3::PdcchMapIdealControlMessage::IdealPdcchRecord [struct]

    module.add_class('IdealPdcchRecord', outer_class=root_module['ns3::PdcchMapIdealControlMessage'])

    ## penetration-loss-model.h: ns3::PenetrationLossModel [class]

    module.add_class('PenetrationLossModel', parent=root_module['ns3::DiscreteTimeLossModel'])

    ## shadowing-loss-model.h: ns3::ShadowingLossModel [class]

    module.add_class('ShadowingLossModel', parent=root_module['ns3::DiscreteTimeLossModel'])

    ## ue-phy.h: ns3::UeLtePhy [class]

    module.add_class('UeLtePhy', parent=root_module['ns3::LtePhy'])

    ## ue-lte-spectrum-phy.h: ns3::UeLteSpectrumPhy [class]

    module.add_class('UeLteSpectrumPhy', parent=root_module['ns3::LteSpectrumPhy'])

    ## ue-mac-entity.h: ns3::UeMacEntity [class]

    module.add_class('UeMacEntity', parent=root_module['ns3::MacEntity'])

    ## ideal-control-messages.h: ns3::CqiIdealControlMessage [class]

    module.add_class('CqiIdealControlMessage', parent=root_module['ns3::IdealControlMessage'])

    ## ideal-control-messages.h: ns3::CqiIdealControlMessage::CqiFeedback [struct]

    module.add_class('CqiFeedback', outer_class=root_module['ns3::CqiIdealControlMessage'])

    ## enb-phy.h: ns3::EnbLtePhy [class]

    module.add_class('EnbLtePhy', parent=root_module['ns3::LtePhy'])

    ## enb-lte-spectrum-phy.h: ns3::EnbLteSpectrumPhy [class]

    module.add_class('EnbLteSpectrumPhy', parent=root_module['ns3::LteSpectrumPhy'])

    ## enb-mac-entity.h: ns3::EnbMacEntity [class]

    module.add_class('EnbMacEntity', parent=root_module['ns3::MacEntity'])

    ## lte-net-device.h: ns3::LteNetDevice [class]

    module.add_class('LteNetDevice', parent=root_module['ns3::NetDevice'])

    ## ue-net-device.h: ns3::UeNetDevice [class]

    module.add_class('UeNetDevice', parent=root_module['ns3::LteNetDevice'])

    ## enb-net-device.h: ns3::EnbNetDevice [class]

    module.add_class('EnbNetDevice', parent=root_module['ns3::LteNetDevice'])

    module.add_container('std::vector< ns3::UeRecord::CqiFeedback >', 'ns3::UeRecord::CqiFeedback', container_type='vector')

    module.add_container('std::deque< ns3::LteMacQueue::QueueElement >', 'ns3::LteMacQueue::QueueElement', container_type='dequeue')

    module.add_container('std::list< ns3::PdcchMapIdealControlMessage::IdealPdcchRecord >', 'ns3::PdcchMapIdealControlMessage::IdealPdcchRecord', container_type='list')

    module.add_container('std::list< ns3::CqiIdealControlMessage::CqiFeedback >', 'ns3::CqiIdealControlMessage::CqiFeedback', container_type='list')

    ## Register a nested module for the namespace Config

    nested_module = module.add_cpp_namespace('Config')

    register_types_ns3_Config(nested_module)

    ## Register a nested module for the namespace FatalImpl

    nested_module = module.add_cpp_namespace('FatalImpl')

    register_types_ns3_FatalImpl(nested_module)

    ## Register a nested module for the namespace addressUtils

    nested_module = module.add_cpp_namespace('addressUtils')

    register_types_ns3_addressUtils(nested_module)

    ## Register a nested module for the namespace aodv

    nested_module = module.add_cpp_namespace('aodv')

    register_types_ns3_aodv(nested_module)

    ## Register a nested module for the namespace dot11s

    nested_module = module.add_cpp_namespace('dot11s')

    register_types_ns3_dot11s(nested_module)

    ## Register a nested module for the namespace dsdv

    nested_module = module.add_cpp_namespace('dsdv')

    register_types_ns3_dsdv(nested_module)

    ## Register a nested module for the namespace flame

    nested_module = module.add_cpp_namespace('flame')

    register_types_ns3_flame(nested_module)

    ## Register a nested module for the namespace internal

    nested_module = module.add_cpp_namespace('internal')

    register_types_ns3_internal(nested_module)

    ## Register a nested module for the namespace olsr

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_FatalImpl(module):

    root_module = module.get_root()

def register_types_ns3_addressUtils(module):

    root_module = module.get_root()

def register_types_ns3_aodv(module):

    root_module = module.get_root()

def register_types_ns3_dot11s(module):

    root_module = module.get_root()

def register_types_ns3_dsdv(module):

    root_module = module.get_root()

def register_types_ns3_flame(module):

    root_module = module.get_root()

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

    register_Ns3LteHelper_methods(root_module, root_module['ns3::LteHelper'])

    register_Ns3LteSpectrumValueHelper_methods(root_module, root_module['ns3::LteSpectrumValueHelper'])

    register_Ns3LteMacHeader_methods(root_module, root_module['ns3::LteMacHeader'])

    register_Ns3PacketScheduler_methods(root_module, root_module['ns3::PacketScheduler'])

    register_Ns3RadioBearerInstance_methods(root_module, root_module['ns3::RadioBearerInstance'])

    register_Ns3RlcEntity_methods(root_module, root_module['ns3::RlcEntity'])

    register_Ns3RrcEntity_methods(root_module, root_module['ns3::RrcEntity'])

    register_Ns3SimplePacketScheduler_methods(root_module, root_module['ns3::SimplePacketScheduler'])

    register_Ns3UeManager_methods(root_module, root_module['ns3::UeManager'])

    register_Ns3UeRecord_methods(root_module, root_module['ns3::UeRecord'])

    register_Ns3UeRecordCqiFeedback_methods(root_module, root_module['ns3::UeRecord::CqiFeedback'])

    register_Ns3AmcModule_methods(root_module, root_module['ns3::AmcModule'])

    register_Ns3BearerQosParameters_methods(root_module, root_module['ns3::BearerQosParameters'])

    register_Ns3ChannelRealization_methods(root_module, root_module['ns3::ChannelRealization'])

    register_Ns3DiscreteTimeLossModel_methods(root_module, root_module['ns3::DiscreteTimeLossModel'])

    register_Ns3IdealControlMessage_methods(root_module, root_module['ns3::IdealControlMessage'])

    register_Ns3JakesFadingLossModel_methods(root_module, root_module['ns3::JakesFadingLossModel'])

    register_Ns3LteMacQueue_methods(root_module, root_module['ns3::LteMacQueue'])

    register_Ns3LtePhy_methods(root_module, root_module['ns3::LtePhy'])

    register_Ns3LtePropagationLossModel_methods(root_module, root_module['ns3::LtePropagationLossModel'])

    register_Ns3LteSpectrumPhy_methods(root_module, root_module['ns3::LteSpectrumPhy'])

    register_Ns3MacEntity_methods(root_module, root_module['ns3::MacEntity'])

    register_Ns3PathLossModel_methods(root_module, root_module['ns3::PathLossModel'])

    register_Ns3PdcchMapIdealControlMessage_methods(root_module, root_module['ns3::PdcchMapIdealControlMessage'])

    register_Ns3PdcchMapIdealControlMessageIdealPdcchRecord_methods(root_module, root_module['ns3::PdcchMapIdealControlMessage::IdealPdcchRecord'])

    register_Ns3PenetrationLossModel_methods(root_module, root_module['ns3::PenetrationLossModel'])

    register_Ns3ShadowingLossModel_methods(root_module, root_module['ns3::ShadowingLossModel'])

    register_Ns3UeLtePhy_methods(root_module, root_module['ns3::UeLtePhy'])

    register_Ns3UeLteSpectrumPhy_methods(root_module, root_module['ns3::UeLteSpectrumPhy'])

    register_Ns3UeMacEntity_methods(root_module, root_module['ns3::UeMacEntity'])

    register_Ns3CqiIdealControlMessage_methods(root_module, root_module['ns3::CqiIdealControlMessage'])

    register_Ns3CqiIdealControlMessageCqiFeedback_methods(root_module, root_module['ns3::CqiIdealControlMessage::CqiFeedback'])

    register_Ns3EnbLtePhy_methods(root_module, root_module['ns3::EnbLtePhy'])

    register_Ns3EnbLteSpectrumPhy_methods(root_module, root_module['ns3::EnbLteSpectrumPhy'])

    register_Ns3EnbMacEntity_methods(root_module, root_module['ns3::EnbMacEntity'])

    register_Ns3LteNetDevice_methods(root_module, root_module['ns3::LteNetDevice'])

    register_Ns3UeNetDevice_methods(root_module, root_module['ns3::UeNetDevice'])

    register_Ns3EnbNetDevice_methods(root_module, root_module['ns3::EnbNetDevice'])

    return

def register_Ns3LteHelper_methods(root_module, cls):

    ## lte-helper.h: ns3::LteHelper::LteHelper(ns3::LteHelper const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::LteHelper const &', 'arg0')])

    ## lte-helper.h: ns3::LteHelper::LteHelper() [constructor]

    cls.add_constructor([])

    ## lte-helper.h: void ns3::LteHelper::AddDownlinkChannelRealization(ns3::Ptr<ns3::MobilityModel> enbMobility, ns3::Ptr<ns3::MobilityModel> ueMobility, ns3::Ptr<ns3::LtePhy> phy) [member function]

    cls.add_method('AddDownlinkChannelRealization', 

                   'void', 

                   [param('ns3::Ptr< ns3::MobilityModel >', 'enbMobility'), param('ns3::Ptr< ns3::MobilityModel >', 'ueMobility'), param('ns3::Ptr< ns3::LtePhy >', 'phy')])

    ## lte-helper.h: void ns3::LteHelper::AddMobility(ns3::Ptr<ns3::LtePhy> phy, ns3::Ptr<ns3::MobilityModel> m) [member function]

    cls.add_method('AddMobility', 

                   'void', 

                   [param('ns3::Ptr< ns3::LtePhy >', 'phy'), param('ns3::Ptr< ns3::MobilityModel >', 'm')])

    ## lte-helper.h: void ns3::LteHelper::EnableLogComponents() [member function]

    cls.add_method('EnableLogComponents', 

                   'void', 

                   [])

    ## lte-helper.h: ns3::NetDeviceContainer ns3::LteHelper::Install(ns3::NodeContainer c, ns3::LteHelper::NetDeviceType type) [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::NodeContainer', 'c'), param('ns3::LteHelper::NetDeviceType', 'type')])

    ## lte-helper.h: void ns3::LteHelper::RegisterUeToTheEnb(ns3::Ptr<ns3::UeNetDevice> ue, ns3::Ptr<ns3::EnbNetDevice> enb) [member function]

    cls.add_method('RegisterUeToTheEnb', 

                   'void', 

                   [param('ns3::Ptr< ns3::UeNetDevice >', 'ue'), param('ns3::Ptr< ns3::EnbNetDevice >', 'enb')])

    return

def register_Ns3LteSpectrumValueHelper_methods(root_module, cls):

    ## lte-spectrum-value-helper.h: ns3::LteSpectrumValueHelper::LteSpectrumValueHelper() [constructor]

    cls.add_constructor([])

    ## lte-spectrum-value-helper.h: ns3::LteSpectrumValueHelper::LteSpectrumValueHelper(ns3::LteSpectrumValueHelper const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::LteSpectrumValueHelper const &', 'arg0')])

    ## lte-spectrum-value-helper.h: ns3::Ptr<ns3::SpectrumValue> ns3::LteSpectrumValueHelper::CreateDownlinkNoisePowerSpectralDensity() [member function]

    cls.add_method('CreateDownlinkNoisePowerSpectralDensity', 

                   'ns3::Ptr< ns3::SpectrumValue >', 

                   [])

    ## lte-spectrum-value-helper.h: ns3::Ptr<ns3::SpectrumValue> ns3::LteSpectrumValueHelper::CreateDownlinkTxPowerSpectralDensity(double powerTx, std::vector<int, std::allocator<int> > channels) [member function]

    cls.add_method('CreateDownlinkTxPowerSpectralDensity', 

                   'ns3::Ptr< ns3::SpectrumValue >', 

                   [param('double', 'powerTx'), param('std::vector< int >', 'channels')])

    ## lte-spectrum-value-helper.h: ns3::Ptr<ns3::SpectrumValue> ns3::LteSpectrumValueHelper::CreateUplinkNoisePowerSpectralDensity() [member function]

    cls.add_method('CreateUplinkNoisePowerSpectralDensity', 

                   'ns3::Ptr< ns3::SpectrumValue >', 

                   [])

    ## lte-spectrum-value-helper.h: ns3::Ptr<ns3::SpectrumValue> ns3::LteSpectrumValueHelper::CreateUplinkTxPowerSpectralDensity(double powerTx, std::vector<int, std::allocator<int> > channels) [member function]

    cls.add_method('CreateUplinkTxPowerSpectralDensity', 

                   'ns3::Ptr< ns3::SpectrumValue >', 

                   [param('double', 'powerTx'), param('std::vector< int >', 'channels')])

    return

def register_Ns3LteMacHeader_methods(root_module, cls):

    ## lte-mac-header.h: ns3::LteMacHeader::LteMacHeader() [constructor]

    cls.add_constructor([])

    ## lte-mac-header.h: ns3::LteMacHeader::LteMacHeader(ns3::LteMacHeader const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::LteMacHeader const &', 'arg0')])

    ## lte-mac-header.h: uint32_t ns3::LteMacHeader::Deserialize(ns3::Buffer::Iterator start) [member function]

    cls.add_method('Deserialize', 

                   'uint32_t', 

                   [param('ns3::Buffer::Iterator', 'start')], 

                   is_virtual=True)

    ## lte-mac-header.h: ns3::Mac48Address ns3::LteMacHeader::GetDestination() const [member function]

    cls.add_method('GetDestination', 

                   'ns3::Mac48Address', 

                   [], 

                   is_const=True)

    ## lte-mac-header.h: ns3::TypeId ns3::LteMacHeader::GetInstanceTypeId() const [member function]

    cls.add_method('GetInstanceTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_const=True, is_virtual=True)

    ## lte-mac-header.h: uint32_t ns3::LteMacHeader::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True, is_virtual=True)

    ## lte-mac-header.h: ns3::Mac48Address ns3::LteMacHeader::GetSource() const [member function]

    cls.add_method('GetSource', 

                   'ns3::Mac48Address', 

                   [], 

                   is_const=True)

    ## lte-mac-header.h: static ns3::TypeId ns3::LteMacHeader::GetTypeId() [member function]

    cls.add_method('GetTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_static=True)

    ## lte-mac-header.h: void ns3::LteMacHeader::Print(std::ostream & os) const [member function]

    cls.add_method('Print', 

                   'void', 

                   [param('std::ostream &', 'os')], 

                   is_const=True, is_virtual=True)

    ## lte-mac-header.h: void ns3::LteMacHeader::Serialize(ns3::Buffer::Iterator start) const [member function]

    cls.add_method('Serialize', 

                   'void', 

                   [param('ns3::Buffer::Iterator', 'start')], 

                   is_const=True, is_virtual=True)

    ## lte-mac-header.h: void ns3::LteMacHeader::SetDestination(ns3::Mac48Address destination) [member function]

    cls.add_method('SetDestination', 

                   'void', 

                   [param('ns3::Mac48Address', 'destination')])

    ## lte-mac-header.h: void ns3::LteMacHeader::SetSource(ns3::Mac48Address source) [member function]

    cls.add_method('SetSource', 

                   'void', 

                   [param('ns3::Mac48Address', 'source')])

    return

def register_Ns3PacketScheduler_methods(root_module, cls):

    ## packet-scheduler.h: ns3::PacketScheduler::PacketScheduler(ns3::PacketScheduler const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::PacketScheduler const &', 'arg0')])

    ## packet-scheduler.h: ns3::PacketScheduler::PacketScheduler() [constructor]

    cls.add_constructor([])

    ## packet-scheduler.h: ns3::PacketScheduler::PacketScheduler(ns3::Ptr<ns3::EnbNetDevice> enb) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::EnbNetDevice >', 'enb')])

    ## packet-scheduler.h: void ns3::PacketScheduler::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   is_virtual=True)

    ## packet-scheduler.h: void ns3::PacketScheduler::DoRunPacketScheduler() [member function]

    cls.add_method('DoRunPacketScheduler', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## packet-scheduler.h: ns3::Ptr<ns3::EnbNetDevice> ns3::PacketScheduler::GetDevice() [member function]

    cls.add_method('GetDevice', 

                   'ns3::Ptr< ns3::EnbNetDevice >', 

                   [])

    ## packet-scheduler.h: ns3::Ptr<ns3::MacEntity> ns3::PacketScheduler::GetMacEntity() [member function]

    cls.add_method('GetMacEntity', 

                   'ns3::Ptr< ns3::MacEntity >', 

                   [])

    ## packet-scheduler.h: static ns3::TypeId ns3::PacketScheduler::GetTypeId() [member function]

    cls.add_method('GetTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_static=True)

    ## packet-scheduler.h: void ns3::PacketScheduler::RunPacketScheduler() [member function]

    cls.add_method('RunPacketScheduler', 

                   'void', 

                   [])

    ## packet-scheduler.h: void ns3::PacketScheduler::SetDevice(ns3::Ptr<ns3::EnbNetDevice> enb) [member function]

    cls.add_method('SetDevice', 

                   'void', 

                   [param('ns3::Ptr< ns3::EnbNetDevice >', 'enb')])

    ## packet-scheduler.h: void ns3::PacketScheduler::SetMacEntity(ns3::Ptr<ns3::MacEntity> mac) [member function]

    cls.add_method('SetMacEntity', 

                   'void', 

                   [param('ns3::Ptr< ns3::MacEntity >', 'mac')])

    return

def register_Ns3RadioBearerInstance_methods(root_module, cls):

    ## radio-bearer-instance.h: ns3::RadioBearerInstance::RadioBearerInstance(ns3::RadioBearerInstance const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::RadioBearerInstance const &', 'arg0')])

    ## radio-bearer-instance.h: ns3::RadioBearerInstance::RadioBearerInstance() [constructor]

    cls.add_constructor([])

    ## radio-bearer-instance.h: ns3::Ptr<ns3::Packet> ns3::RadioBearerInstance::Dequeue() [member function]

    cls.add_method('Dequeue', 

                   'ns3::Ptr< ns3::Packet >', 

                   [])

    ## radio-bearer-instance.h: ns3::Ptr<ns3::Packet> ns3::RadioBearerInstance::Dequeue(uint32_t availableByte) [member function]

    cls.add_method('Dequeue', 

                   'ns3::Ptr< ns3::Packet >', 

                   [param('uint32_t', 'availableByte')])

    ## radio-bearer-instance.h: bool ns3::RadioBearerInstance::Enqueue(ns3::Ptr<ns3::Packet> packet) [member function]

    cls.add_method('Enqueue', 

                   'bool', 

                   [param('ns3::Ptr< ns3::Packet >', 'packet')])

    ## radio-bearer-instance.h: ns3::RadioBearerInstance::BearerDirection ns3::RadioBearerInstance::GetBearerDirection() const [member function]

    cls.add_method('GetBearerDirection', 

                   'ns3::RadioBearerInstance::BearerDirection', 

                   [], 

                   is_const=True)

    ## radio-bearer-instance.h: ns3::RadioBearerInstance::BearerType ns3::RadioBearerInstance::GetBearerType() const [member function]

    cls.add_method('GetBearerType', 

                   'ns3::RadioBearerInstance::BearerType', 

                   [], 

                   is_const=True)

    ## radio-bearer-instance.h: ns3::IpcsClassifierRecord * ns3::RadioBearerInstance::GetIpcsClassifierRecord() [member function]

    cls.add_method('GetIpcsClassifierRecord', 

                   'ns3::IpcsClassifierRecord *', 

                   [])

    ## radio-bearer-instance.h: ns3::Ptr<ns3::BearerQosParameters> ns3::RadioBearerInstance::GetQosParameters() [member function]

    cls.add_method('GetQosParameters', 

                   'ns3::Ptr< ns3::BearerQosParameters >', 

                   [])

    ## radio-bearer-instance.h: ns3::Ptr<ns3::LteMacQueue> ns3::RadioBearerInstance::GetQueue() const [member function]

    cls.add_method('GetQueue', 

                   'ns3::Ptr< ns3::LteMacQueue >', 

                   [], 

                   is_const=True)

    ## radio-bearer-instance.h: ns3::Ptr<ns3::RlcEntity> ns3::RadioBearerInstance::GetRlcEntity() [member function]

    cls.add_method('GetRlcEntity', 

                   'ns3::Ptr< ns3::RlcEntity >', 

                   [])

    ## radio-bearer-instance.h: static ns3::TypeId ns3::RadioBearerInstance::GetTypeId() [member function]

    cls.add_method('GetTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_static=True)

    ## radio-bearer-instance.h: bool ns3::RadioBearerInstance::HasPackets() const [member function]

    cls.add_method('HasPackets', 

                   'bool', 

                   [], 

                   is_const=True)

    ## radio-bearer-instance.h: void ns3::RadioBearerInstance::SetBearerDirection(ns3::RadioBearerInstance::BearerDirection direction) [member function]

    cls.add_method('SetBearerDirection', 

                   'void', 

                   [param('ns3::RadioBearerInstance::BearerDirection', 'direction')])

    ## radio-bearer-instance.h: void ns3::RadioBearerInstance::SetBearerType(ns3::RadioBearerInstance::BearerType type) [member function]

    cls.add_method('SetBearerType', 

                   'void', 

                   [param('ns3::RadioBearerInstance::BearerType', 'type')])

    ## radio-bearer-instance.h: void ns3::RadioBearerInstance::SetIpcsClassifierRecord(ns3::IpcsClassifierRecord * c) [member function]

    cls.add_method('SetIpcsClassifierRecord', 

                   'void', 

                   [param('ns3::IpcsClassifierRecord *', 'c')])

    ## radio-bearer-instance.h: void ns3::RadioBearerInstance::SetQosParameters(ns3::Ptr<ns3::BearerQosParameters> qosParameters) [member function]

    cls.add_method('SetQosParameters', 

                   'void', 

                   [param('ns3::Ptr< ns3::BearerQosParameters >', 'qosParameters')])

    ## radio-bearer-instance.h: void ns3::RadioBearerInstance::SetRlcEntity(ns3::Ptr<ns3::RlcEntity> rlc) [member function]

    cls.add_method('SetRlcEntity', 

                   'void', 

                   [param('ns3::Ptr< ns3::RlcEntity >', 'rlc')])

    ## radio-bearer-instance.h: void ns3::RadioBearerInstance::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   visibility='private', is_virtual=True)

    return

def register_Ns3RlcEntity_methods(root_module, cls):

    ## rlc-entity.h: ns3::RlcEntity::RlcEntity(ns3::RlcEntity const & arg0) [copy constructor]

    cls.add_constructor([param('ns3::RlcEntity const &', 'arg0')])

    ## rlc-entity.h: ns3::RlcEntity::RlcEntity() [constructor]

    cls.add_constructor([])

    ## rlc-entity.h: ns3::RlcEntity::RlcEntity(ns3::Ptr<ns3::LteNetDevice> d) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::LteNetDevice >', 'd')])

    ## rlc-entity.h: ns3::Ptr<ns3::Packet> ns3::RlcEntity::Dequeue() [member function]

    cls.add_method('Dequeue', 

                   'ns3::Ptr< ns3::Packet >', 

                   [])

    ## rlc-entity.h: void ns3::RlcEntity::DoDispose() [member function]

    cls.add_method('DoDispose', 

                   'void', 

                   [], 

                   is_virtual=True)

    ## rlc-entity.h: ns3::Ptr<ns3::LteNetDevice> ns3::RlcEntity::GetDevice() [member function]

    cls.add_method('GetDevice', 

                   'ns3::Ptr< ns3::LteNetDevice >', 

                   [])

    ## rlc-entity.h: ns3::Ptr<ns3::RadioBearerInstance> ns3::RlcEntity::GetRadioBearer() [member function]

    cls.add_method('GetRadioBearer', 

                   'ns3::Ptr< ns3::RadioBearerInstance >', 

                   [])

    ## rlc-entity.h: static ns3::TypeId ns3::RlcEntity::GetTypeId() [member function]

    cls.add_method('GetTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_static=True)

    ## rlc-entity.h: void ns3::RlcEntity::SetDevice(ns3::Ptr<ns3::LteNetDevice> d) [member function]

    cls.add_method('SetDevice', 

                   'void', 

                   [param('ns3::Ptr< ns3::LteNetDevice >', 'd')])

    ## rlc-entity.h: void ns3::RlcEntity::SetRadioBearer(ns3::Ptr<ns3::RadioBearerInstance> b) [member function]

    cls.add_method('SetRadioBearer', 

                   'void', 

                   [param('ns3::Ptr< ns3::RadioBearerInstance >', 'b')])

    return