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

def register_types(module):

    root_module = module.get_root()

    ## packetbb.h: ns3::PbbAddressLength [enumeration]

    module.add_enum('PbbAddressLength', ['IPV4', 'IPV6'])

    ## ethernet-header.h: ns3::ethernet_header_t [enumeration]

    module.add_enum('ethernet_header_t', ['LENGTH', 'VLAN', 'QINQ'])

    ## address.h: ns3::Address [class]

    module.add_class('Address')

    ## address.h: ns3::Address::MaxSize_e [enumeration]

    module.add_enum('MaxSize_e', ['MAX_SIZE'], outer_class=root_module['ns3::Address'])

    ## channel-list.h: ns3::ChannelList [class]

    module.add_class('ChannelList')

    ## inet6-socket-address.h: ns3::Inet6SocketAddress [class]

    module.add_class('Inet6SocketAddress')

    ## inet6-socket-address.h: ns3::Inet6SocketAddress [class]

    root_module['ns3::Inet6SocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    ## inet-socket-address.h: ns3::InetSocketAddress [class]

    module.add_class('InetSocketAddress')

    ## inet-socket-address.h: ns3::InetSocketAddress [class]

    root_module['ns3::InetSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv4-address.h: ns3::Ipv4Address [class]

    module.add_class('Ipv4Address')

    ## ipv4-address.h: ns3::Ipv4Address [class]

    root_module['ns3::Ipv4Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv4-address-generator.h: ns3::Ipv4AddressGenerator [class]

    module.add_class('Ipv4AddressGenerator')

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress [class]

    module.add_class('Ipv4InterfaceAddress')

    ## ipv4-interface-address.h: ns3::Ipv4InterfaceAddress::InterfaceAddressScope_e [enumeration]

    module.add_enum('InterfaceAddressScope_e', ['HOST', 'LINK', 'GLOBAL'], outer_class=root_module['ns3::Ipv4InterfaceAddress'])

    ## ipv4-address.h: ns3::Ipv4Mask [class]

    module.add_class('Ipv4Mask')

    ## ipv6-address.h: ns3::Ipv6Address [class]

    module.add_class('Ipv6Address')

    ## ipv6-address.h: ns3::Ipv6Address [class]

    root_module['ns3::Ipv6Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## ipv6-interface-address.h: ns3::Ipv6InterfaceAddress [class]

    module.add_class('Ipv6InterfaceAddress')

    ## ipv6-interface-address.h: ns3::Ipv6InterfaceAddress::State_e [enumeration]

    module.add_enum('State_e', ['TENTATIVE', 'DEPRECATED', 'PREFERRED', 'PERMANENT', 'HOMEADDRESS', 'TENTATIVE_OPTIMISTIC', 'INVALID'], outer_class=root_module['ns3::Ipv6InterfaceAddress'])

    ## ipv6-interface-address.h: ns3::Ipv6InterfaceAddress::Scope_e [enumeration]

    module.add_enum('Scope_e', ['HOST', 'LINKLOCAL', 'GLOBAL'], outer_class=root_module['ns3::Ipv6InterfaceAddress'])

    ## ipv6-address.h: ns3::Ipv6Prefix [class]

    module.add_class('Ipv6Prefix')

    ## mac48-address.h: ns3::Mac48Address [class]

    module.add_class('Mac48Address')

    ## mac48-address.h: ns3::Mac48Address [class]

    root_module['ns3::Mac48Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## mac64-address.h: ns3::Mac64Address [class]

    module.add_class('Mac64Address')

    ## mac64-address.h: ns3::Mac64Address [class]

    root_module['ns3::Mac64Address'].implicitly_converts_to(root_module['ns3::Address'])

    ## node-list.h: ns3::NodeList [class]

    module.add_class('NodeList')

    ## packet-socket-address.h: ns3::PacketSocketAddress [class]

    module.add_class('PacketSocketAddress')

    ## packet-socket-address.h: ns3::PacketSocketAddress [class]

    root_module['ns3::PacketSocketAddress'].implicitly_converts_to(root_module['ns3::Address'])

    ## packetbb.h: ns3::PbbAddressTlvBlock [class]

    module.add_class('PbbAddressTlvBlock')

    ## packetbb.h: ns3::PbbTlvBlock [class]

    module.add_class('PbbTlvBlock')

    ## ipv4-header.h: ns3::Ipv4Header [class]

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

    ## ipv4-packet-info-tag.h: ns3::Ipv4PacketInfoTag [class]

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

    ## ipv6-header.h: ns3::Ipv6Header [class]

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

    ## ipv6-header.h: ns3::Ipv6Header::NextHeader_e [enumeration]

    module.add_enum('NextHeader_e', ['IPV6_EXT_HOP_BY_HOP', 'IPV6_IPV4', 'IPV6_TCP', 'IPV6_UDP', 'IPV6_IPV6', 'IPV6_EXT_ROUTING', 'IPV6_EXT_FRAGMENTATION', 'IPV6_EXT_CONFIDENTIALITY', 'IPV6_EXT_AUTHENTIFICATION', 'IPV6_ICMPV6', 'IPV6_EXT_END', 'IPV6_EXT_DESTINATION', 'IPV6_SCTP', 'IPV6_EXT_MOBILITY', 'IPV6_UDP_LITE'], outer_class=root_module['ns3::Ipv6Header'])

    ## ipv6-packet-info-tag.h: ns3::Ipv6PacketInfoTag [class]

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

    ## llc-snap-header.h: ns3::LlcSnapHeader [class]

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

    ## queue.h: ns3::Queue [class]

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

    ## radiotap-header.h: ns3::RadiotapHeader [class]

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

    ## radiotap-header.h: ns3::RadiotapHeader [enumeration]

    module.add_enum('', ['FRAME_FLAG_NONE', 'FRAME_FLAG_CFP', 'FRAME_FLAG_SHORT_PREAMBLE', 'FRAME_FLAG_WEP', 'FRAME_FLAG_FRAGMENTED', 'FRAME_FLAG_FCS_INCLUDED', 'FRAME_FLAG_DATA_PADDING', 'FRAME_FLAG_BAD_FCS', 'FRAME_FLAG_SHORT_GUARD'], outer_class=root_module['ns3::RadiotapHeader'])

    ## radiotap-header.h: ns3::RadiotapHeader [enumeration]

    module.add_enum('', ['CHANNEL_FLAG_NONE', 'CHANNEL_FLAG_TURBO', 'CHANNEL_FLAG_CCK', 'CHANNEL_FLAG_OFDM', 'CHANNEL_FLAG_SPECTRUM_2GHZ', 'CHANNEL_FLAG_SPECTRUM_5GHZ', 'CHANNEL_FLAG_PASSIVE', 'CHANNEL_FLAG_DYNAMIC', 'CHANNEL_FLAG_GFSK'], outer_class=root_module['ns3::RadiotapHeader'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ## socket.h: ns3::Socket [class]

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

    ## socket.h: ns3::Socket::SocketErrno [enumeration]

    module.add_enum('SocketErrno', ['ERROR_NOTERROR', 'ERROR_ISCONN', 'ERROR_NOTCONN', 'ERROR_MSGSIZE', 'ERROR_AGAIN', 'ERROR_SHUTDOWN', 'ERROR_OPNOTSUPP', 'ERROR_AFNOSUPPORT', 'ERROR_INVAL', 'ERROR_BADF', 'ERROR_NOROUTETOHOST', 'ERROR_NODEV', 'ERROR_ADDRNOTAVAIL', 'SOCKET_ERRNO_LAST'], outer_class=root_module['ns3::Socket'])

    ## socket.h: ns3::SocketAddressTag [class]

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

    ## socket-factory.h: ns3::SocketFactory [class]

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

    ## socket.h: ns3::SocketIpTtlTag [class]

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

    ## socket.h: ns3::SocketSetDontFragmentTag [class]

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

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

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

    ## tcp-socket.h: ns3::TcpSocket [class]

    module.add_class('TcpSocket', parent=root_module['ns3::Socket'])

    ## tcp-socket-factory.h: ns3::TcpSocketFactory [class]

    module.add_class('TcpSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## udp-socket.h: ns3::UdpSocket [class]

    module.add_class('UdpSocket', parent=root_module['ns3::Socket'])

    ## udp-socket-factory.h: ns3::UdpSocketFactory [class]

    module.add_class('UdpSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## application.h: ns3::Application [class]

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

    ## channel.h: ns3::Channel [class]

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

    ## drop-tail-queue.h: ns3::DropTailQueue [class]

    module.add_class('DropTailQueue', parent=root_module['ns3::Queue'])

    ## drop-tail-queue.h: ns3::DropTailQueue::Mode [enumeration]

    module.add_enum('Mode', ['ILLEGAL', 'PACKETS', 'BYTES'], outer_class=root_module['ns3::DropTailQueue'])

    ## ethernet-header.h: ns3::EthernetHeader [class]

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

    ## ethernet-trailer.h: ns3::EthernetTrailer [class]

    module.add_class('EthernetTrailer', parent=root_module['ns3::Trailer'])

    ## ipv4.h: ns3::Ipv4 [class]

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

    ## ipv4-address.h: ns3::Ipv4AddressChecker [class]

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

    ## ipv4-address.h: ns3::Ipv4AddressValue [class]

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

    ## ipv4-address.h: ns3::Ipv4MaskChecker [class]

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

    ## ipv4-address.h: ns3::Ipv4MaskValue [class]

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

    ## ipv4-route.h: ns3::Ipv4MulticastRoute [class]

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

    ## ipv4-raw-socket-factory.h: ns3::Ipv4RawSocketFactory [class]

    module.add_class('Ipv4RawSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## ipv4-route.h: ns3::Ipv4Route [class]

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

    ## ipv4-routing-protocol.h: ns3::Ipv4RoutingProtocol [class]

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

    ## ipv6.h: ns3::Ipv6 [class]

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

    ## ipv6-address.h: ns3::Ipv6AddressChecker [class]

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

    ## ipv6-address.h: ns3::Ipv6AddressValue [class]

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

    ## ipv6-route.h: ns3::Ipv6MulticastRoute [class]

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

    ## ipv6-address.h: ns3::Ipv6PrefixChecker [class]

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

    ## ipv6-address.h: ns3::Ipv6PrefixValue [class]

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

    ## ipv6-raw-socket-factory.h: ns3::Ipv6RawSocketFactory [class]

    module.add_class('Ipv6RawSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## ipv6-route.h: ns3::Ipv6Route [class]

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

    ## ipv6-routing-protocol.h: ns3::Ipv6RoutingProtocol [class]

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

    ## mac48-address.h: ns3::Mac48AddressChecker [class]

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

    ## mac48-address.h: ns3::Mac48AddressValue [class]

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

    ## net-device.h: ns3::NetDevice [class]

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

    ## net-device.h: ns3::NetDevice::PacketType [enumeration]

    module.add_enum('PacketType', ['PACKET_HOST', 'NS3_PACKET_HOST', 'PACKET_BROADCAST', 'NS3_PACKET_BROADCAST', 'PACKET_MULTICAST', 'NS3_PACKET_MULTICAST', 'PACKET_OTHERHOST', 'NS3_PACKET_OTHERHOST'], outer_class=root_module['ns3::NetDevice'])

    ## node.h: ns3::Node [class]

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

    ## packet-socket-factory.h: ns3::PacketSocketFactory [class]

    module.add_class('PacketSocketFactory', parent=root_module['ns3::SocketFactory'])

    ## packetbb.h: ns3::PbbAddressBlock [class]

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

    ## packetbb.h: ns3::PbbAddressBlockIpv4 [class]

    module.add_class('PbbAddressBlockIpv4', parent=root_module['ns3::PbbAddressBlock'])

    ## packetbb.h: ns3::PbbAddressBlockIpv6 [class]

    module.add_class('PbbAddressBlockIpv6', parent=root_module['ns3::PbbAddressBlock'])

    ## packetbb.h: ns3::PbbMessage [class]

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

    ## packetbb.h: ns3::PbbMessageIpv4 [class]

    module.add_class('PbbMessageIpv4', parent=root_module['ns3::PbbMessage'])

    ## packetbb.h: ns3::PbbMessageIpv6 [class]

    module.add_class('PbbMessageIpv6', parent=root_module['ns3::PbbMessage'])

    ## packetbb.h: ns3::PbbPacket [class]

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

    ## packetbb.h: ns3::PbbTlv [class]

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

    ## simple-channel.h: ns3::SimpleChannel [class]

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

    ## simple-net-device.h: ns3::SimpleNetDevice [class]

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

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

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

    ## address.h: ns3::AddressChecker [class]

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

    ## address.h: ns3::AddressValue [class]

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

    ## packetbb.h: ns3::PbbAddressTlv [class]

    module.add_class('PbbAddressTlv', parent=root_module['ns3::PbbTlv'])

    module.add_container('ns3::olsr::MprSet', 'ns3::Ipv4Address', container_type='set')

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

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

    typehandlers.add_type_alias('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ns3::PhyMacTxEndCallback')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', 'ns3::PhyMacTxEndCallback*')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::Ptr< ns3::Packet const >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', 'ns3::PhyMacTxEndCallback&')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ns3::PhyMacRxEndErrorCallback')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', 'ns3::PhyMacRxEndErrorCallback*')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', 'ns3::PhyMacRxEndErrorCallback&')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ns3::PhyMacRxEndOkCallback')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', 'ns3::PhyMacRxEndOkCallback*')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::Ptr< ns3::Packet >, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', 'ns3::PhyMacRxEndOkCallback&')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >', 'ns3::PhyMacRxStartCallback')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >*', 'ns3::PhyMacRxStartCallback*')

    typehandlers.add_type_alias('ns3::Callback< void, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty, ns3::empty >&', 'ns3::PhyMacRxStartCallback&')

    ## Register a nested module for the namespace Config

    nested_module = module.add_cpp_namespace('Config')

    register_types_ns3_Config(nested_module)

    ## Register a nested module for the namespace FatalImpl

    nested_module = module.add_cpp_namespace('FatalImpl')

    register_types_ns3_FatalImpl(nested_module)

    ## Register a nested module for the namespace addressUtils

    nested_module = module.add_cpp_namespace('addressUtils')

    register_types_ns3_addressUtils(nested_module)

    ## Register a nested module for the namespace aodv

    nested_module = module.add_cpp_namespace('aodv')

    register_types_ns3_aodv(nested_module)

    ## Register a nested module for the namespace dot11s

    nested_module = module.add_cpp_namespace('dot11s')

    register_types_ns3_dot11s(nested_module)

    ## Register a nested module for the namespace flame

    nested_module = module.add_cpp_namespace('flame')

    register_types_ns3_flame(nested_module)

    ## Register a nested module for the namespace internal

    nested_module = module.add_cpp_namespace('internal')

    register_types_ns3_internal(nested_module)

    ## Register a nested module for the namespace olsr

    nested_module = module.add_cpp_namespace('olsr')

    register_types_ns3_olsr(nested_module)

def register_types_ns3_Config(module):

    root_module = module.get_root()

def register_types_ns3_FatalImpl(module):

    root_module = module.get_root()

def register_types_ns3_addressUtils(module):

    root_module = module.get_root()

def register_types_ns3_aodv(module):

    root_module = module.get_root()

def register_types_ns3_dot11s(module):

    root_module = module.get_root()

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

def register_types_ns3_flame(module):

    root_module = module.get_root()

def register_types_ns3_internal(module):

    root_module = module.get_root()

def register_types_ns3_olsr(module):

    root_module = module.get_root()

def register_methods(root_module):

    register_Ns3Address_methods(root_module, root_module['ns3::Address'])

    register_Ns3ChannelList_methods(root_module, root_module['ns3::ChannelList'])

    register_Ns3Inet6SocketAddress_methods(root_module, root_module['ns3::Inet6SocketAddress'])

    register_Ns3InetSocketAddress_methods(root_module, root_module['ns3::InetSocketAddress'])

    register_Ns3Ipv4Address_methods(root_module, root_module['ns3::Ipv4Address'])

    register_Ns3Ipv4AddressGenerator_methods(root_module, root_module['ns3::Ipv4AddressGenerator'])

    register_Ns3Ipv4InterfaceAddress_methods(root_module, root_module['ns3::Ipv4InterfaceAddress'])

    register_Ns3Ipv4Mask_methods(root_module, root_module['ns3::Ipv4Mask'])

    register_Ns3Ipv6Address_methods(root_module, root_module['ns3::Ipv6Address'])

    register_Ns3Ipv6InterfaceAddress_methods(root_module, root_module['ns3::Ipv6InterfaceAddress'])

    register_Ns3Ipv6Prefix_methods(root_module, root_module['ns3::Ipv6Prefix'])

    register_Ns3Mac48Address_methods(root_module, root_module['ns3::Mac48Address'])

    register_Ns3Mac64Address_methods(root_module, root_module['ns3::Mac64Address'])

    register_Ns3NodeList_methods(root_module, root_module['ns3::NodeList'])

    register_Ns3PacketSocketAddress_methods(root_module, root_module['ns3::PacketSocketAddress'])

    register_Ns3PbbAddressTlvBlock_methods(root_module, root_module['ns3::PbbAddressTlvBlock'])

    register_Ns3PbbTlvBlock_methods(root_module, root_module['ns3::PbbTlvBlock'])

    register_Ns3Ipv4Header_methods(root_module, root_module['ns3::Ipv4Header'])

    register_Ns3Ipv4PacketInfoTag_methods(root_module, root_module['ns3::Ipv4PacketInfoTag'])

    register_Ns3Ipv6Header_methods(root_module, root_module['ns3::Ipv6Header'])

    register_Ns3Ipv6PacketInfoTag_methods(root_module, root_module['ns3::Ipv6PacketInfoTag'])

    register_Ns3LlcSnapHeader_methods(root_module, root_module['ns3::LlcSnapHeader'])

    register_Ns3Queue_methods(root_module, root_module['ns3::Queue'])

    register_Ns3RadiotapHeader_methods(root_module, root_module['ns3::RadiotapHeader'])

    register_Ns3Socket_methods(root_module, root_module['ns3::Socket'])

    register_Ns3SocketAddressTag_methods(root_module, root_module['ns3::SocketAddressTag'])

    register_Ns3SocketFactory_methods(root_module, root_module['ns3::SocketFactory'])

    register_Ns3SocketIpTtlTag_methods(root_module, root_module['ns3::SocketIpTtlTag'])

    register_Ns3SocketSetDontFragmentTag_methods(root_module, root_module['ns3::SocketSetDontFragmentTag'])

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

    register_Ns3TcpSocket_methods(root_module, root_module['ns3::TcpSocket'])

    register_Ns3TcpSocketFactory_methods(root_module, root_module['ns3::TcpSocketFactory'])

    register_Ns3UdpSocket_methods(root_module, root_module['ns3::UdpSocket'])

    register_Ns3UdpSocketFactory_methods(root_module, root_module['ns3::UdpSocketFactory'])

    register_Ns3Application_methods(root_module, root_module['ns3::Application'])

    register_Ns3Channel_methods(root_module, root_module['ns3::Channel'])

    register_Ns3DropTailQueue_methods(root_module, root_module['ns3::DropTailQueue'])

    register_Ns3EthernetHeader_methods(root_module, root_module['ns3::EthernetHeader'])

    register_Ns3EthernetTrailer_methods(root_module, root_module['ns3::EthernetTrailer'])

    register_Ns3Ipv4_methods(root_module, root_module['ns3::Ipv4'])

    register_Ns3Ipv4AddressChecker_methods(root_module, root_module['ns3::Ipv4AddressChecker'])

    register_Ns3Ipv4AddressValue_methods(root_module, root_module['ns3::Ipv4AddressValue'])

    register_Ns3Ipv4MaskChecker_methods(root_module, root_module['ns3::Ipv4MaskChecker'])

    register_Ns3Ipv4MaskValue_methods(root_module, root_module['ns3::Ipv4MaskValue'])

    register_Ns3Ipv4MulticastRoute_methods(root_module, root_module['ns3::Ipv4MulticastRoute'])

    register_Ns3Ipv4RawSocketFactory_methods(root_module, root_module['ns3::Ipv4RawSocketFactory'])

    register_Ns3Ipv4Route_methods(root_module, root_module['ns3::Ipv4Route'])

    register_Ns3Ipv4RoutingProtocol_methods(root_module, root_module['ns3::Ipv4RoutingProtocol'])

    register_Ns3Ipv6_methods(root_module, root_module['ns3::Ipv6'])

    register_Ns3Ipv6AddressChecker_methods(root_module, root_module['ns3::Ipv6AddressChecker'])

    register_Ns3Ipv6AddressValue_methods(root_module, root_module['ns3::Ipv6AddressValue'])

    register_Ns3Ipv6MulticastRoute_methods(root_module, root_module['ns3::Ipv6MulticastRoute'])

    register_Ns3Ipv6PrefixChecker_methods(root_module, root_module['ns3::Ipv6PrefixChecker'])

    register_Ns3Ipv6PrefixValue_methods(root_module, root_module['ns3::Ipv6PrefixValue'])

    register_Ns3Ipv6RawSocketFactory_methods(root_module, root_module['ns3::Ipv6RawSocketFactory'])

    register_Ns3Ipv6Route_methods(root_module, root_module['ns3::Ipv6Route'])

    register_Ns3Ipv6RoutingProtocol_methods(root_module, root_module['ns3::Ipv6RoutingProtocol'])

    register_Ns3Mac48AddressChecker_methods(root_module, root_module['ns3::Mac48AddressChecker'])

    register_Ns3Mac48AddressValue_methods(root_module, root_module['ns3::Mac48AddressValue'])

    register_Ns3NetDevice_methods(root_module, root_module['ns3::NetDevice'])

    register_Ns3Node_methods(root_module, root_module['ns3::Node'])

    register_Ns3PacketSocketFactory_methods(root_module, root_module['ns3::PacketSocketFactory'])

    register_Ns3PbbAddressBlock_methods(root_module, root_module['ns3::PbbAddressBlock'])

    register_Ns3PbbAddressBlockIpv4_methods(root_module, root_module['ns3::PbbAddressBlockIpv4'])

    register_Ns3PbbAddressBlockIpv6_methods(root_module, root_module['ns3::PbbAddressBlockIpv6'])

    register_Ns3PbbMessage_methods(root_module, root_module['ns3::PbbMessage'])

    register_Ns3PbbMessageIpv4_methods(root_module, root_module['ns3::PbbMessageIpv4'])

    register_Ns3PbbMessageIpv6_methods(root_module, root_module['ns3::PbbMessageIpv6'])

    register_Ns3PbbPacket_methods(root_module, root_module['ns3::PbbPacket'])

    register_Ns3PbbTlv_methods(root_module, root_module['ns3::PbbTlv'])

    register_Ns3SimpleChannel_methods(root_module, root_module['ns3::SimpleChannel'])

    register_Ns3SimpleNetDevice_methods(root_module, root_module['ns3::SimpleNetDevice'])

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

    register_Ns3AddressChecker_methods(root_module, root_module['ns3::AddressChecker'])

    register_Ns3AddressValue_methods(root_module, root_module['ns3::AddressValue'])

    register_Ns3PbbAddressTlv_methods(root_module, root_module['ns3::PbbAddressTlv'])

    return

def register_Ns3Address_methods(root_module, cls):

    cls.add_binary_comparison_operator('!=')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## address.h: ns3::Address::Address() [constructor]

    cls.add_constructor([])

    ## address.h: ns3::Address::Address(uint8_t type, uint8_t const * buffer, uint8_t len) [constructor]

    cls.add_constructor([param('uint8_t', 'type'), param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

    ## address.h: ns3::Address::Address(ns3::Address const & address) [copy constructor]

    cls.add_constructor([param('ns3::Address const &', 'address')])

    ## address.h: bool ns3::Address::CheckCompatible(uint8_t type, uint8_t len) const [member function]

    cls.add_method('CheckCompatible', 

                   'bool', 

                   [param('uint8_t', 'type'), param('uint8_t', 'len')], 

                   is_const=True)

    ## address.h: uint32_t ns3::Address::CopyAllFrom(uint8_t const * buffer, uint8_t len) [member function]

    cls.add_method('CopyAllFrom', 

                   'uint32_t', 

                   [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

    ## address.h: uint32_t ns3::Address::CopyAllTo(uint8_t * buffer, uint8_t len) const [member function]

    cls.add_method('CopyAllTo', 

                   'uint32_t', 

                   [param('uint8_t *', 'buffer'), param('uint8_t', 'len')], 

                   is_const=True)

    ## address.h: uint32_t ns3::Address::CopyFrom(uint8_t const * buffer, uint8_t len) [member function]

    cls.add_method('CopyFrom', 

                   'uint32_t', 

                   [param('uint8_t const *', 'buffer'), param('uint8_t', 'len')])

    ## address.h: uint32_t ns3::Address::CopyTo(uint8_t * buffer) const [member function]

    cls.add_method('CopyTo', 

                   'uint32_t', 

                   [param('uint8_t *', 'buffer')], 

                   is_const=True)

    ## address.h: void ns3::Address::Deserialize(ns3::TagBuffer buffer) [member function]

    cls.add_method('Deserialize', 

                   'void', 

                   [param('ns3::TagBuffer', 'buffer')])

    ## address.h: uint8_t ns3::Address::GetLength() const [member function]

    cls.add_method('GetLength', 

                   'uint8_t', 

                   [], 

                   is_const=True)

    ## address.h: uint32_t ns3::Address::GetSerializedSize() const [member function]

    cls.add_method('GetSerializedSize', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## address.h: bool ns3::Address::IsInvalid() const [member function]

    cls.add_method('IsInvalid', 

                   'bool', 

                   [], 

                   is_const=True)

    ## address.h: bool ns3::Address::IsMatchingType(uint8_t type) const [member function]

    cls.add_method('IsMatchingType', 

                   'bool', 

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

                   is_const=True)

    ## address.h: static uint8_t ns3::Address::Register() [member function]

    cls.add_method('Register', 

                   'uint8_t', 

                   [], 

                   is_static=True)

    ## address.h: void ns3::Address::Serialize(ns3::TagBuffer buffer) const [member function]

    cls.add_method('Serialize', 

                   'void', 

                   [param('ns3::TagBuffer', 'buffer')], 

                   is_const=True)

    return

def register_Ns3ChannelList_methods(root_module, cls):

    ## channel-list.h: ns3::ChannelList::ChannelList() [constructor]

    cls.add_constructor([])

    ## channel-list.h: ns3::ChannelList::ChannelList(ns3::ChannelList const & arg0) [copy constructor]

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

    ## channel-list.h: static uint32_t ns3::ChannelList::Add(ns3::Ptr<ns3::Channel> channel) [member function]

    cls.add_method('Add', 

                   'uint32_t', 

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

                   is_static=True)

    ## channel-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Channel>*,std::vector<ns3::Ptr<ns3::Channel>, std::allocator<ns3::Ptr<ns3::Channel> > > > ns3::ChannelList::Begin() [member function]

    cls.add_method('Begin', 

                   '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Channel > const, std::vector< ns3::Ptr< ns3::Channel > > >', 

                   [], 

                   is_static=True)

    ## channel-list.h: static __gnu_cxx::__normal_iterator<const ns3::Ptr<ns3::Channel>*,std::vector<ns3::Ptr<ns3::Channel>, std::allocator<ns3::Ptr<ns3::Channel> > > > ns3::ChannelList::End() [member function]

    cls.add_method('End', 

                   '__gnu_cxx::__normal_iterator< ns3::Ptr< ns3::Channel > const, std::vector< ns3::Ptr< ns3::Channel > > >', 

                   [], 

                   is_static=True)

    ## channel-list.h: static ns3::Ptr<ns3::Channel> ns3::ChannelList::GetChannel(uint32_t n) [member function]

    cls.add_method('GetChannel', 

                   'ns3::Ptr< ns3::Channel >', 

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

                   is_static=True)

    ## channel-list.h: static uint32_t ns3::ChannelList::GetNChannels() [member function]

    cls.add_method('GetNChannels', 

                   'uint32_t', 

                   [], 

                   is_static=True)

    return

def register_Ns3Inet6SocketAddress_methods(root_module, cls):

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Inet6SocketAddress const & arg0) [copy constructor]

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

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6, uint16_t port) [constructor]

    cls.add_constructor([param('ns3::Ipv6Address', 'ipv6'), param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(ns3::Ipv6Address ipv6) [constructor]

    cls.add_constructor([param('ns3::Ipv6Address', 'ipv6')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(uint16_t port) [constructor]

    cls.add_constructor([param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(char const * ipv6, uint16_t port) [constructor]

    cls.add_constructor([param('char const *', 'ipv6'), param('uint16_t', 'port')])

    ## inet6-socket-address.h: ns3::Inet6SocketAddress::Inet6SocketAddress(char const * ipv6) [constructor]

    cls.add_constructor([param('char const *', 'ipv6')])

    ## inet6-socket-address.h: static ns3::Inet6SocketAddress ns3::Inet6SocketAddress::ConvertFrom(ns3::Address const & addr) [member function]

    cls.add_method('ConvertFrom', 

                   'ns3::Inet6SocketAddress', 

                   [param('ns3::Address const &', 'addr')], 

                   is_static=True)