from pybindgen import Module, FileCodeSink, write_preamble, param, retval

def register_types(module):

    root_module = module.get_root()

    ## 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_holland'])

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

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

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

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

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

    module.add_class('ThresholdsItem')

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

    module.add_class('SupportedRates')

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

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

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

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

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

    module.add_class('WifiModeFactory')

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

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

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

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

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

    module.add_class('Ssid')

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

    module.add_class('WifiMode')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    module.add_class('CompositePropagationLossModel', allow_subclassing=True, parent=root_module['ns3::PropagationLossModel'])

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

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

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

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

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

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

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

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

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

    module.add_class('WifiPhy', allow_subclassing=True, 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-channel.h: ns3::WifiChannel [class]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    nested_module = module.add_cpp_namespace('TimeStepPrecision')

    register_types_ns3_TimeStepPrecision(nested_module)

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

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_TimeStepPrecision(module):

    root_module = module.get_root()

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    register_Ns3CompositePropagationLossModel_methods(root_module, root_module['ns3::CompositePropagationLossModel'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return

def register_Ns3WifiRemoteStation_methods(root_module, cls):

    ## wifi-remote-station-manager.h: static ns3::TypeId ns3::WifiRemoteStation::GetTypeId() [member function]

    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)

    ## wifi-remote-station-manager.h: ns3::WifiRemoteStation::WifiRemoteStation() [constructor]

    cls.add_constructor([], visibility='public')

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::Reset() [member function]

    cls.add_method('Reset', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::AddSupportedMode(ns3::WifiMode mode) [member function]

    cls.add_method('AddSupportedMode', 'void', [param('ns3::WifiMode', 'mode')])

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsBrandNew() const [member function]

    cls.add_method('IsBrandNew', 'bool', [], is_const=True)

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsAssociated() const [member function]

    cls.add_method('IsAssociated', 'bool', [], is_const=True)

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsWaitAssocTxOk() const [member function]

    cls.add_method('IsWaitAssocTxOk', 'bool', [], is_const=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordWaitAssocTxOk() [member function]

    cls.add_method('RecordWaitAssocTxOk', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordGotAssocTxOk() [member function]

    cls.add_method('RecordGotAssocTxOk', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordGotAssocTxFailed() [member function]

    cls.add_method('RecordGotAssocTxFailed', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::RecordDisassociated() [member function]

    cls.add_method('RecordDisassociated', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::PrepareForQueue(ns3::Ptr<const ns3::Packet> packet, uint32_t fullPacketSize) [member function]

    cls.add_method('PrepareForQueue', 'void', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fullPacketSize')])

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetDataMode(ns3::Ptr<const ns3::Packet> packet, uint32_t fullPacketSize) [member function]

    cls.add_method('GetDataMode', 'ns3::WifiMode', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fullPacketSize')])

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetRtsMode(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('GetRtsMode', 'ns3::WifiMode', [param('ns3::Ptr< const ns3::Packet >', 'packet')])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportRtsFailed() [member function]

    cls.add_method('ReportRtsFailed', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportDataFailed() [member function]

    cls.add_method('ReportDataFailed', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]

    cls.add_method('ReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function]

    cls.add_method('ReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportFinalRtsFailed() [member function]

    cls.add_method('ReportFinalRtsFailed', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportFinalDataFailed() [member function]

    cls.add_method('ReportFinalDataFailed', 'void', [])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::ReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('ReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')])

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedRts(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('NeedRts', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True)

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedRtsRetransmission(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('NeedRtsRetransmission', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True)

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedDataRetransmission(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('NeedDataRetransmission', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True)

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::NeedFragmentation(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('NeedFragmentation', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True)

    ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStation::GetNFragments(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('GetNFragments', 'uint32_t', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True)

    ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStation::GetFragmentSize(ns3::Ptr<const ns3::Packet> packet, uint32_t fragmentNumber) [member function]

    cls.add_method('GetFragmentSize', 'uint32_t', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fragmentNumber')], is_virtual=True)

    ## wifi-remote-station-manager.h: bool ns3::WifiRemoteStation::IsLastFragment(ns3::Ptr<const ns3::Packet> packet, uint32_t fragmentNumber) [member function]

    cls.add_method('IsLastFragment', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet'), param('uint32_t', 'fragmentNumber')], is_virtual=True)

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetCtsMode(ns3::WifiMode rtsMode) [member function]

    cls.add_method('GetCtsMode', 'ns3::WifiMode', [param('ns3::WifiMode', 'rtsMode')])

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetAckMode(ns3::WifiMode dataMode) [member function]

    cls.add_method('GetAckMode', 'ns3::WifiMode', [param('ns3::WifiMode', 'dataMode')])

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportRtsFailed() [member function]

    cls.add_method('DoReportRtsFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportDataFailed() [member function]

    cls.add_method('DoReportDataFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]

    cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function]

    cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportFinalRtsFailed() [member function]

    cls.add_method('DoReportFinalRtsFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportFinalDataFailed() [member function]

    cls.add_method('DoReportFinalDataFailed', 'void', [], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: void ns3::WifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], is_pure_virtual=True, visibility='protected', is_virtual=True)

    ## wifi-remote-station-manager.h: uint32_t ns3::WifiRemoteStation::GetNSupportedModes() const [member function]

    cls.add_method('GetNSupportedModes', 'uint32_t', [], is_const=True, visibility='protected')

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::GetSupportedMode(uint32_t i) const [member function]

    cls.add_method('GetSupportedMode', 'ns3::WifiMode', [param('uint32_t', 'i')], is_const=True, visibility='protected')

    ## wifi-remote-station-manager.h: ns3::Ptr<ns3::WifiRemoteStationManager> ns3::WifiRemoteStation::GetManager() const [member function]

    cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_pure_virtual=True, is_const=True, visibility='private', is_virtual=True)

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::DoGetDataMode(uint32_t size) [member function]

    cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], is_pure_virtual=True, visibility='private', is_virtual=True)

    ## wifi-remote-station-manager.h: ns3::WifiMode ns3::WifiRemoteStation::DoGetRtsMode() [member function]

    cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], is_pure_virtual=True, visibility='private', is_virtual=True)

    return

def register_Ns3WifiPhyListener_methods(root_module, cls):

    ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxStart(ns3::Time duration) [member function]

    cls.add_method('NotifyRxStart', 'void', [param('ns3::Time', 'duration')], is_pure_virtual=True, is_virtual=True)

    ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxEndOk() [member function]

    cls.add_method('NotifyRxEndOk', 'void', [], is_pure_virtual=True, is_virtual=True)

    ## wifi-phy.h: void ns3::WifiPhyListener::NotifyRxEndError() [member function]

    cls.add_method('NotifyRxEndError', 'void', [], is_pure_virtual=True, is_virtual=True)

    ## wifi-phy.h: void ns3::WifiPhyListener::NotifyTxStart(ns3::Time duration) [member function]

    cls.add_method('NotifyTxStart', 'void', [param('ns3::Time', 'duration')], is_pure_virtual=True, is_virtual=True)

    ## wifi-phy.h: void ns3::WifiPhyListener::NotifyCcaBusyStart(ns3::Time duration) [member function]

    cls.add_method('NotifyCcaBusyStart', 'void', [param('ns3::Time', 'duration')], is_pure_virtual=True, is_virtual=True)

    cls.add_constructor([])

    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)

    cls.add_constructor([])

    return

def register_Ns3SupportedRates_methods(root_module, cls):

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

    cls.add_constructor([param('ns3::SupportedRates&', 'arg0', is_const=True)], visibility='public')

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

    cls.add_constructor([], visibility='public')

    ## 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')])

    cls.add_output_stream_operator()

    return

def register_Ns3IdealWifiRemoteStation_methods(root_module, cls):

    ## ideal-wifi-manager.h: ns3::IdealWifiRemoteStation::IdealWifiRemoteStation(ns3::Ptr<ns3::IdealWifiManager> stations) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::IdealWifiManager >', 'stations')], visibility='public')

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRtsFailed() [member function]

    cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportDataFailed() [member function]

    cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]

    cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function]

    cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportFinalRtsFailed() [member function]

    cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: void ns3::IdealWifiRemoteStation::DoReportFinalDataFailed() [member function]

    cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## ideal-wifi-manager.h: ns3::Ptr<ns3::WifiRemoteStationManager> ns3::IdealWifiRemoteStation::GetManager() const [member function]

    cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True)

    ## ideal-wifi-manager.h: ns3::WifiMode ns3::IdealWifiRemoteStation::DoGetDataMode(uint32_t size) [member function]

    cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True)

    ## ideal-wifi-manager.h: ns3::WifiMode ns3::IdealWifiRemoteStation::DoGetRtsMode() [member function]

    cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True)

    return

def register_Ns3WifiModeChecker_methods(root_module, cls):

    cls.add_constructor([])

    return

def register_Ns3WifiModeFactory_methods(root_module, cls):

    ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateBpsk(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate) [member function]

    cls.add_method('CreateBpsk', 'ns3::WifiMode', [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate')], is_static=True)

    ## wifi-mode.h: static ns3::WifiMode ns3::WifiModeFactory::CreateQam(std::string uniqueName, bool isMandatory, uint32_t bandwidth, uint32_t dataRate, uint32_t phyRate, uint8_t constellationSize) [member function]

    cls.add_method('CreateQam', 'ns3::WifiMode', [param('std::string', 'uniqueName'), param('bool', 'isMandatory'), param('uint32_t', 'bandwidth'), param('uint32_t', 'dataRate'), param('uint32_t', 'phyRate'), param('uint8_t', 'constellationSize')], is_static=True)

    return

def register_Ns3OnoeWifiRemoteStation_methods(root_module, cls):

    ## onoe-wifi-manager.h: ns3::OnoeWifiRemoteStation::OnoeWifiRemoteStation(ns3::Ptr<ns3::OnoeWifiManager> stations) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::OnoeWifiManager >', 'stations')], visibility='public')

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRtsFailed() [member function]

    cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportDataFailed() [member function]

    cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]

    cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function]

    cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportFinalRtsFailed() [member function]

    cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: void ns3::OnoeWifiRemoteStation::DoReportFinalDataFailed() [member function]

    cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## onoe-wifi-manager.h: ns3::Ptr<ns3::WifiRemoteStationManager> ns3::OnoeWifiRemoteStation::GetManager() const [member function]

    cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True)

    ## onoe-wifi-manager.h: ns3::WifiMode ns3::OnoeWifiRemoteStation::DoGetDataMode(uint32_t size) [member function]

    cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True)

    ## onoe-wifi-manager.h: ns3::WifiMode ns3::OnoeWifiRemoteStation::DoGetRtsMode() [member function]

    cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True)

    return

def register_Ns3RraaWifiRemoteStation_methods(root_module, cls):

    ## rraa-wifi-manager.h: ns3::RraaWifiRemoteStation::RraaWifiRemoteStation(ns3::Ptr<ns3::RraaWifiManager> stations) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::RraaWifiManager >', 'stations')], visibility='public')

    ## rraa-wifi-manager.h: bool ns3::RraaWifiRemoteStation::NeedRts(ns3::Ptr<const ns3::Packet> packet) [member function]

    cls.add_method('NeedRts', 'bool', [param('ns3::Ptr< const ns3::Packet >', 'packet')], is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportRtsFailed() [member function]

    cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportDataFailed() [member function]

    cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]

    cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function]

    cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportFinalRtsFailed() [member function]

    cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: void ns3::RraaWifiRemoteStation::DoReportFinalDataFailed() [member function]

    cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## rraa-wifi-manager.h: ns3::Ptr<ns3::WifiRemoteStationManager> ns3::RraaWifiRemoteStation::GetManager() const [member function]

    cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True)

    ## rraa-wifi-manager.h: ns3::WifiMode ns3::RraaWifiRemoteStation::DoGetDataMode(uint32_t size) [member function]

    cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True)

    ## rraa-wifi-manager.h: ns3::WifiMode ns3::RraaWifiRemoteStation::DoGetRtsMode() [member function]

    cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True)

    return

def register_Ns3Ssid_methods(root_module, cls):

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

    cls.add_constructor([param('ns3::Ssid&', 'arg0', is_const=True)], visibility='public')

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

    cls.add_constructor([], visibility='public')

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

    cls.add_constructor([param('char *', 'ssid', transfer_ownership=False, is_const=True)], visibility='public')

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

    cls.add_constructor([param('char *', 'ssid', transfer_ownership=False, is_const=True), param('uint8_t', 'length')], visibility='public')

    ## 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&', 'o', is_const=True)], 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)

    cls.add_output_stream_operator()

    return

def register_Ns3WifiMode_methods(root_module, cls):

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

    cls.add_constructor([param('ns3::WifiMode&', 'arg0', is_const=True)], visibility='public')

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

    cls.add_constructor([], visibility='public')

    ## 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: 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', 'bool', [], is_const=True)

    cls.add_output_stream_operator()

    return

def register_Ns3SsidValue_methods(root_module, cls):

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

    cls.add_constructor([], visibility='public')

    ## ssid.h: ns3::SsidValue::SsidValue(ns3::Ssid const & value) [constructor]

    cls.add_constructor([param('ns3::Ssid&', 'value', is_const=True)], visibility='public')

    ## ssid.h: void ns3::SsidValue::Set(ns3::Ssid const & value) [member function]

    cls.add_method('Set', 'void', [param('ns3::Ssid&', 'value', is_const=True)])

    ## ssid.h: ns3::Ssid ns3::SsidValue::Get() const [member function]

    cls.add_method('Get', 'ns3::Ssid', [], is_const=True)

    ## ssid.h: ns3::Ptr<ns3::AttributeValue> ns3::SsidValue::Copy() const [member function]

    cls.add_method('Copy', 'ns3::Ptr< ns3::AttributeValue >', [], is_const=True, is_virtual=True)

    ## ssid.h: std::string ns3::SsidValue::SerializeToString(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

    cls.add_method('SerializeToString', 'std::string', [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_const=True, is_virtual=True)

    ## ssid.h: bool ns3::SsidValue::DeserializeFromString(std::string value, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

    cls.add_method('DeserializeFromString', 'bool', [param('std::string', 'value'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], is_virtual=True)

    return

def register_Ns3SsidChecker_methods(root_module, cls):

    cls.add_constructor([])

    return

def register_Ns3ConstantRateWifiRemoteStation_methods(root_module, cls):

    ## constant-rate-wifi-manager.h: ns3::ConstantRateWifiRemoteStation::ConstantRateWifiRemoteStation(ns3::Ptr<ns3::ConstantRateWifiManager> stations) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::ConstantRateWifiManager >', 'stations')], visibility='public')

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRtsFailed() [member function]

    cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportDataFailed() [member function]

    cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]

    cls.add_method('DoReportRtsOk', 'void', [param('double', 'ctsSnr'), param('ns3::WifiMode', 'ctsMode'), param('double', 'rtsSnr')], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportDataOk(double ackSnr, ns3::WifiMode ackMode, double dataSnr) [member function]

    cls.add_method('DoReportDataOk', 'void', [param('double', 'ackSnr'), param('ns3::WifiMode', 'ackMode'), param('double', 'dataSnr')], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportFinalRtsFailed() [member function]

    cls.add_method('DoReportFinalRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: void ns3::ConstantRateWifiRemoteStation::DoReportFinalDataFailed() [member function]

    cls.add_method('DoReportFinalDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## constant-rate-wifi-manager.h: ns3::Ptr<ns3::WifiRemoteStationManager> ns3::ConstantRateWifiRemoteStation::GetManager() const [member function]

    cls.add_method('GetManager', 'ns3::Ptr< ns3::WifiRemoteStationManager >', [], is_const=True, visibility='private', is_virtual=True)

    ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiRemoteStation::DoGetDataMode(uint32_t size) [member function]

    cls.add_method('DoGetDataMode', 'ns3::WifiMode', [param('uint32_t', 'size')], visibility='private', is_virtual=True)

    ## constant-rate-wifi-manager.h: ns3::WifiMode ns3::ConstantRateWifiRemoteStation::DoGetRtsMode() [member function]

    cls.add_method('DoGetRtsMode', 'ns3::WifiMode', [], visibility='private', is_virtual=True)

    return

def register_Ns3PropagationLossModel_methods(root_module, cls):

    ## propagation-loss-model.h: static ns3::TypeId ns3::PropagationLossModel::GetTypeId() [member function]

    cls.add_method('GetTypeId', 'ns3::TypeId', [], is_static=True)

    ## propagation-loss-model.h: double ns3::PropagationLossModel::GetLoss(ns3::Ptr<ns3::MobilityModel> a, ns3::Ptr<ns3::MobilityModel> b) const [member function]

    cls.add_method('GetLoss', 'double', [param('ns3::Ptr< ns3::MobilityModel >', 'a'), param('ns3::Ptr< ns3::MobilityModel >', 'b')], is_pure_virtual=True, is_const=True, is_virtual=True)

    cls.add_constructor([])

    return

def register_Ns3ArfWifiRemoteStation_methods(root_module, cls):

    ## arf-wifi-manager.h: ns3::ArfWifiRemoteStation::ArfWifiRemoteStation(ns3::Ptr<ns3::ArfWifiManager> stations, int minTimerTimeout, int minSuccessThreshold) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::ArfWifiManager >', 'stations'), param('int', 'minTimerTimeout'), param('int', 'minSuccessThreshold')], visibility='public')

    ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRxOk(double rxSnr, ns3::WifiMode txMode) [member function]

    cls.add_method('DoReportRxOk', 'void', [param('double', 'rxSnr'), param('ns3::WifiMode', 'txMode')], visibility='protected', is_virtual=True)

    ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRtsFailed() [member function]

    cls.add_method('DoReportRtsFailed', 'void', [], visibility='protected', is_virtual=True)

    ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportDataFailed() [member function]

    cls.add_method('DoReportDataFailed', 'void', [], visibility='protected', is_virtual=True)

    ## arf-wifi-manager.h: void ns3::ArfWifiRemoteStation::DoReportRtsOk(double ctsSnr, ns3::WifiMode ctsMode, double rtsSnr) [member function]