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

def register_types(module):

    root_module = module.get_root()

    ## wifi-mac-header.h: ns3::WifiMacType [enumeration]

    module.add_enum('WifiMacType', ['WIFI_MAC_CTL_RTS', 'WIFI_MAC_CTL_CTS', 'WIFI_MAC_CTL_ACK', 'WIFI_MAC_CTL_BACKREQ', 'WIFI_MAC_CTL_BACKRESP', 'WIFI_MAC_MGT_BEACON', 'WIFI_MAC_MGT_ASSOCIATION_REQUEST', 'WIFI_MAC_MGT_ASSOCIATION_RESPONSE', 'WIFI_MAC_MGT_DISASSOCIATION', 'WIFI_MAC_MGT_REASSOCIATION_REQUEST', 'WIFI_MAC_MGT_REASSOCIATION_RESPONSE', 'WIFI_MAC_MGT_PROBE_REQUEST', 'WIFI_MAC_MGT_PROBE_RESPONSE', 'WIFI_MAC_MGT_AUTHENTICATION', 'WIFI_MAC_MGT_DEAUTHENTICATION', 'WIFI_MAC_MGT_ACTION', 'WIFI_MAC_MGT_ACTION_NO_ACK', 'WIFI_MAC_MGT_MULTIHOP_ACTION', 'WIFI_MAC_DATA', 'WIFI_MAC_DATA_CFACK', 'WIFI_MAC_DATA_CFPOLL', 'WIFI_MAC_DATA_CFACK_CFPOLL', 'WIFI_MAC_DATA_NULL', 'WIFI_MAC_DATA_NULL_CFACK', 'WIFI_MAC_DATA_NULL_CFPOLL', 'WIFI_MAC_DATA_NULL_CFACK_CFPOLL', 'WIFI_MAC_QOSDATA', 'WIFI_MAC_QOSDATA_CFACK', 'WIFI_MAC_QOSDATA_CFPOLL', 'WIFI_MAC_QOSDATA_CFACK_CFPOLL', 'WIFI_MAC_QOSDATA_NULL', 'WIFI_MAC_QOSDATA_NULL_CFPOLL', 'WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL'])

    ## wifi-preamble.h: ns3::WifiPreamble [enumeration]

    module.add_enum('WifiPreamble', ['WIFI_PREAMBLE_LONG', 'WIFI_PREAMBLE_SHORT'])

    ## wifi-phy-standard.h: ns3::WifiPhyStandard [enumeration]

    module.add_enum('WifiPhyStandard', ['WIFI_PHY_STANDARD_80211a', 'WIFI_PHY_STANDARD_80211b', 'WIFI_PHY_STANDARD_80211_10Mhz', 'WIFI_PHY_STANDARD_80211_5Mhz', 'WIFI_PHY_STANDARD_holland'])

    ## qos-utils.h: ns3::AccessClass [enumeration]

    module.add_enum('AccessClass', ['AC_VO', 'AC_VI', 'AC_BE', 'AC_BK', 'AC_UNDEF'])

    ## edca-txop-n.h: ns3::TypeOfStation [enumeration]

    module.add_enum('TypeOfStation', ['STA', 'AP', 'ADHOC_STA'])

    ## capability-information.h: ns3::CapabilityInformation [class]

    module.add_class('CapabilityInformation')

    ## dcf-manager.h: ns3::DcfManager [class]

    module.add_class('DcfManager')

    ## dcf-manager.h: ns3::DcfState [class]

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

    ## interference-helper.h: ns3::InterferenceHelper [class]

    module.add_class('InterferenceHelper', allow_subclassing=False)

    ## interference-helper.h: ns3::InterferenceHelper::SnrPer [struct]

    module.add_class('SnrPer', outer_class=root_module['ns3::InterferenceHelper'])

    ## mac-low.h: ns3::MacLowDcfListener [class]

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

    ## mac-low.h: ns3::MacLowTransmissionListener [class]

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

    ## mac-low.h: ns3::MacLowTransmissionParameters [class]

    module.add_class('MacLowTransmissionParameters')

    ## mac-rx-middle.h: ns3::MacRxMiddle [class]

    module.add_class('MacRxMiddle')

    ## minstrel-wifi-manager.h: ns3::RateInfo [struct]

    module.add_class('RateInfo')

    ## ssid.h: ns3::Ssid [class]

    module.add_class('Ssid')

    ## status-code.h: ns3::StatusCode [class]

    module.add_class('StatusCode')

    ## supported-rates.h: ns3::SupportedRates [class]

    module.add_class('SupportedRates')

    ## rraa-wifi-manager.h: ns3::ThresholdsItem [struct]

    module.add_class('ThresholdsItem')

    ## wifi-mode.h: ns3::WifiMode [class]

    module.add_class('WifiMode')

    ## wifi-mode.h: ns3::WifiMode::ModulationType [enumeration]

    module.add_enum('ModulationType', ['BPSK', 'DBPSK', 'DQPSK', 'QAM'], outer_class=root_module['ns3::WifiMode'])

    ## wifi-mode.h: ns3::WifiModeFactory [class]

    module.add_class('WifiModeFactory')

    ## wifi-phy.h: ns3::WifiPhyListener [class]

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

    ## wifi-remote-station-manager.h: ns3::WifiRemoteStation [class]

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

    ## amrr-wifi-manager.h: ns3::AmrrWifiRemoteStation [class]

    module.add_class('AmrrWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation [class]

    module.add_class('ArfWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation [class]

    module.add_class('ConstantRateWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation [class]

    module.add_class('IdealWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## mgt-headers.h: ns3::MgtAssocRequestHeader [class]

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

    ## mgt-headers.h: ns3::MgtAssocResponseHeader [class]

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

    ## mgt-headers.h: ns3::MgtProbeRequestHeader [class]

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

    ## mgt-headers.h: ns3::MgtProbeResponseHeader [class]

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

    ## minstrel-wifi-manager.h: ns3::MinstrelWifiRemoteStation [class]

    module.add_class('MinstrelWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation [class]

    module.add_class('OnoeWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## propagation-delay-model.h: ns3::PropagationDelayModel [class]

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

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

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

    ## qos-tag.h: ns3::QosTag [class]

    module.add_class('QosTag', parent=root_module['ns3::Tag'])

    ## propagation-delay-model.h: ns3::RandomPropagationDelayModel [class]

    module.add_class('RandomPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])

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

    module.add_class('RandomPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation [class]

    module.add_class('RraaWifiRemoteStation', parent=root_module['ns3::WifiRemoteStation'])

    ## ssid.h: ns3::SsidChecker [class]

    module.add_class('SsidChecker', parent=root_module['ns3::AttributeChecker'])

    ## ssid.h: ns3::SsidValue [class]

    module.add_class('SsidValue', parent=root_module['ns3::AttributeValue'])

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

    module.add_class('ThreeLogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## wifi-mac.h: ns3::WifiMac [class]

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

    ## wifi-mac-header.h: ns3::WifiMacHeader [class]

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

    ## wifi-mac-header.h: ns3::WifiMacHeader::QosAckPolicy [enumeration]

    module.add_enum('QosAckPolicy', ['NORMAL_ACK', 'NO_ACK', 'NO_EXPLICIT_ACK', 'BLOCK_ACK'], outer_class=root_module['ns3::WifiMacHeader'])

    ## wifi-mac-header.h: ns3::WifiMacHeader::AddressType [enumeration]

    module.add_enum('AddressType', ['ADDR1', 'ADDR2', 'ADDR3', 'ADDR4'], outer_class=root_module['ns3::WifiMacHeader'])

    ## wifi-mode.h: ns3::WifiModeChecker [class]

    module.add_class('WifiModeChecker', parent=root_module['ns3::AttributeChecker'])

    ## wifi-mode.h: ns3::WifiModeValue [class]

    module.add_class('WifiModeValue', parent=root_module['ns3::AttributeValue'])

    ## wifi-phy.h: ns3::WifiPhy [class]

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

    ## wifi-phy.h: ns3::WifiPhy::State [enumeration]

    module.add_enum('State', ['SYNC', 'TX', 'CCA_BUSY', 'IDLE'], outer_class=root_module['ns3::WifiPhy'])

    ## wifi-remote-station-manager.h: ns3::WifiRemoteStationManager [class]

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

    ## yans-wifi-phy.h: ns3::YansWifiPhy [class]

    module.add_class('YansWifiPhy', parent=root_module['ns3::WifiPhy'])

    ## aarf-wifi-manager.h: ns3::AarfWifiRemoteStation [class]

    module.add_class('AarfWifiRemoteStation', parent=root_module['ns3::ArfWifiRemoteStation'])

    ## adhoc-wifi-mac.h: ns3::AdhocWifiMac [class]

    module.add_class('AdhocWifiMac', parent=root_module['ns3::WifiMac'])

    ## amrr-wifi-manager.h: ns3::AmrrWifiManager [class]

    module.add_class('AmrrWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## amsdu-subframe-header.h: ns3::AmsduSubframeHeader [class]

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

    ## arf-wifi-manager.h: ns3::ArfWifiManager [class]

    module.add_class('ArfWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiManager [class]

    module.add_class('ConstantRateWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## propagation-delay-model.h: ns3::ConstantSpeedPropagationDelayModel [class]

    module.add_class('ConstantSpeedPropagationDelayModel', parent=root_module['ns3::PropagationDelayModel'])

    ## dca-txop.h: ns3::DcaTxop [class]

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

    ## edca-txop-n.h: ns3::EdcaTxopN [class]

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

    ## error-rate-model.h: ns3::ErrorRateModel [class]

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

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

    module.add_class('FixedRssLossModel', parent=root_module['ns3::PropagationLossModel'])

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

    module.add_class('FriisPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## ideal-wifi-manager.h: ns3::IdealWifiManager [class]

    module.add_class('IdealWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## jakes-propagation-loss-model.h: ns3::JakesPropagationLossModel [class]

    module.add_class('JakesPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

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

    module.add_class('LogDistancePropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## mac-low.h: ns3::MacLow [class]

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

    ## mgt-headers.h: ns3::MgtBeaconHeader [class]

    module.add_class('MgtBeaconHeader', parent=root_module['ns3::MgtProbeResponseHeader'])

    ## minstrel-wifi-manager.h: ns3::MinstrelWifiManager [class]

    module.add_class('MinstrelWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## msdu-aggregator.h: ns3::MsduAggregator [class]

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

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

    module.add_class('NakagamiPropagationLossModel', parent=root_module['ns3::PropagationLossModel'])

    ## nqap-wifi-mac.h: ns3::NqapWifiMac [class]

    module.add_class('NqapWifiMac', parent=root_module['ns3::WifiMac'])

    ## nqsta-wifi-mac.h: ns3::NqstaWifiMac [class]

    module.add_class('NqstaWifiMac', parent=root_module['ns3::WifiMac'])

    ## onoe-wifi-manager.h: ns3::OnoeWifiManager [class]

    module.add_class('OnoeWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## qadhoc-wifi-mac.h: ns3::QadhocWifiMac [class]

    module.add_class('QadhocWifiMac', parent=root_module['ns3::WifiMac'])

    ## qap-wifi-mac.h: ns3::QapWifiMac [class]

    module.add_class('QapWifiMac', parent=root_module['ns3::WifiMac'])

    ## qsta-wifi-mac.h: ns3::QstaWifiMac [class]

    module.add_class('QstaWifiMac', parent=root_module['ns3::WifiMac'])

    ## rraa-wifi-manager.h: ns3::RraaWifiManager [class]

    module.add_class('RraaWifiManager', parent=root_module['ns3::WifiRemoteStationManager'])

    ## wifi-channel.h: ns3::WifiChannel [class]

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

    ## wifi-net-device.h: ns3::WifiNetDevice [class]

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

    ## yans-error-rate-model.h: ns3::YansErrorRateModel [class]

    module.add_class('YansErrorRateModel', parent=root_module['ns3::ErrorRateModel'])

    ## yans-wifi-channel.h: ns3::YansWifiChannel [class]

    module.add_class('YansWifiChannel', parent=root_module['ns3::WifiChannel'])

    ## aarf-wifi-manager.h: ns3::AarfWifiManager [class]

    module.add_class('AarfWifiManager', parent=root_module['ns3::ArfWifiManager'])

    typehandlers.add_type_alias('std::vector< ns3::RateInfo, std::allocator< ns3::RateInfo > >', 'ns3::MinstrelRate')

    typehandlers.add_type_alias('std::vector< std::vector< unsigned int, std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int, std::allocator< unsigned int > > > >', 'ns3::SampleRate')

    typehandlers.add_type_alias('std::vector< ns3::ThresholdsItem, std::allocator< ns3::ThresholdsItem > >', 'ns3::Thresholds')

    ## 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 TimeStepPrecision

    nested_module = module.add_cpp_namespace('TimeStepPrecision')

    register_types_ns3_TimeStepPrecision(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 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_TimeStepPrecision(module):

    root_module = module.get_root()

def register_types_ns3_addressUtils(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_Ns3CapabilityInformation_methods(root_module, root_module['ns3::CapabilityInformation'])

    register_Ns3DcfManager_methods(root_module, root_module['ns3::DcfManager'])

    register_Ns3DcfState_methods(root_module, root_module['ns3::DcfState'])

    register_Ns3InterferenceHelper_methods(root_module, root_module['ns3::InterferenceHelper'])

    register_Ns3InterferenceHelperSnrPer_methods(root_module, root_module['ns3::InterferenceHelper::SnrPer'])

    register_Ns3MacLowDcfListener_methods(root_module, root_module['ns3::MacLowDcfListener'])

    register_Ns3MacLowTransmissionListener_methods(root_module, root_module['ns3::MacLowTransmissionListener'])

    register_Ns3MacLowTransmissionParameters_methods(root_module, root_module['ns3::MacLowTransmissionParameters'])

    register_Ns3MacRxMiddle_methods(root_module, root_module['ns3::MacRxMiddle'])

    register_Ns3RateInfo_methods(root_module, root_module['ns3::RateInfo'])

    register_Ns3Ssid_methods(root_module, root_module['ns3::Ssid'])

    register_Ns3StatusCode_methods(root_module, root_module['ns3::StatusCode'])

    register_Ns3SupportedRates_methods(root_module, root_module['ns3::SupportedRates'])

    register_Ns3ThresholdsItem_methods(root_module, root_module['ns3::ThresholdsItem'])

    register_Ns3WifiMode_methods(root_module, root_module['ns3::WifiMode'])

    register_Ns3WifiModeFactory_methods(root_module, root_module['ns3::WifiModeFactory'])

    register_Ns3WifiPhyListener_methods(root_module, root_module['ns3::WifiPhyListener'])

    register_Ns3WifiRemoteStation_methods(root_module, root_module['ns3::WifiRemoteStation'])

    register_Ns3AmrrWifiRemoteStation_methods(root_module, root_module['ns3::AmrrWifiRemoteStation'])

    register_Ns3ArfWifiRemoteStation_methods(root_module, root_module['ns3::ArfWifiRemoteStation'])

    register_Ns3ConstantRateWifiRemoteStation_methods(root_module, root_module['ns3::ConstantRateWifiRemoteStation'])

    register_Ns3IdealWifiRemoteStation_methods(root_module, root_module['ns3::IdealWifiRemoteStation'])

    register_Ns3MgtAssocRequestHeader_methods(root_module, root_module['ns3::MgtAssocRequestHeader'])

    register_Ns3MgtAssocResponseHeader_methods(root_module, root_module['ns3::MgtAssocResponseHeader'])

    register_Ns3MgtProbeRequestHeader_methods(root_module, root_module['ns3::MgtProbeRequestHeader'])

    register_Ns3MgtProbeResponseHeader_methods(root_module, root_module['ns3::MgtProbeResponseHeader'])

    register_Ns3MinstrelWifiRemoteStation_methods(root_module, root_module['ns3::MinstrelWifiRemoteStation'])

    register_Ns3OnoeWifiRemoteStation_methods(root_module, root_module['ns3::OnoeWifiRemoteStation'])

    register_Ns3PropagationDelayModel_methods(root_module, root_module['ns3::PropagationDelayModel'])

    register_Ns3PropagationLossModel_methods(root_module, root_module['ns3::PropagationLossModel'])

    register_Ns3QosTag_methods(root_module, root_module['ns3::QosTag'])

    register_Ns3RandomPropagationDelayModel_methods(root_module, root_module['ns3::RandomPropagationDelayModel'])

    register_Ns3RandomPropagationLossModel_methods(root_module, root_module['ns3::RandomPropagationLossModel'])

    register_Ns3RraaWifiRemoteStation_methods(root_module, root_module['ns3::RraaWifiRemoteStation'])

    register_Ns3SsidChecker_methods(root_module, root_module['ns3::SsidChecker'])

    register_Ns3SsidValue_methods(root_module, root_module['ns3::SsidValue'])

    register_Ns3ThreeLogDistancePropagationLossModel_methods(root_module, root_module['ns3::ThreeLogDistancePropagationLossModel'])

    register_Ns3WifiMac_methods(root_module, root_module['ns3::WifiMac'])

    register_Ns3WifiMacHeader_methods(root_module, root_module['ns3::WifiMacHeader'])

    register_Ns3WifiModeChecker_methods(root_module, root_module['ns3::WifiModeChecker'])

    register_Ns3WifiModeValue_methods(root_module, root_module['ns3::WifiModeValue'])

    register_Ns3WifiPhy_methods(root_module, root_module['ns3::WifiPhy'])

    register_Ns3WifiRemoteStationManager_methods(root_module, root_module['ns3::WifiRemoteStationManager'])

    register_Ns3YansWifiPhy_methods(root_module, root_module['ns3::YansWifiPhy'])

    register_Ns3AarfWifiRemoteStation_methods(root_module, root_module['ns3::AarfWifiRemoteStation'])

    register_Ns3AdhocWifiMac_methods(root_module, root_module['ns3::AdhocWifiMac'])

    register_Ns3AmrrWifiManager_methods(root_module, root_module['ns3::AmrrWifiManager'])

    register_Ns3AmsduSubframeHeader_methods(root_module, root_module['ns3::AmsduSubframeHeader'])

    register_Ns3ArfWifiManager_methods(root_module, root_module['ns3::ArfWifiManager'])

    register_Ns3ConstantRateWifiManager_methods(root_module, root_module['ns3::ConstantRateWifiManager'])

    register_Ns3ConstantSpeedPropagationDelayModel_methods(root_module, root_module['ns3::ConstantSpeedPropagationDelayModel'])

    register_Ns3DcaTxop_methods(root_module, root_module['ns3::DcaTxop'])

    register_Ns3EdcaTxopN_methods(root_module, root_module['ns3::EdcaTxopN'])

    register_Ns3ErrorRateModel_methods(root_module, root_module['ns3::ErrorRateModel'])

    register_Ns3FixedRssLossModel_methods(root_module, root_module['ns3::FixedRssLossModel'])

    register_Ns3FriisPropagationLossModel_methods(root_module, root_module['ns3::FriisPropagationLossModel'])

    register_Ns3IdealWifiManager_methods(root_module, root_module['ns3::IdealWifiManager'])

    register_Ns3JakesPropagationLossModel_methods(root_module, root_module['ns3::JakesPropagationLossModel'])

    register_Ns3LogDistancePropagationLossModel_methods(root_module, root_module['ns3::LogDistancePropagationLossModel'])

    register_Ns3MacLow_methods(root_module, root_module['ns3::MacLow'])

    register_Ns3MgtBeaconHeader_methods(root_module, root_module['ns3::MgtBeaconHeader'])

    register_Ns3MinstrelWifiManager_methods(root_module, root_module['ns3::MinstrelWifiManager'])

    register_Ns3MsduAggregator_methods(root_module, root_module['ns3::MsduAggregator'])

    register_Ns3NakagamiPropagationLossModel_methods(root_module, root_module['ns3::NakagamiPropagationLossModel'])

    register_Ns3NqapWifiMac_methods(root_module, root_module['ns3::NqapWifiMac'])

    register_Ns3NqstaWifiMac_methods(root_module, root_module['ns3::NqstaWifiMac'])

    register_Ns3OnoeWifiManager_methods(root_module, root_module['ns3::OnoeWifiManager'])

    register_Ns3QadhocWifiMac_methods(root_module, root_module['ns3::QadhocWifiMac'])

    register_Ns3QapWifiMac_methods(root_module, root_module['ns3::QapWifiMac'])

    register_Ns3QstaWifiMac_methods(root_module, root_module['ns3::QstaWifiMac'])

    register_Ns3RraaWifiManager_methods(root_module, root_module['ns3::RraaWifiManager'])

    register_Ns3WifiChannel_methods(root_module, root_module['ns3::WifiChannel'])

    register_Ns3WifiNetDevice_methods(root_module, root_module['ns3::WifiNetDevice'])

    register_Ns3YansErrorRateModel_methods(root_module, root_module['ns3::YansErrorRateModel'])

    register_Ns3YansWifiChannel_methods(root_module, root_module['ns3::YansWifiChannel'])

    register_Ns3AarfWifiManager_methods(root_module, root_module['ns3::AarfWifiManager'])

    return

def register_Ns3CapabilityInformation_methods(root_module, cls):

    ## capability-information.h: ns3::CapabilityInformation::CapabilityInformation(ns3::CapabilityInformation const & arg0) [copy constructor]

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

    ## capability-information.h: ns3::CapabilityInformation::CapabilityInformation() [constructor]

    cls.add_constructor([])

    ## capability-information.h: void ns3::CapabilityInformation::SetEss() [member function]

    cls.add_method('SetEss', 

                   'void', 

                   [])

    ## capability-information.h: void ns3::CapabilityInformation::SetIbss() [member function]

    cls.add_method('SetIbss', 

                   'void', 

                   [])

    ## capability-information.h: bool ns3::CapabilityInformation::IsEss() const [member function]

    cls.add_method('IsEss', 

                   'bool', 

                   [], 

                   is_const=True)

    ## capability-information.h: bool ns3::CapabilityInformation::IsIbss() const [member function]

    cls.add_method('IsIbss', 

                   'bool', 

                   [], 

                   is_const=True)

    ## capability-information.h: uint32_t ns3::CapabilityInformation::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## capability-information.h: ns3::Buffer::Iterator ns3::CapabilityInformation::Serialize(ns3::Buffer::Iterator start) const [member function]

    cls.add_method('Serialize', 

                   'ns3::Buffer::Iterator', 

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

                   is_const=True)

    ## capability-information.h: ns3::Buffer::Iterator ns3::CapabilityInformation::Deserialize(ns3::Buffer::Iterator start) [member function]

    cls.add_method('Deserialize', 

                   'ns3::Buffer::Iterator', 

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

    return

def register_Ns3DcfManager_methods(root_module, cls):

    ## dcf-manager.h: ns3::DcfManager::DcfManager(ns3::DcfManager const & arg0) [copy constructor]

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

    ## dcf-manager.h: ns3::DcfManager::DcfManager() [constructor]

    cls.add_constructor([])

    ## dcf-manager.h: void ns3::DcfManager::SetupPhyListener(ns3::Ptr<ns3::WifiPhy> phy) [member function]

    cls.add_method('SetupPhyListener', 

                   'void', 

                   [param('ns3::Ptr< ns3::WifiPhy >', 'phy')])

    ## dcf-manager.h: void ns3::DcfManager::SetupLowListener(ns3::Ptr<ns3::MacLow> low) [member function]

    cls.add_method('SetupLowListener', 

                   'void', 

                   [param('ns3::Ptr< ns3::MacLow >', 'low')])

    ## dcf-manager.h: void ns3::DcfManager::SetSlot(ns3::Time slotTime) [member function]

    cls.add_method('SetSlot', 

                   'void', 

                   [param('ns3::Time', 'slotTime')])

    ## dcf-manager.h: void ns3::DcfManager::SetSifs(ns3::Time sifs) [member function]

    cls.add_method('SetSifs', 

                   'void', 

                   [param('ns3::Time', 'sifs')])

    ## dcf-manager.h: void ns3::DcfManager::SetEifsNoDifs(ns3::Time eifsNoDifs) [member function]

    cls.add_method('SetEifsNoDifs', 

                   'void', 

                   [param('ns3::Time', 'eifsNoDifs')])

    ## dcf-manager.h: ns3::Time ns3::DcfManager::GetEifsNoDifs() const [member function]

    cls.add_method('GetEifsNoDifs', 

                   'ns3::Time', 

                   [], 

                   is_const=True)

    ## dcf-manager.h: void ns3::DcfManager::Add(ns3::DcfState * dcf) [member function]

    cls.add_method('Add', 

                   'void', 

                   [param('ns3::DcfState *', 'dcf')])

    ## dcf-manager.h: void ns3::DcfManager::RequestAccess(ns3::DcfState * state) [member function]

    cls.add_method('RequestAccess', 

                   'void', 

                   [param('ns3::DcfState *', 'state')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyRxStartNow(ns3::Time duration) [member function]

    cls.add_method('NotifyRxStartNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyRxEndOkNow() [member function]

    cls.add_method('NotifyRxEndOkNow', 

                   'void', 

                   [])

    ## dcf-manager.h: void ns3::DcfManager::NotifyRxEndErrorNow() [member function]

    cls.add_method('NotifyRxEndErrorNow', 

                   'void', 

                   [])

    ## dcf-manager.h: void ns3::DcfManager::NotifyTxStartNow(ns3::Time duration) [member function]

    cls.add_method('NotifyTxStartNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyMaybeCcaBusyStartNow(ns3::Time duration) [member function]

    cls.add_method('NotifyMaybeCcaBusyStartNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyNavResetNow(ns3::Time duration) [member function]

    cls.add_method('NotifyNavResetNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyNavStartNow(ns3::Time duration) [member function]

    cls.add_method('NotifyNavStartNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyAckTimeoutStartNow(ns3::Time duration) [member function]

    cls.add_method('NotifyAckTimeoutStartNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyAckTimeoutResetNow() [member function]

    cls.add_method('NotifyAckTimeoutResetNow', 

                   'void', 

                   [])

    ## dcf-manager.h: void ns3::DcfManager::NotifyCtsTimeoutStartNow(ns3::Time duration) [member function]

    cls.add_method('NotifyCtsTimeoutStartNow', 

                   'void', 

                   [param('ns3::Time', 'duration')])

    ## dcf-manager.h: void ns3::DcfManager::NotifyCtsTimeoutResetNow() [member function]

    cls.add_method('NotifyCtsTimeoutResetNow', 

                   'void', 

                   [])

    return

def register_Ns3DcfState_methods(root_module, cls):

    ## dcf-manager.h: ns3::DcfState::DcfState(ns3::DcfState const & arg0) [copy constructor]

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

    ## dcf-manager.h: ns3::DcfState::DcfState() [constructor]

    cls.add_constructor([])

    ## dcf-manager.h: void ns3::DcfState::SetAifsn(uint32_t aifsn) [member function]

    cls.add_method('SetAifsn', 

                   'void', 

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

    ## dcf-manager.h: void ns3::DcfState::SetCwMin(uint32_t minCw) [member function]

    cls.add_method('SetCwMin', 

                   'void', 

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

    ## dcf-manager.h: void ns3::DcfState::SetCwMax(uint32_t maxCw) [member function]

    cls.add_method('SetCwMax', 

                   'void', 

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

    ## dcf-manager.h: uint32_t ns3::DcfState::GetAifsn() const [member function]

    cls.add_method('GetAifsn', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## dcf-manager.h: uint32_t ns3::DcfState::GetCwMin() const [member function]

    cls.add_method('GetCwMin', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## dcf-manager.h: uint32_t ns3::DcfState::GetCwMax() const [member function]

    cls.add_method('GetCwMax', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## dcf-manager.h: void ns3::DcfState::ResetCw() [member function]

    cls.add_method('ResetCw', 

                   'void', 

                   [])

    ## dcf-manager.h: void ns3::DcfState::UpdateFailedCw() [member function]

    cls.add_method('UpdateFailedCw', 

                   'void', 

                   [])

    ## dcf-manager.h: void ns3::DcfState::StartBackoffNow(uint32_t nSlots) [member function]

    cls.add_method('StartBackoffNow', 

                   'void', 

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

    ## dcf-manager.h: uint32_t ns3::DcfState::GetCw() const [member function]

    cls.add_method('GetCw', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## dcf-manager.h: bool ns3::DcfState::IsAccessRequested() const [member function]

    cls.add_method('IsAccessRequested', 

                   'bool', 

                   [], 

                   is_const=True)

    ## dcf-manager.h: void ns3::DcfState::DoNotifyAccessGranted() [member function]

    cls.add_method('DoNotifyAccessGranted', 

                   'void', 

                   [], 

                   is_pure_virtual=True, visibility='private', is_virtual=True)

    ## dcf-manager.h: void ns3::DcfState::DoNotifyInternalCollision() [member function]

    cls.add_method('DoNotifyInternalCollision', 

                   'void', 

                   [], 

                   is_pure_virtual=True, visibility='private', is_virtual=True)

    ## dcf-manager.h: void ns3::DcfState::DoNotifyCollision() [member function]

    cls.add_method('DoNotifyCollision', 

                   'void', 

                   [], 

                   is_pure_virtual=True, visibility='private', is_virtual=True)

    return

def register_Ns3InterferenceHelper_methods(root_module, cls):

    ## interference-helper.h: ns3::InterferenceHelper::InterferenceHelper() [constructor]

    cls.add_constructor([])

    ## interference-helper.h: ns3::Ptr<ns3::InterferenceHelper::Event> ns3::InterferenceHelper::Add(uint32_t size, ns3::WifiMode payloadMode, ns3::WifiPreamble preamble, ns3::Time duration, double rxPower) [member function]

    cls.add_method('Add', 

                   'ns3::Ptr< ns3::InterferenceHelper::Event >', 

                   [param('uint32_t', 'size'), param('ns3::WifiMode', 'payloadMode'), param('ns3::WifiPreamble', 'preamble'), param('ns3::Time', 'duration'), param('double', 'rxPower')])

    ## interference-helper.h: ns3::InterferenceHelper::SnrPer ns3::InterferenceHelper::CalculateSnrPer(ns3::Ptr<ns3::InterferenceHelper::Event> event) [member function]

    cls.add_method('CalculateSnrPer', 

                   'ns3::InterferenceHelper::SnrPer', 

                   [param('ns3::Ptr< ns3::InterferenceHelper::Event >', 'event')])

    ## interference-helper.h: static ns3::Time ns3::InterferenceHelper::CalculateTxDuration(uint32_t size, ns3::WifiMode payloadMode, ns3::WifiPreamble preamble) [member function]

    cls.add_method('CalculateTxDuration', 

                   'ns3::Time', 

                   [param('uint32_t', 'size'), param('ns3::WifiMode', 'payloadMode'), param('ns3::WifiPreamble', 'preamble')], 

                   is_static=True)

    ## interference-helper.h: ns3::Time ns3::InterferenceHelper::GetEnergyDuration(double energyW) [member function]

    cls.add_method('GetEnergyDuration', 

                   'ns3::Time', 

                   [param('double', 'energyW')])

    ## interference-helper.h: ns3::Ptr<ns3::ErrorRateModel> ns3::InterferenceHelper::GetErrorRateModel() const [member function]

    cls.add_method('GetErrorRateModel', 

                   'ns3::Ptr< ns3::ErrorRateModel >', 

                   [], 

                   is_const=True)

    ## interference-helper.h: double ns3::InterferenceHelper::GetNoiseFigure() const [member function]

    cls.add_method('GetNoiseFigure', 

                   'double', 

                   [], 

                   is_const=True)

    ## interference-helper.h: static uint32_t ns3::InterferenceHelper::GetPayloadDurationMicroSeconds(uint32_t size, ns3::WifiMode payloadMode) [member function]

    cls.add_method('GetPayloadDurationMicroSeconds', 

                   'uint32_t', 

                   [param('uint32_t', 'size'), param('ns3::WifiMode', 'payloadMode')], 

                   is_static=True)

    ## interference-helper.h: static uint32_t ns3::InterferenceHelper::GetPlcpHeaderDurationMicroSeconds(ns3::WifiMode payloadMode, ns3::WifiPreamble preamble) [member function]

    cls.add_method('GetPlcpHeaderDurationMicroSeconds', 

                   'uint32_t', 

                   [param('ns3::WifiMode', 'payloadMode'), param('ns3::WifiPreamble', 'preamble')], 

                   is_static=True)

    ## interference-helper.h: static ns3::WifiMode ns3::InterferenceHelper::GetPlcpHeaderMode(ns3::WifiMode payloadMode, ns3::WifiPreamble preamble) [member function]

    cls.add_method('GetPlcpHeaderMode', 

                   'ns3::WifiMode', 

                   [param('ns3::WifiMode', 'payloadMode'), param('ns3::WifiPreamble', 'preamble')], 

                   is_static=True)

    ## interference-helper.h: static uint32_t ns3::InterferenceHelper::GetPlcpPreambleDurationMicroSeconds(ns3::WifiMode mode, ns3::WifiPreamble preamble) [member function]

    cls.add_method('GetPlcpPreambleDurationMicroSeconds', 

                   'uint32_t', 

                   [param('ns3::WifiMode', 'mode'), param('ns3::WifiPreamble', 'preamble')], 

                   is_static=True)

    ## interference-helper.h: void ns3::InterferenceHelper::SetErrorRateModel(ns3::Ptr<ns3::ErrorRateModel> rate) [member function]

    cls.add_method('SetErrorRateModel', 

                   'void', 

                   [param('ns3::Ptr< ns3::ErrorRateModel >', 'rate')])

    ## interference-helper.h: void ns3::InterferenceHelper::SetNoiseFigure(double value) [member function]

    cls.add_method('SetNoiseFigure', 

                   'void', 

                   [param('double', 'value')])

    return

def register_Ns3InterferenceHelperSnrPer_methods(root_module, cls):

    ## interference-helper.h: ns3::InterferenceHelper::SnrPer::SnrPer() [constructor]

    cls.add_constructor([])

    ## interference-helper.h: ns3::InterferenceHelper::SnrPer::SnrPer(ns3::InterferenceHelper::SnrPer const & arg0) [copy constructor]

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

    ## interference-helper.h: ns3::InterferenceHelper::SnrPer::per [variable]

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

    ## interference-helper.h: ns3::InterferenceHelper::SnrPer::snr [variable]

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

    return

def register_Ns3MacLowDcfListener_methods(root_module, cls):

    ## mac-low.h: ns3::MacLowDcfListener::MacLowDcfListener(ns3::MacLowDcfListener const & arg0) [copy constructor]

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

    ## mac-low.h: ns3::MacLowDcfListener::MacLowDcfListener() [constructor]

    cls.add_constructor([])

    ## mac-low.h: void ns3::MacLowDcfListener::NavStart(ns3::Time duration) [member function]

    cls.add_method('NavStart', 

                   'void', 

                   [param('ns3::Time', 'duration')], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowDcfListener::NavReset(ns3::Time duration) [member function]

    cls.add_method('NavReset', 

                   'void', 

                   [param('ns3::Time', 'duration')], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowDcfListener::AckTimeoutStart(ns3::Time duration) [member function]

    cls.add_method('AckTimeoutStart', 

                   'void', 

                   [param('ns3::Time', 'duration')], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowDcfListener::AckTimeoutReset() [member function]

    cls.add_method('AckTimeoutReset', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowDcfListener::CtsTimeoutStart(ns3::Time duration) [member function]

    cls.add_method('CtsTimeoutStart', 

                   'void', 

                   [param('ns3::Time', 'duration')], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowDcfListener::CtsTimeoutReset() [member function]

    cls.add_method('CtsTimeoutReset', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    return

def register_Ns3MacLowTransmissionListener_methods(root_module, cls):

    ## mac-low.h: ns3::MacLowTransmissionListener::MacLowTransmissionListener(ns3::MacLowTransmissionListener const & arg0) [copy constructor]

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

    ## mac-low.h: ns3::MacLowTransmissionListener::MacLowTransmissionListener() [constructor]

    cls.add_constructor([])

    ## mac-low.h: void ns3::MacLowTransmissionListener::GotCts(double snr, ns3::WifiMode txMode) [member function]

    cls.add_method('GotCts', 

                   'void', 

                   [param('double', 'snr'), param('ns3::WifiMode', 'txMode')], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowTransmissionListener::MissedCts() [member function]

    cls.add_method('MissedCts', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowTransmissionListener::GotAck(double snr, ns3::WifiMode txMode) [member function]

    cls.add_method('GotAck', 

                   'void', 

                   [param('double', 'snr'), param('ns3::WifiMode', 'txMode')], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowTransmissionListener::MissedAck() [member function]

    cls.add_method('MissedAck', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowTransmissionListener::StartNext() [member function]

    cls.add_method('StartNext', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    ## mac-low.h: void ns3::MacLowTransmissionListener::Cancel() [member function]

    cls.add_method('Cancel', 

                   'void', 

                   [], 

                   is_pure_virtual=True, is_virtual=True)

    return

def register_Ns3MacLowTransmissionParameters_methods(root_module, cls):

    cls.add_output_stream_operator()

    ## mac-low.h: ns3::MacLowTransmissionParameters::MacLowTransmissionParameters(ns3::MacLowTransmissionParameters const & arg0) [copy constructor]

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

    ## mac-low.h: ns3::MacLowTransmissionParameters::MacLowTransmissionParameters() [constructor]

    cls.add_constructor([])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::DisableAck() [member function]

    cls.add_method('DisableAck', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::DisableNextData() [member function]

    cls.add_method('DisableNextData', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::DisableOverrideDurationId() [member function]

    cls.add_method('DisableOverrideDurationId', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::DisableRts() [member function]

    cls.add_method('DisableRts', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::EnableAck() [member function]

    cls.add_method('EnableAck', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::EnableFastAck() [member function]

    cls.add_method('EnableFastAck', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::EnableNextData(uint32_t size) [member function]

    cls.add_method('EnableNextData', 

                   'void', 

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

    ## mac-low.h: void ns3::MacLowTransmissionParameters::EnableOverrideDurationId(ns3::Time durationId) [member function]

    cls.add_method('EnableOverrideDurationId', 

                   'void', 

                   [param('ns3::Time', 'durationId')])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::EnableRts() [member function]

    cls.add_method('EnableRts', 

                   'void', 

                   [])

    ## mac-low.h: void ns3::MacLowTransmissionParameters::EnableSuperFastAck() [member function]

    cls.add_method('EnableSuperFastAck', 

                   'void', 

                   [])

    ## mac-low.h: ns3::Time ns3::MacLowTransmissionParameters::GetDurationId() const [member function]

    cls.add_method('GetDurationId', 

                   'ns3::Time', 

                   [], 

                   is_const=True)

    ## mac-low.h: uint32_t ns3::MacLowTransmissionParameters::GetNextPacketSize() const [member function]

    cls.add_method('GetNextPacketSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::HasDurationId() const [member function]

    cls.add_method('HasDurationId', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::HasNextPacket() const [member function]

    cls.add_method('HasNextPacket', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::MustSendRts() const [member function]

    cls.add_method('MustSendRts', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::MustWaitAck() const [member function]

    cls.add_method('MustWaitAck', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::MustWaitFastAck() const [member function]

    cls.add_method('MustWaitFastAck', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::MustWaitNormalAck() const [member function]

    cls.add_method('MustWaitNormalAck', 

                   'bool', 

                   [], 

                   is_const=True)

    ## mac-low.h: bool ns3::MacLowTransmissionParameters::MustWaitSuperFastAck() const [member function]

    cls.add_method('MustWaitSuperFastAck', 

                   'bool', 

                   [], 

                   is_const=True)

    return

def register_Ns3MacRxMiddle_methods(root_module, cls):

    ## mac-rx-middle.h: ns3::MacRxMiddle::MacRxMiddle(ns3::MacRxMiddle const & arg0) [copy constructor]

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

    ## mac-rx-middle.h: ns3::MacRxMiddle::MacRxMiddle() [constructor]

    cls.add_constructor([])

    ## mac-rx-middle.h: void ns3::MacRxMiddle::SetForwardCallback(ns3::Callback<void, ns3::Ptr<ns3::Packet>, ns3::WifiMacHeader const*, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty> callback) [member function]

    cls.add_method('SetForwardCallback', 

                   'void', 

                   [param('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::WifiMacHeader const *, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'callback')])

    ## mac-rx-middle.h: void ns3::MacRxMiddle::Receive(ns3::Ptr<ns3::Packet> packet, ns3::WifiMacHeader const * hdr) [member function]

    cls.add_method('Receive', 

                   'void', 

                   [param('ns3::Ptr< ns3::Packet >', 'packet'), param('ns3::WifiMacHeader const *', 'hdr')])

    return

def register_Ns3RateInfo_methods(root_module, cls):

    ## minstrel-wifi-manager.h: ns3::RateInfo::perfectTxTime [variable]

    cls.add_instance_attribute('perfectTxTime', 'ns3::Time', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::retryCount [variable]

    cls.add_instance_attribute('retryCount', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::adjustedRetryCount [variable]

    cls.add_instance_attribute('adjustedRetryCount', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::numRateAttempt [variable]

    cls.add_instance_attribute('numRateAttempt', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::numRateSuccess [variable]

    cls.add_instance_attribute('numRateSuccess', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::prob [variable]

    cls.add_instance_attribute('prob', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::ewmaProb [variable]

    cls.add_instance_attribute('ewmaProb', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::prevNumRateAttempt [variable]

    cls.add_instance_attribute('prevNumRateAttempt', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::prevNumRateSuccess [variable]

    cls.add_instance_attribute('prevNumRateSuccess', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::successHist [variable]

    cls.add_instance_attribute('successHist', 'uint64_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::attemptHist [variable]

    cls.add_instance_attribute('attemptHist', 'uint64_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::throughput [variable]

    cls.add_instance_attribute('throughput', 'uint32_t', is_const=False)

    ## minstrel-wifi-manager.h: ns3::RateInfo::RateInfo(ns3::RateInfo const & arg0) [copy constructor]

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

    ## minstrel-wifi-manager.h: ns3::RateInfo::RateInfo() [constructor]

    cls.add_constructor([])

    return

def register_Ns3Ssid_methods(root_module, cls):

    cls.add_output_stream_operator()

    ## ssid.h: ns3::Ssid::Ssid(ns3::Ssid const & arg0) [copy constructor]

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

    ## ssid.h: ns3::Ssid::Ssid() [constructor]

    cls.add_constructor([])

    ## ssid.h: ns3::Ssid::Ssid(std::string s) [constructor]

    cls.add_constructor([param('std::string', 's')])

    ## ssid.h: ns3::Ssid::Ssid(char const * ssid, uint8_t length) [constructor]

    cls.add_constructor([param('char const *', 'ssid'), param('uint8_t', 'length')])

    ## ssid.h: ns3::Buffer::Iterator ns3::Ssid::Deserialize(ns3::Buffer::Iterator i) [member function]

    cls.add_method('Deserialize', 

                   'ns3::Buffer::Iterator', 

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

    ## ssid.h: uint32_t ns3::Ssid::GetLength() const [member function]

    cls.add_method('GetLength', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## ssid.h: uint32_t ns3::Ssid::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## ssid.h: bool ns3::Ssid::IsBroadcast() const [member function]

    cls.add_method('IsBroadcast', 

                   'bool', 

                   [], 

                   is_const=True)

    ## ssid.h: bool ns3::Ssid::IsEqual(ns3::Ssid const & o) const [member function]

    cls.add_method('IsEqual', 

                   'bool', 

                   [param('ns3::Ssid const &', 'o')], 

                   is_const=True)

    ## ssid.h: char * ns3::Ssid::PeekString() const [member function]

    cls.add_method('PeekString', 

                   'char *', 

                   [], 

                   is_const=True)

    ## ssid.h: ns3::Buffer::Iterator ns3::Ssid::Serialize(ns3::Buffer::Iterator i) const [member function]

    cls.add_method('Serialize', 

                   'ns3::Buffer::Iterator', 

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

                   is_const=True)

    return

def register_Ns3StatusCode_methods(root_module, cls):

    cls.add_output_stream_operator()

    ## status-code.h: ns3::StatusCode::StatusCode(ns3::StatusCode const & arg0) [copy constructor]

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

    ## status-code.h: ns3::StatusCode::StatusCode() [constructor]

    cls.add_constructor([])

    ## status-code.h: ns3::Buffer::Iterator ns3::StatusCode::Deserialize(ns3::Buffer::Iterator start) [member function]

    cls.add_method('Deserialize', 

                   'ns3::Buffer::Iterator', 

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

    ## status-code.h: uint32_t ns3::StatusCode::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## status-code.h: bool ns3::StatusCode::IsSuccess() const [member function]

    cls.add_method('IsSuccess', 

                   'bool', 

                   [], 

                   is_const=True)

    ## status-code.h: ns3::Buffer::Iterator ns3::StatusCode::Serialize(ns3::Buffer::Iterator start) const [member function]

    cls.add_method('Serialize', 

                   'ns3::Buffer::Iterator', 

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

                   is_const=True)

    ## status-code.h: void ns3::StatusCode::SetFailure() [member function]

    cls.add_method('SetFailure', 

                   'void', 

                   [])

    ## status-code.h: void ns3::StatusCode::SetSuccess() [member function]

    cls.add_method('SetSuccess', 

                   'void', 

                   [])

    return

def register_Ns3SupportedRates_methods(root_module, cls):

    cls.add_output_stream_operator()

    ## supported-rates.h: ns3::SupportedRates::SupportedRates(ns3::SupportedRates const & arg0) [copy constructor]

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

    ## supported-rates.h: ns3::SupportedRates::SupportedRates() [constructor]

    cls.add_constructor([])

    ## supported-rates.h: void ns3::SupportedRates::AddSupportedRate(uint32_t bs) [member function]

    cls.add_method('AddSupportedRate', 

                   'void', 

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

    ## supported-rates.h: ns3::Buffer::Iterator ns3::SupportedRates::Deserialize(ns3::Buffer::Iterator start) [member function]

    cls.add_method('Deserialize', 

                   'ns3::Buffer::Iterator', 

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

    ## supported-rates.h: uint8_t ns3::SupportedRates::GetNRates() const [member function]

    cls.add_method('GetNRates', 

                   'uint8_t', 

                   [], 

                   is_const=True)

    ## supported-rates.h: uint32_t ns3::SupportedRates::GetRate(uint8_t i) const [member function]

    cls.add_method('GetRate', 

                   'uint32_t', 

                   [param('uint8_t', 'i')], 

                   is_const=True)

    ## supported-rates.h: uint32_t ns3::SupportedRates::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## supported-rates.h: bool ns3::SupportedRates::IsBasicRate(uint32_t bs) const [member function]

    cls.add_method('IsBasicRate', 

                   'bool', 

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

                   is_const=True)

    ## supported-rates.h: bool ns3::SupportedRates::IsSupportedRate(uint32_t bs) const [member function]

    cls.add_method('IsSupportedRate', 

                   'bool', 

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

                   is_const=True)

    ## supported-rates.h: ns3::Buffer::Iterator ns3::SupportedRates::Serialize(ns3::Buffer::Iterator start) const [member function]

    cls.add_method('Serialize', 

                   'ns3::Buffer::Iterator', 

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

                   is_const=True)

    ## supported-rates.h: void ns3::SupportedRates::SetBasicRate(uint32_t bs) [member function]

    cls.add_method('SetBasicRate', 

                   'void', 

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

    return

def register_Ns3ThresholdsItem_methods(root_module, cls):

    ## rraa-wifi-manager.h: ns3::ThresholdsItem::datarate [variable]

    cls.add_instance_attribute('datarate', 'uint32_t', is_const=False)

    ## rraa-wifi-manager.h: ns3::ThresholdsItem::pori [variable]

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

    ## rraa-wifi-manager.h: ns3::ThresholdsItem::pmtl [variable]

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

    ## rraa-wifi-manager.h: ns3::ThresholdsItem::ewnd [variable]

    cls.add_instance_attribute('ewnd', 'uint32_t', is_const=False)

    ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem(ns3::ThresholdsItem const & arg0) [copy constructor]

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

    ## rraa-wifi-manager.h: ns3::ThresholdsItem::ThresholdsItem() [constructor]

    cls.add_constructor([])

    return

def register_Ns3WifiMode_methods(root_module, cls):

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## wifi-mode.h: ns3::WifiMode::WifiMode(ns3::WifiMode const & arg0) [copy constructor]

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

    ## wifi-mode.h: ns3::WifiMode::WifiMode() [constructor]

    cls.add_constructor([])

    ## wifi-mode.h: ns3::WifiMode::WifiMode(std::string name) [constructor]

    cls.add_constructor([param('std::string', 'name')])

    ## wifi-mode.h: uint32_t ns3::WifiMode::GetBandwidth() const [member function]

    cls.add_method('GetBandwidth', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: uint8_t ns3::WifiMode::GetConstellationSize() const [member function]

    cls.add_method('GetConstellationSize', 

                   'uint8_t', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: uint32_t ns3::WifiMode::GetDataRate() const [member function]

    cls.add_method('GetDataRate', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: ns3::WifiMode::ModulationType ns3::WifiMode::GetModulationType() const [member function]

    cls.add_method('GetModulationType', 

                   'ns3::WifiMode::ModulationType', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: uint32_t ns3::WifiMode::GetPhyRate() const [member function]

    cls.add_method('GetPhyRate', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: ns3::WifiPhyStandard ns3::WifiMode::GetStandard() const [member function]

    cls.add_method('GetStandard', 

                   'ns3::WifiPhyStandard', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: uint32_t ns3::WifiMode::GetUid() const [member function]

    cls.add_method('GetUid', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: std::string ns3::WifiMode::GetUniqueName() const [member function]

    cls.add_method('GetUniqueName', 

                   'std::string', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: bool ns3::WifiMode::IsMandatory() const [member function]

    cls.add_method('IsMandatory', 

                   'bool', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: bool ns3::WifiMode::IsModulationBpsk() const [member function]

    cls.add_method('IsModulationBpsk', 

                   'bool', 

                   [], 

                   is_const=True)

    ## wifi-mode.h: bool ns3::WifiMode::IsModulationQam() const [member function]

    cls.add_method('IsModulationQam',