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

def register_types(module):

    root_module = module.get_root()

    ## adhoc-aloha-noack-ideal-phy-helper.h: ns3::AdhocAlohaNoackIdealPhyHelper [class]

    module.add_class('AdhocAlohaNoackIdealPhyHelper')

    ## spectrum-model.h: ns3::BandInfo [struct]

    module.add_class('BandInfo')

    ## microwave-oven-spectrum-value-helper.h: ns3::MicrowaveOvenSpectrumValueHelper [class]

    module.add_class('MicrowaveOvenSpectrumValueHelper')

    ## multi-model-spectrum-channel.h: ns3::RxSpectrumModelInfo [class]

    module.add_class('RxSpectrumModelInfo')

    ## spectrum-analyzer-helper.h: ns3::SpectrumAnalyzerHelper [class]

    module.add_class('SpectrumAnalyzerHelper')

    ## spectrum-helper.h: ns3::SpectrumChannelHelper [class]

    module.add_class('SpectrumChannelHelper')

    ## spectrum-helper.h: ns3::SpectrumPhyHelper [class]

    module.add_class('SpectrumPhyHelper')

    ## spectrum-type.h: ns3::SpectrumType [class]

    module.add_class('SpectrumType')

    ## spectrum-type.h: ns3::SpectrumTypeFactory [class]

    module.add_class('SpectrumTypeFactory')

    ## multi-model-spectrum-channel.h: ns3::TxSpectrumModelInfo [class]

    module.add_class('TxSpectrumModelInfo')

    ## waveform-generator-helper.h: ns3::WaveformGeneratorHelper [class]

    module.add_class('WaveformGeneratorHelper')

    ## wifi-spectrum-value-helper.h: ns3::WifiSpectrumValue5MhzFactory [class]

    module.add_class('WifiSpectrumValue5MhzFactory', allow_subclassing=True)

    ## wifi-spectrum-value-helper.h: ns3::WifiSpectrumValueHelper [class]

    module.add_class('WifiSpectrumValueHelper', allow_subclassing=True)

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

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

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

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

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

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

    ## spectrum-converter.h: ns3::SpectrumConverter [class]

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

    ## spectrum-error-model.h: ns3::SpectrumErrorModel [class]

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

    ## spectrum-interference.h: ns3::SpectrumInterference [class]

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

    ## spectrum-model.h: ns3::SpectrumModel [class]

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

    ## spectrum-phy.h: ns3::SpectrumPhy [class]

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

    ## spectrum-propagation-loss-model.h: ns3::SpectrumPropagationLossModel [class]

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

    ## spectrum-value.h: ns3::SpectrumValue [class]

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

    ## waveform-generator.h: ns3::WaveformGenerator [class]

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

    ## aloha-noack-mac-header.h: ns3::AlohaNoackMacHeader [class]

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

    ## friis-spectrum-propagation-loss.h: ns3::FriisSpectrumPropagationLossModel [class]

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

    ## half-duplex-ideal-phy.h: ns3::HalfDuplexIdealPhy [class]

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

    ## half-duplex-ideal-phy.h: ns3::HalfDuplexIdealPhy::State [enumeration]

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

    ## non-communicating-net-device.h: ns3::NonCommunicatingNetDevice [class]

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

    ## spectrum-error-model.h: ns3::ShannonSpectrumErrorModel [class]

    module.add_class('ShannonSpectrumErrorModel', parent=root_module['ns3::SpectrumErrorModel'])

    ## spectrum-analyzer.h: ns3::SpectrumAnalyzer [class]

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

    ## spectrum-channel.h: ns3::SpectrumChannel [class]

    module.add_class('SpectrumChannel', parent=root_module['ns3::Channel'])

    ## aloha-noack-net-device.h: ns3::AlohaNoackNetDevice [class]

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

    ## aloha-noack-net-device.h: ns3::AlohaNoackNetDevice::State [enumeration]

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

    ## multi-model-spectrum-channel.h: ns3::MultiModelSpectrumChannel [class]

    module.add_class('MultiModelSpectrumChannel', parent=root_module['ns3::SpectrumChannel'])

    ## single-model-spectrum-channel.h: ns3::SingleModelSpectrumChannel [class]

    module.add_class('SingleModelSpectrumChannel', parent=root_module['ns3::SpectrumChannel'])

    module.add_container('ns3::SpectrumConverterMap_t', ('unsigned int', 'ns3::SpectrumConverter'), container_type='map')

    module.add_container('ns3::Bands', 'ns3::BandInfo', container_type='vector')

    typehandlers.add_type_alias('std::vector< double, std::allocator< double > >', 'ns3::Values')

    typehandlers.add_type_alias('std::vector< double, std::allocator< double > >*', 'ns3::Values*')

    typehandlers.add_type_alias('std::vector< double, std::allocator< double > >&', 'ns3::Values&')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::SpectrumConverter, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::SpectrumConverter > > >', 'ns3::SpectrumConverterMap_t')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::SpectrumConverter, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::SpectrumConverter > > >*', 'ns3::SpectrumConverterMap_t*')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::SpectrumConverter, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::SpectrumConverter > > >&', 'ns3::SpectrumConverterMap_t&')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::TxSpectrumModelInfo, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::TxSpectrumModelInfo > > >', 'ns3::TxSpectrumModelInfoMap_t')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::TxSpectrumModelInfo, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::TxSpectrumModelInfo > > >*', 'ns3::TxSpectrumModelInfoMap_t*')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::TxSpectrumModelInfo, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::TxSpectrumModelInfo > > >&', 'ns3::TxSpectrumModelInfoMap_t&')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::RxSpectrumModelInfo, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::RxSpectrumModelInfo > > >', 'ns3::RxSpectrumModelInfoMap_t')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::RxSpectrumModelInfo, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::RxSpectrumModelInfo > > >*', 'ns3::RxSpectrumModelInfoMap_t*')

    typehandlers.add_type_alias('std::map< unsigned int, ns3::RxSpectrumModelInfo, std::less< unsigned int >, std::allocator< std::pair< unsigned int const, ns3::RxSpectrumModelInfo > > >&', 'ns3::RxSpectrumModelInfoMap_t&')

    typehandlers.add_type_alias('uint32_t', 'ns3::SpectrumModelUid_t')

    typehandlers.add_type_alias('uint32_t*', 'ns3::SpectrumModelUid_t*')

    typehandlers.add_type_alias('uint32_t&', 'ns3::SpectrumModelUid_t&')

    typehandlers.add_type_alias('std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >', 'ns3::Bands')

    typehandlers.add_type_alias('std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >*', 'ns3::Bands*')

    typehandlers.add_type_alias('std::vector< ns3::BandInfo, std::allocator< ns3::BandInfo > >&', 'ns3::Bands&')

    ## 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_Ns3AdhocAlohaNoackIdealPhyHelper_methods(root_module, root_module['ns3::AdhocAlohaNoackIdealPhyHelper'])

    register_Ns3BandInfo_methods(root_module, root_module['ns3::BandInfo'])

    register_Ns3MicrowaveOvenSpectrumValueHelper_methods(root_module, root_module['ns3::MicrowaveOvenSpectrumValueHelper'])

    register_Ns3RxSpectrumModelInfo_methods(root_module, root_module['ns3::RxSpectrumModelInfo'])

    register_Ns3SpectrumAnalyzerHelper_methods(root_module, root_module['ns3::SpectrumAnalyzerHelper'])

    register_Ns3SpectrumChannelHelper_methods(root_module, root_module['ns3::SpectrumChannelHelper'])

    register_Ns3SpectrumPhyHelper_methods(root_module, root_module['ns3::SpectrumPhyHelper'])

    register_Ns3SpectrumType_methods(root_module, root_module['ns3::SpectrumType'])

    register_Ns3SpectrumTypeFactory_methods(root_module, root_module['ns3::SpectrumTypeFactory'])

    register_Ns3TxSpectrumModelInfo_methods(root_module, root_module['ns3::TxSpectrumModelInfo'])

    register_Ns3WaveformGeneratorHelper_methods(root_module, root_module['ns3::WaveformGeneratorHelper'])

    register_Ns3WifiSpectrumValue5MhzFactory_methods(root_module, root_module['ns3::WifiSpectrumValue5MhzFactory'])

    register_Ns3WifiSpectrumValueHelper_methods(root_module, root_module['ns3::WifiSpectrumValueHelper'])

    register_Ns3SpectrumConverter_methods(root_module, root_module['ns3::SpectrumConverter'])

    register_Ns3SpectrumErrorModel_methods(root_module, root_module['ns3::SpectrumErrorModel'])

    register_Ns3SpectrumInterference_methods(root_module, root_module['ns3::SpectrumInterference'])

    register_Ns3SpectrumModel_methods(root_module, root_module['ns3::SpectrumModel'])

    register_Ns3SpectrumPhy_methods(root_module, root_module['ns3::SpectrumPhy'])

    register_Ns3SpectrumPropagationLossModel_methods(root_module, root_module['ns3::SpectrumPropagationLossModel'])

    register_Ns3SpectrumValue_methods(root_module, root_module['ns3::SpectrumValue'])

    register_Ns3WaveformGenerator_methods(root_module, root_module['ns3::WaveformGenerator'])

    register_Ns3AlohaNoackMacHeader_methods(root_module, root_module['ns3::AlohaNoackMacHeader'])

    register_Ns3FriisSpectrumPropagationLossModel_methods(root_module, root_module['ns3::FriisSpectrumPropagationLossModel'])

    register_Ns3HalfDuplexIdealPhy_methods(root_module, root_module['ns3::HalfDuplexIdealPhy'])

    register_Ns3NonCommunicatingNetDevice_methods(root_module, root_module['ns3::NonCommunicatingNetDevice'])

    register_Ns3ShannonSpectrumErrorModel_methods(root_module, root_module['ns3::ShannonSpectrumErrorModel'])

    register_Ns3SpectrumAnalyzer_methods(root_module, root_module['ns3::SpectrumAnalyzer'])

    register_Ns3SpectrumChannel_methods(root_module, root_module['ns3::SpectrumChannel'])

    register_Ns3AlohaNoackNetDevice_methods(root_module, root_module['ns3::AlohaNoackNetDevice'])

    register_Ns3MultiModelSpectrumChannel_methods(root_module, root_module['ns3::MultiModelSpectrumChannel'])

    register_Ns3SingleModelSpectrumChannel_methods(root_module, root_module['ns3::SingleModelSpectrumChannel'])

    return

def register_Ns3AdhocAlohaNoackIdealPhyHelper_methods(root_module, cls):

    ## adhoc-aloha-noack-ideal-phy-helper.h: ns3::AdhocAlohaNoackIdealPhyHelper::AdhocAlohaNoackIdealPhyHelper(ns3::AdhocAlohaNoackIdealPhyHelper const & arg0) [copy constructor]

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

    ## adhoc-aloha-noack-ideal-phy-helper.h: ns3::AdhocAlohaNoackIdealPhyHelper::AdhocAlohaNoackIdealPhyHelper() [constructor]

    cls.add_constructor([])

    ## adhoc-aloha-noack-ideal-phy-helper.h: ns3::NetDeviceContainer ns3::AdhocAlohaNoackIdealPhyHelper::Install(ns3::NodeContainer c) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::NodeContainer', 'c')], 

                   is_const=True)

    ## adhoc-aloha-noack-ideal-phy-helper.h: ns3::NetDeviceContainer ns3::AdhocAlohaNoackIdealPhyHelper::Install(ns3::Ptr<ns3::Node> node) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::Ptr< ns3::Node >', 'node')], 

                   is_const=True)

    ## adhoc-aloha-noack-ideal-phy-helper.h: ns3::NetDeviceContainer ns3::AdhocAlohaNoackIdealPhyHelper::Install(std::string nodeName) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('std::string', 'nodeName')], 

                   is_const=True)

    ## adhoc-aloha-noack-ideal-phy-helper.h: void ns3::AdhocAlohaNoackIdealPhyHelper::SetChannel(ns3::Ptr<ns3::SpectrumChannel> channel) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumChannel >', 'channel')])

    ## adhoc-aloha-noack-ideal-phy-helper.h: void ns3::AdhocAlohaNoackIdealPhyHelper::SetChannel(std::string channelName) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('std::string', 'channelName')])

    ## adhoc-aloha-noack-ideal-phy-helper.h: void ns3::AdhocAlohaNoackIdealPhyHelper::SetDeviceAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]

    cls.add_method('SetDeviceAttribute', 

                   'void', 

                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])

    ## adhoc-aloha-noack-ideal-phy-helper.h: void ns3::AdhocAlohaNoackIdealPhyHelper::SetNoisePowerSpectralDensity(ns3::Ptr<ns3::SpectrumValue> noisePsd) [member function]

    cls.add_method('SetNoisePowerSpectralDensity', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumValue >', 'noisePsd')])

    ## adhoc-aloha-noack-ideal-phy-helper.h: void ns3::AdhocAlohaNoackIdealPhyHelper::SetPhyAttribute(std::string name, ns3::AttributeValue const & v) [member function]

    cls.add_method('SetPhyAttribute', 

                   'void', 

                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')])

    ## adhoc-aloha-noack-ideal-phy-helper.h: void ns3::AdhocAlohaNoackIdealPhyHelper::SetTxPowerSpectralDensity(ns3::Ptr<ns3::SpectrumValue> txPsd) [member function]

    cls.add_method('SetTxPowerSpectralDensity', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumValue >', 'txPsd')])

    return

def register_Ns3BandInfo_methods(root_module, cls):

    ## spectrum-model.h: ns3::BandInfo::BandInfo() [constructor]

    cls.add_constructor([])

    ## spectrum-model.h: ns3::BandInfo::BandInfo(ns3::BandInfo const & arg0) [copy constructor]

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

    ## spectrum-model.h: ns3::BandInfo::fc [variable]

    cls.add_instance_attribute('fc', 'double', is_const=False)

    ## spectrum-model.h: ns3::BandInfo::fh [variable]

    cls.add_instance_attribute('fh', 'double', is_const=False)

    ## spectrum-model.h: ns3::BandInfo::fl [variable]

    cls.add_instance_attribute('fl', 'double', is_const=False)

    return

def register_Ns3MicrowaveOvenSpectrumValueHelper_methods(root_module, cls):

    ## microwave-oven-spectrum-value-helper.h: ns3::MicrowaveOvenSpectrumValueHelper::MicrowaveOvenSpectrumValueHelper() [constructor]

    cls.add_constructor([])

    ## microwave-oven-spectrum-value-helper.h: ns3::MicrowaveOvenSpectrumValueHelper::MicrowaveOvenSpectrumValueHelper(ns3::MicrowaveOvenSpectrumValueHelper const & arg0) [copy constructor]

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

    ## microwave-oven-spectrum-value-helper.h: static ns3::Ptr<ns3::SpectrumValue> ns3::MicrowaveOvenSpectrumValueHelper::CreatePowerSpectralDensityMwo1() [member function]

    cls.add_method('CreatePowerSpectralDensityMwo1', 

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

                   [], 

                   is_static=True)

    ## microwave-oven-spectrum-value-helper.h: static ns3::Ptr<ns3::SpectrumValue> ns3::MicrowaveOvenSpectrumValueHelper::CreatePowerSpectralDensityMwo2() [member function]

    cls.add_method('CreatePowerSpectralDensityMwo2', 

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

                   [], 

                   is_static=True)

    return

def register_Ns3RxSpectrumModelInfo_methods(root_module, cls):

    ## multi-model-spectrum-channel.h: ns3::RxSpectrumModelInfo::RxSpectrumModelInfo(ns3::RxSpectrumModelInfo const & arg0) [copy constructor]

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

    ## multi-model-spectrum-channel.h: ns3::RxSpectrumModelInfo::RxSpectrumModelInfo(ns3::Ptr<ns3::SpectrumModel const> rxSpectrumModel) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::SpectrumModel const >', 'rxSpectrumModel')])

    ## multi-model-spectrum-channel.h: ns3::RxSpectrumModelInfo::m_rxPhyList [variable]

    cls.add_instance_attribute('m_rxPhyList', 'std::list< ns3::Ptr< ns3::SpectrumPhy > >', is_const=False)

    ## multi-model-spectrum-channel.h: ns3::RxSpectrumModelInfo::m_rxSpectrumModel [variable]

    cls.add_instance_attribute('m_rxSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', is_const=False)

    return

def register_Ns3SpectrumAnalyzerHelper_methods(root_module, cls):

    ## spectrum-analyzer-helper.h: ns3::SpectrumAnalyzerHelper::SpectrumAnalyzerHelper(ns3::SpectrumAnalyzerHelper const & arg0) [copy constructor]

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

    ## spectrum-analyzer-helper.h: ns3::SpectrumAnalyzerHelper::SpectrumAnalyzerHelper() [constructor]

    cls.add_constructor([])

    ## spectrum-analyzer-helper.h: void ns3::SpectrumAnalyzerHelper::EnableAsciiAll(std::string prefix) [member function]

    cls.add_method('EnableAsciiAll', 

                   'void', 

                   [param('std::string', 'prefix')])

    ## spectrum-analyzer-helper.h: ns3::NetDeviceContainer ns3::SpectrumAnalyzerHelper::Install(ns3::NodeContainer c) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::NodeContainer', 'c')], 

                   is_const=True)

    ## spectrum-analyzer-helper.h: ns3::NetDeviceContainer ns3::SpectrumAnalyzerHelper::Install(ns3::Ptr<ns3::Node> node) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::Ptr< ns3::Node >', 'node')], 

                   is_const=True)

    ## spectrum-analyzer-helper.h: ns3::NetDeviceContainer ns3::SpectrumAnalyzerHelper::Install(std::string nodeName) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('std::string', 'nodeName')], 

                   is_const=True)

    ## spectrum-analyzer-helper.h: void ns3::SpectrumAnalyzerHelper::SetChannel(ns3::Ptr<ns3::SpectrumChannel> channel) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumChannel >', 'channel')])

    ## spectrum-analyzer-helper.h: void ns3::SpectrumAnalyzerHelper::SetChannel(std::string channelName) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('std::string', 'channelName')])

    ## spectrum-analyzer-helper.h: void ns3::SpectrumAnalyzerHelper::SetDeviceAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]

    cls.add_method('SetDeviceAttribute', 

                   'void', 

                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])

    ## spectrum-analyzer-helper.h: void ns3::SpectrumAnalyzerHelper::SetPhyAttribute(std::string name, ns3::AttributeValue const & v) [member function]

    cls.add_method('SetPhyAttribute', 

                   'void', 

                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')])

    ## spectrum-analyzer-helper.h: void ns3::SpectrumAnalyzerHelper::SetRxSpectrumModel(ns3::Ptr<ns3::SpectrumModel> m) [member function]

    cls.add_method('SetRxSpectrumModel', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumModel >', 'm')])

    return

def register_Ns3SpectrumChannelHelper_methods(root_module, cls):

    ## spectrum-helper.h: ns3::SpectrumChannelHelper::SpectrumChannelHelper() [constructor]

    cls.add_constructor([])

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

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

    ## spectrum-helper.h: void ns3::SpectrumChannelHelper::AddSpectrumPropagationLoss(std::string name, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]

    cls.add_method('AddSpectrumPropagationLoss', 

                   'void', 

                   [param('std::string', 'name'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])

    ## spectrum-helper.h: ns3::Ptr<ns3::SpectrumChannel> ns3::SpectrumChannelHelper::Create() const [member function]

    cls.add_method('Create', 

                   'ns3::Ptr< ns3::SpectrumChannel >', 

                   [], 

                   is_const=True)

    ## spectrum-helper.h: static ns3::SpectrumChannelHelper ns3::SpectrumChannelHelper::Default() [member function]

    cls.add_method('Default', 

                   'ns3::SpectrumChannelHelper', 

                   [], 

                   is_static=True)

    ## spectrum-helper.h: void ns3::SpectrumChannelHelper::SetChannel(std::string type, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('std::string', 'type'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])

    ## spectrum-helper.h: void ns3::SpectrumChannelHelper::SetPropagationDelay(std::string name, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]

    cls.add_method('SetPropagationDelay', 

                   'void', 

                   [param('std::string', 'name'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])

    return

def register_Ns3SpectrumPhyHelper_methods(root_module, cls):

    ## spectrum-helper.h: ns3::SpectrumPhyHelper::SpectrumPhyHelper() [constructor]

    cls.add_constructor([])

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

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

    ## spectrum-helper.h: ns3::Ptr<ns3::SpectrumPhy> ns3::SpectrumPhyHelper::Create(ns3::Ptr<ns3::Node> node, ns3::Ptr<ns3::NetDevice> device) const [member function]

    cls.add_method('Create', 

                   'ns3::Ptr< ns3::SpectrumPhy >', 

                   [param('ns3::Ptr< ns3::Node >', 'node'), param('ns3::Ptr< ns3::NetDevice >', 'device')], 

                   is_const=True)

    ## spectrum-helper.h: void ns3::SpectrumPhyHelper::SetChannel(ns3::Ptr<ns3::SpectrumChannel> channel) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumChannel >', 'channel')])

    ## spectrum-helper.h: void ns3::SpectrumPhyHelper::SetChannel(std::string channelName) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('std::string', 'channelName')])

    ## spectrum-helper.h: void ns3::SpectrumPhyHelper::SetPhy(std::string name, std::string n0="", ns3::AttributeValue const & v0=ns3::EmptyAttributeValue(), std::string n1="", ns3::AttributeValue const & v1=ns3::EmptyAttributeValue(), std::string n2="", ns3::AttributeValue const & v2=ns3::EmptyAttributeValue(), std::string n3="", ns3::AttributeValue const & v3=ns3::EmptyAttributeValue(), std::string n4="", ns3::AttributeValue const & v4=ns3::EmptyAttributeValue(), std::string n5="", ns3::AttributeValue const & v5=ns3::EmptyAttributeValue(), std::string n6="", ns3::AttributeValue const & v6=ns3::EmptyAttributeValue(), std::string n7="", ns3::AttributeValue const & v7=ns3::EmptyAttributeValue()) [member function]

    cls.add_method('SetPhy', 

                   'void', 

                   [param('std::string', 'name'), param('std::string', 'n0', default_value='""'), param('ns3::AttributeValue const &', 'v0', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n1', default_value='""'), param('ns3::AttributeValue const &', 'v1', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n2', default_value='""'), param('ns3::AttributeValue const &', 'v2', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n3', default_value='""'), param('ns3::AttributeValue const &', 'v3', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n4', default_value='""'), param('ns3::AttributeValue const &', 'v4', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n5', default_value='""'), param('ns3::AttributeValue const &', 'v5', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n6', default_value='""'), param('ns3::AttributeValue const &', 'v6', default_value='ns3::EmptyAttributeValue()'), param('std::string', 'n7', default_value='""'), param('ns3::AttributeValue const &', 'v7', default_value='ns3::EmptyAttributeValue()')])

    ## spectrum-helper.h: void ns3::SpectrumPhyHelper::SetPhyAttribute(std::string name, ns3::AttributeValue const & v) [member function]

    cls.add_method('SetPhyAttribute', 

                   'void', 

                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')])

    return

def register_Ns3SpectrumType_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## spectrum-type.h: ns3::SpectrumType::SpectrumType(ns3::SpectrumType const & arg0) [copy constructor]

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

    ## spectrum-type.h: std::string ns3::SpectrumType::GetName() const [member function]

    cls.add_method('GetName', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## spectrum-type.h: uint32_t ns3::SpectrumType::GetUid() const [member function]

    cls.add_method('GetUid', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    return

def register_Ns3SpectrumTypeFactory_methods(root_module, cls):

    ## spectrum-type.h: ns3::SpectrumTypeFactory::SpectrumTypeFactory() [constructor]

    cls.add_constructor([])

    ## spectrum-type.h: ns3::SpectrumTypeFactory::SpectrumTypeFactory(ns3::SpectrumTypeFactory const & arg0) [copy constructor]

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

    ## spectrum-type.h: static ns3::SpectrumType ns3::SpectrumTypeFactory::Create(std::string name) [member function]

    cls.add_method('Create', 

                   'ns3::SpectrumType', 

                   [param('std::string', 'name')], 

                   is_static=True)

    ## spectrum-type.h: static std::string ns3::SpectrumTypeFactory::GetNameByUid(uint32_t uid) [member function]

    cls.add_method('GetNameByUid', 

                   'std::string', 

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

                   is_static=True)

    return

def register_Ns3TxSpectrumModelInfo_methods(root_module, cls):

    ## multi-model-spectrum-channel.h: ns3::TxSpectrumModelInfo::TxSpectrumModelInfo(ns3::TxSpectrumModelInfo const & arg0) [copy constructor]

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

    ## multi-model-spectrum-channel.h: ns3::TxSpectrumModelInfo::TxSpectrumModelInfo(ns3::Ptr<ns3::SpectrumModel const> txSpectrumModel) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::SpectrumModel const >', 'txSpectrumModel')])

    ## multi-model-spectrum-channel.h: ns3::TxSpectrumModelInfo::m_spectrumConverterMap [variable]

    cls.add_instance_attribute('m_spectrumConverterMap', 'ns3::SpectrumConverterMap_t', is_const=False)

    ## multi-model-spectrum-channel.h: ns3::TxSpectrumModelInfo::m_txSpectrumModel [variable]

    cls.add_instance_attribute('m_txSpectrumModel', 'ns3::Ptr< ns3::SpectrumModel const >', is_const=False)

    return

def register_Ns3WaveformGeneratorHelper_methods(root_module, cls):

    ## waveform-generator-helper.h: ns3::WaveformGeneratorHelper::WaveformGeneratorHelper(ns3::WaveformGeneratorHelper const & arg0) [copy constructor]

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

    ## waveform-generator-helper.h: ns3::WaveformGeneratorHelper::WaveformGeneratorHelper() [constructor]

    cls.add_constructor([])

    ## waveform-generator-helper.h: ns3::NetDeviceContainer ns3::WaveformGeneratorHelper::Install(ns3::NodeContainer c) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::NodeContainer', 'c')], 

                   is_const=True)

    ## waveform-generator-helper.h: ns3::NetDeviceContainer ns3::WaveformGeneratorHelper::Install(ns3::Ptr<ns3::Node> node) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('ns3::Ptr< ns3::Node >', 'node')], 

                   is_const=True)

    ## waveform-generator-helper.h: ns3::NetDeviceContainer ns3::WaveformGeneratorHelper::Install(std::string nodeName) const [member function]

    cls.add_method('Install', 

                   'ns3::NetDeviceContainer', 

                   [param('std::string', 'nodeName')], 

                   is_const=True)

    ## waveform-generator-helper.h: void ns3::WaveformGeneratorHelper::SetChannel(ns3::Ptr<ns3::SpectrumChannel> channel) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumChannel >', 'channel')])

    ## waveform-generator-helper.h: void ns3::WaveformGeneratorHelper::SetChannel(std::string channelName) [member function]

    cls.add_method('SetChannel', 

                   'void', 

                   [param('std::string', 'channelName')])

    ## waveform-generator-helper.h: void ns3::WaveformGeneratorHelper::SetDeviceAttribute(std::string n1, ns3::AttributeValue const & v1) [member function]

    cls.add_method('SetDeviceAttribute', 

                   'void', 

                   [param('std::string', 'n1'), param('ns3::AttributeValue const &', 'v1')])

    ## waveform-generator-helper.h: void ns3::WaveformGeneratorHelper::SetPhyAttribute(std::string name, ns3::AttributeValue const & v) [member function]

    cls.add_method('SetPhyAttribute', 

                   'void', 

                   [param('std::string', 'name'), param('ns3::AttributeValue const &', 'v')])

    ## waveform-generator-helper.h: void ns3::WaveformGeneratorHelper::SetTxPowerSpectralDensity(ns3::Ptr<ns3::SpectrumValue> txPsd) [member function]

    cls.add_method('SetTxPowerSpectralDensity', 

                   'void', 

                   [param('ns3::Ptr< ns3::SpectrumValue >', 'txPsd')])

    return

def register_Ns3WifiSpectrumValue5MhzFactory_methods(root_module, cls):

    ## wifi-spectrum-value-helper.h: ns3::WifiSpectrumValue5MhzFactory::WifiSpectrumValue5MhzFactory() [constructor]

    cls.add_constructor([])

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