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

import pybindgen.settings

import warnings

class ErrorHandler(pybindgen.settings.ErrorHandler):

    def handle_error(self, wrapper, exception, traceback_):

        warnings.warn("exception %r in wrapper %s" % (exception, wrapper))

        return True

pybindgen.settings.error_handler = ErrorHandler()

import sys

def module_init():

    root_module = Module('ns.propagation', cpp_namespace='::ns3')

    return root_module

def register_types(module):

    root_module = module.get_root()

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList [class]

    module.add_class('AttributeConstructionList', import_from_module='ns.core')

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item [struct]

    module.add_class('Item', import_from_module='ns.core', outer_class=root_module['ns3::AttributeConstructionList'])

    ## callback.h (module 'core'): ns3::CallbackBase [class]

    module.add_class('CallbackBase', import_from_module='ns.core')

    ## object-base.h (module 'core'): ns3::ObjectBase [class]

    module.add_class('ObjectBase', allow_subclassing=True, import_from_module='ns.core')

    ## object.h (module 'core'): ns3::ObjectDeleter [struct]

    module.add_class('ObjectDeleter', import_from_module='ns.core')

    ## random-variable.h (module 'core'): ns3::RandomVariable [class]

    module.add_class('RandomVariable', import_from_module='ns.core')

    ## random-variable.h (module 'core'): ns3::SeedManager [class]

    module.add_class('SeedManager', import_from_module='ns.core')

    ## random-variable.h (module 'core'): ns3::SequentialVariable [class]

    module.add_class('SequentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> [class]

    module.add_class('SimpleRefCount', automatic_type_narrowing=True, import_from_module='ns.core', template_parameters=['ns3::Object', 'ns3::ObjectBase', 'ns3::ObjectDeleter'], parent=root_module['ns3::ObjectBase'], memory_policy=cppclass.ReferenceCountingMethodsPolicy(incref_method='Ref', decref_method='Unref', peekref_method='GetReferenceCount'))

    ## random-variable.h (module 'core'): ns3::TriangularVariable [class]

    module.add_class('TriangularVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## type-id.h (module 'core'): ns3::TypeId [class]

    module.add_class('TypeId', import_from_module='ns.core')

    ## type-id.h (module 'core'): ns3::TypeId::AttributeFlag [enumeration]

    module.add_enum('AttributeFlag', ['ATTR_GET', 'ATTR_SET', 'ATTR_CONSTRUCT', 'ATTR_SGC'], outer_class=root_module['ns3::TypeId'], import_from_module='ns.core')

    ## type-id.h (module 'core'): ns3::TypeId::AttributeInformation [struct]

    module.add_class('AttributeInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])

    ## type-id.h (module 'core'): ns3::TypeId::TraceSourceInformation [struct]

    module.add_class('TraceSourceInformation', import_from_module='ns.core', outer_class=root_module['ns3::TypeId'])

    ## random-variable.h (module 'core'): ns3::UniformVariable [class]

    module.add_class('UniformVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## vector.h (module 'core'): ns3::Vector2D [class]

    module.add_class('Vector2D', import_from_module='ns.core')

    ## vector.h (module 'core'): ns3::Vector3D [class]

    module.add_class('Vector3D', import_from_module='ns.core')

    ## random-variable.h (module 'core'): ns3::WeibullVariable [class]

    module.add_class('WeibullVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::ZetaVariable [class]

    module.add_class('ZetaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::ZipfVariable [class]

    module.add_class('ZipfVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## empty.h (module 'core'): ns3::empty [class]

    module.add_class('empty', import_from_module='ns.core')

    ## int64x64-double.h (module 'core'): ns3::int64x64_t [class]

    module.add_class('int64x64_t', import_from_module='ns.core')

    ## random-variable.h (module 'core'): ns3::ConstantVariable [class]

    module.add_class('ConstantVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::DeterministicVariable [class]

    module.add_class('DeterministicVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::EmpiricalVariable [class]

    module.add_class('EmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::ErlangVariable [class]

    module.add_class('ErlangVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::ExponentialVariable [class]

    module.add_class('ExponentialVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::GammaVariable [class]

    module.add_class('GammaVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::IntEmpiricalVariable [class]

    module.add_class('IntEmpiricalVariable', import_from_module='ns.core', parent=root_module['ns3::EmpiricalVariable'])

    ## random-variable.h (module 'core'): ns3::LogNormalVariable [class]

    module.add_class('LogNormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## random-variable.h (module 'core'): ns3::NormalVariable [class]

    module.add_class('NormalVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## object.h (module 'core'): ns3::Object [class]

    module.add_class('Object', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])

    ## object.h (module 'core'): ns3::Object::AggregateIterator [class]

    module.add_class('AggregateIterator', import_from_module='ns.core', outer_class=root_module['ns3::Object'])

    ## random-variable.h (module 'core'): ns3::ParetoVariable [class]

    module.add_class('ParetoVariable', import_from_module='ns.core', parent=root_module['ns3::RandomVariable'])

    ## propagation-delay-model.h (module 'propagation'): ns3::PropagationDelayModel [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::PropagationLossModel [class]

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

    ## propagation-delay-model.h (module 'propagation'): ns3::RandomPropagationDelayModel [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::RandomPropagationLossModel [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::RangePropagationLossModel [class]

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

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> > [class]

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

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> > [class]

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

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> > [class]

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

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> > [class]

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

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> > [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::ThreeLogDistancePropagationLossModel [class]

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

    ## nstime.h (module 'core'): ns3::Time [class]

    module.add_class('Time', import_from_module='ns.core')

    ## nstime.h (module 'core'): ns3::Time::Unit [enumeration]

    module.add_enum('Unit', ['S', 'MS', 'US', 'NS', 'PS', 'FS', 'LAST'], outer_class=root_module['ns3::Time'], import_from_module='ns.core')

    ## nstime.h (module 'core'): ns3::Time [class]

    root_module['ns3::Time'].implicitly_converts_to(root_module['ns3::int64x64_t'])

    ## trace-source-accessor.h (module 'core'): ns3::TraceSourceAccessor [class]

    module.add_class('TraceSourceAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])

    ## propagation-loss-model.h (module 'propagation'): ns3::TwoRayGroundPropagationLossModel [class]

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

    ## attribute.h (module 'core'): ns3::AttributeAccessor [class]

    module.add_class('AttributeAccessor', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])

    ## attribute.h (module 'core'): ns3::AttributeChecker [class]

    module.add_class('AttributeChecker', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])

    ## attribute.h (module 'core'): ns3::AttributeValue [class]

    module.add_class('AttributeValue', allow_subclassing=False, automatic_type_narrowing=True, import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])

    ## callback.h (module 'core'): ns3::CallbackChecker [class]

    module.add_class('CallbackChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## callback.h (module 'core'): ns3::CallbackImplBase [class]

    module.add_class('CallbackImplBase', import_from_module='ns.core', parent=root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])

    ## callback.h (module 'core'): ns3::CallbackValue [class]

    module.add_class('CallbackValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## propagation-delay-model.h (module 'propagation'): ns3::ConstantSpeedPropagationDelayModel [class]

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

    ## cost231-propagation-loss-model.h (module 'propagation'): ns3::Cost231PropagationLossModel [class]

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

    ## cost231-propagation-loss-model.h (module 'propagation'): ns3::Cost231PropagationLossModel::Environment [enumeration]

    module.add_enum('Environment', ['SubUrban', 'MediumCity', 'Metropolitan'], outer_class=root_module['ns3::Cost231PropagationLossModel'])

    ## attribute.h (module 'core'): ns3::EmptyAttributeValue [class]

    module.add_class('EmptyAttributeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## propagation-loss-model.h (module 'propagation'): ns3::FixedRssLossModel [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::FriisPropagationLossModel [class]

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

    ## jakes-propagation-loss-model.h (module 'propagation'): ns3::JakesPropagationLossModel [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::LogDistancePropagationLossModel [class]

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

    ## propagation-loss-model.h (module 'propagation'): ns3::MatrixPropagationLossModel [class]

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

    ## mobility-model.h (module 'mobility'): ns3::MobilityModel [class]

    module.add_class('MobilityModel', import_from_module='ns.mobility', parent=root_module['ns3::Object'])

    ## propagation-loss-model.h (module 'propagation'): ns3::NakagamiPropagationLossModel [class]

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

    ## random-variable.h (module 'core'): ns3::RandomVariableChecker [class]

    module.add_class('RandomVariableChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## random-variable.h (module 'core'): ns3::RandomVariableValue [class]

    module.add_class('RandomVariableValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## nstime.h (module 'core'): ns3::TimeChecker [class]

    module.add_class('TimeChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## nstime.h (module 'core'): ns3::TimeValue [class]

    module.add_class('TimeValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## type-id.h (module 'core'): ns3::TypeIdChecker [class]

    module.add_class('TypeIdChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## type-id.h (module 'core'): ns3::TypeIdValue [class]

    module.add_class('TypeIdValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## vector.h (module 'core'): ns3::Vector2DChecker [class]

    module.add_class('Vector2DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## vector.h (module 'core'): ns3::Vector2DValue [class]

    module.add_class('Vector2DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    ## vector.h (module 'core'): ns3::Vector3DChecker [class]

    module.add_class('Vector3DChecker', import_from_module='ns.core', parent=root_module['ns3::AttributeChecker'])

    ## vector.h (module 'core'): ns3::Vector3DValue [class]

    module.add_class('Vector3DValue', import_from_module='ns.core', parent=root_module['ns3::AttributeValue'])

    typehandlers.add_type_alias('ns3::Vector3DValue', 'ns3::VectorValue')

    typehandlers.add_type_alias('ns3::Vector3DValue*', 'ns3::VectorValue*')

    typehandlers.add_type_alias('ns3::Vector3DValue&', 'ns3::VectorValue&')

    module.add_typedef(root_module['ns3::Vector3DValue'], 'VectorValue')

    typehandlers.add_type_alias('ns3::Vector3D', 'ns3::Vector')

    typehandlers.add_type_alias('ns3::Vector3D*', 'ns3::Vector*')

    typehandlers.add_type_alias('ns3::Vector3D&', 'ns3::Vector&')

    module.add_typedef(root_module['ns3::Vector3D'], 'Vector')

    typehandlers.add_type_alias('ns3::Vector3DChecker', 'ns3::VectorChecker')

    typehandlers.add_type_alias('ns3::Vector3DChecker*', 'ns3::VectorChecker*')

    typehandlers.add_type_alias('ns3::Vector3DChecker&', 'ns3::VectorChecker&')

    module.add_typedef(root_module['ns3::Vector3DChecker'], 'VectorChecker')

    ## Register a nested module for the namespace FatalImpl

    nested_module = module.add_cpp_namespace('FatalImpl')

    register_types_ns3_FatalImpl(nested_module)

def register_types_ns3_FatalImpl(module):

    root_module = module.get_root()

def register_methods(root_module):

    register_Ns3AttributeConstructionList_methods(root_module, root_module['ns3::AttributeConstructionList'])

    register_Ns3AttributeConstructionListItem_methods(root_module, root_module['ns3::AttributeConstructionList::Item'])

    register_Ns3CallbackBase_methods(root_module, root_module['ns3::CallbackBase'])

    register_Ns3ObjectBase_methods(root_module, root_module['ns3::ObjectBase'])

    register_Ns3ObjectDeleter_methods(root_module, root_module['ns3::ObjectDeleter'])

    register_Ns3RandomVariable_methods(root_module, root_module['ns3::RandomVariable'])

    register_Ns3SeedManager_methods(root_module, root_module['ns3::SeedManager'])

    register_Ns3SequentialVariable_methods(root_module, root_module['ns3::SequentialVariable'])

    register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, root_module['ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter >'])

    register_Ns3TriangularVariable_methods(root_module, root_module['ns3::TriangularVariable'])

    register_Ns3TypeId_methods(root_module, root_module['ns3::TypeId'])

    register_Ns3TypeIdAttributeInformation_methods(root_module, root_module['ns3::TypeId::AttributeInformation'])

    register_Ns3TypeIdTraceSourceInformation_methods(root_module, root_module['ns3::TypeId::TraceSourceInformation'])

    register_Ns3UniformVariable_methods(root_module, root_module['ns3::UniformVariable'])

    register_Ns3Vector2D_methods(root_module, root_module['ns3::Vector2D'])

    register_Ns3Vector3D_methods(root_module, root_module['ns3::Vector3D'])

    register_Ns3WeibullVariable_methods(root_module, root_module['ns3::WeibullVariable'])

    register_Ns3ZetaVariable_methods(root_module, root_module['ns3::ZetaVariable'])

    register_Ns3ZipfVariable_methods(root_module, root_module['ns3::ZipfVariable'])

    register_Ns3Empty_methods(root_module, root_module['ns3::empty'])

    register_Ns3Int64x64_t_methods(root_module, root_module['ns3::int64x64_t'])

    register_Ns3ConstantVariable_methods(root_module, root_module['ns3::ConstantVariable'])

    register_Ns3DeterministicVariable_methods(root_module, root_module['ns3::DeterministicVariable'])

    register_Ns3EmpiricalVariable_methods(root_module, root_module['ns3::EmpiricalVariable'])

    register_Ns3ErlangVariable_methods(root_module, root_module['ns3::ErlangVariable'])

    register_Ns3ExponentialVariable_methods(root_module, root_module['ns3::ExponentialVariable'])

    register_Ns3GammaVariable_methods(root_module, root_module['ns3::GammaVariable'])

    register_Ns3IntEmpiricalVariable_methods(root_module, root_module['ns3::IntEmpiricalVariable'])

    register_Ns3LogNormalVariable_methods(root_module, root_module['ns3::LogNormalVariable'])

    register_Ns3NormalVariable_methods(root_module, root_module['ns3::NormalVariable'])

    register_Ns3Object_methods(root_module, root_module['ns3::Object'])

    register_Ns3ObjectAggregateIterator_methods(root_module, root_module['ns3::Object::AggregateIterator'])

    register_Ns3ParetoVariable_methods(root_module, root_module['ns3::ParetoVariable'])

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

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

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

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

    register_Ns3RangePropagationLossModel_methods(root_module, root_module['ns3::RangePropagationLossModel'])

    register_Ns3SimpleRefCount__Ns3AttributeAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeAccessor, ns3::empty, ns3::DefaultDeleter<ns3::AttributeAccessor> >'])

    register_Ns3SimpleRefCount__Ns3AttributeChecker_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeChecker__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeChecker, ns3::empty, ns3::DefaultDeleter<ns3::AttributeChecker> >'])

    register_Ns3SimpleRefCount__Ns3AttributeValue_Ns3Empty_Ns3DefaultDeleter__lt__ns3AttributeValue__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::AttributeValue, ns3::empty, ns3::DefaultDeleter<ns3::AttributeValue> >'])

    register_Ns3SimpleRefCount__Ns3CallbackImplBase_Ns3Empty_Ns3DefaultDeleter__lt__ns3CallbackImplBase__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::CallbackImplBase, ns3::empty, ns3::DefaultDeleter<ns3::CallbackImplBase> >'])

    register_Ns3SimpleRefCount__Ns3TraceSourceAccessor_Ns3Empty_Ns3DefaultDeleter__lt__ns3TraceSourceAccessor__gt___methods(root_module, root_module['ns3::SimpleRefCount< ns3::TraceSourceAccessor, ns3::empty, ns3::DefaultDeleter<ns3::TraceSourceAccessor> >'])

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

    register_Ns3Time_methods(root_module, root_module['ns3::Time'])

    register_Ns3TraceSourceAccessor_methods(root_module, root_module['ns3::TraceSourceAccessor'])

    register_Ns3TwoRayGroundPropagationLossModel_methods(root_module, root_module['ns3::TwoRayGroundPropagationLossModel'])

    register_Ns3AttributeAccessor_methods(root_module, root_module['ns3::AttributeAccessor'])

    register_Ns3AttributeChecker_methods(root_module, root_module['ns3::AttributeChecker'])

    register_Ns3AttributeValue_methods(root_module, root_module['ns3::AttributeValue'])

    register_Ns3CallbackChecker_methods(root_module, root_module['ns3::CallbackChecker'])

    register_Ns3CallbackImplBase_methods(root_module, root_module['ns3::CallbackImplBase'])

    register_Ns3CallbackValue_methods(root_module, root_module['ns3::CallbackValue'])

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

    register_Ns3Cost231PropagationLossModel_methods(root_module, root_module['ns3::Cost231PropagationLossModel'])

    register_Ns3EmptyAttributeValue_methods(root_module, root_module['ns3::EmptyAttributeValue'])

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

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

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

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

    register_Ns3MatrixPropagationLossModel_methods(root_module, root_module['ns3::MatrixPropagationLossModel'])

    register_Ns3MobilityModel_methods(root_module, root_module['ns3::MobilityModel'])

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

    register_Ns3RandomVariableChecker_methods(root_module, root_module['ns3::RandomVariableChecker'])

    register_Ns3RandomVariableValue_methods(root_module, root_module['ns3::RandomVariableValue'])

    register_Ns3TimeChecker_methods(root_module, root_module['ns3::TimeChecker'])

    register_Ns3TimeValue_methods(root_module, root_module['ns3::TimeValue'])

    register_Ns3TypeIdChecker_methods(root_module, root_module['ns3::TypeIdChecker'])

    register_Ns3TypeIdValue_methods(root_module, root_module['ns3::TypeIdValue'])

    register_Ns3Vector2DChecker_methods(root_module, root_module['ns3::Vector2DChecker'])

    register_Ns3Vector2DValue_methods(root_module, root_module['ns3::Vector2DValue'])

    register_Ns3Vector3DChecker_methods(root_module, root_module['ns3::Vector3DChecker'])

    register_Ns3Vector3DValue_methods(root_module, root_module['ns3::Vector3DValue'])

    return

def register_Ns3AttributeConstructionList_methods(root_module, cls):

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList(ns3::AttributeConstructionList const & arg0) [copy constructor]

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

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::AttributeConstructionList() [constructor]

    cls.add_constructor([])

    ## attribute-construction-list.h (module 'core'): void ns3::AttributeConstructionList::Add(std::string name, ns3::Ptr<ns3::AttributeChecker const> checker, ns3::Ptr<ns3::AttributeValue> value) [member function]

    cls.add_method('Add', 

                   'void', 

                   [param('std::string', 'name'), param('ns3::Ptr< ns3::AttributeChecker const >', 'checker'), param('ns3::Ptr< ns3::AttributeValue >', 'value')])

    ## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::Begin() const [member function]

    cls.add_method('Begin', 

                   'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', 

                   [], 

                   is_const=True)

    ## attribute-construction-list.h (module 'core'): std::_List_const_iterator<ns3::AttributeConstructionList::Item> ns3::AttributeConstructionList::End() const [member function]

    cls.add_method('End', 

                   'std::_List_const_iterator< ns3::AttributeConstructionList::Item >', 

                   [], 

                   is_const=True)

    ## attribute-construction-list.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::AttributeConstructionList::Find(ns3::Ptr<ns3::AttributeChecker const> checker) const [member function]

    cls.add_method('Find', 

                   'ns3::Ptr< ns3::AttributeValue >', 

                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 

                   is_const=True)

    return

def register_Ns3AttributeConstructionListItem_methods(root_module, cls):

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item() [constructor]

    cls.add_constructor([])

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::Item(ns3::AttributeConstructionList::Item const & arg0) [copy constructor]

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

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::checker [variable]

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

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::name [variable]

    cls.add_instance_attribute('name', 'std::string', is_const=False)

    ## attribute-construction-list.h (module 'core'): ns3::AttributeConstructionList::Item::value [variable]

    cls.add_instance_attribute('value', 'ns3::Ptr< ns3::AttributeValue >', is_const=False)

    return

def register_Ns3CallbackBase_methods(root_module, cls):

    ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::CallbackBase const & arg0) [copy constructor]

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

    ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase() [constructor]

    cls.add_constructor([])

    ## callback.h (module 'core'): ns3::Ptr<ns3::CallbackImplBase> ns3::CallbackBase::GetImpl() const [member function]

    cls.add_method('GetImpl', 

                   'ns3::Ptr< ns3::CallbackImplBase >', 

                   [], 

                   is_const=True)

    ## callback.h (module 'core'): ns3::CallbackBase::CallbackBase(ns3::Ptr<ns3::CallbackImplBase> impl) [constructor]

    cls.add_constructor([param('ns3::Ptr< ns3::CallbackImplBase >', 'impl')], 

                        visibility='protected')

    ## callback.h (module 'core'): static std::string ns3::CallbackBase::Demangle(std::string const & mangled) [member function]

    cls.add_method('Demangle', 

                   'std::string', 

                   [param('std::string const &', 'mangled')], 

                   is_static=True, visibility='protected')

    return

def register_Ns3ObjectBase_methods(root_module, cls):

    ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase() [constructor]

    cls.add_constructor([])

    ## object-base.h (module 'core'): ns3::ObjectBase::ObjectBase(ns3::ObjectBase const & arg0) [copy constructor]

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

    ## object-base.h (module 'core'): void ns3::ObjectBase::GetAttribute(std::string name, ns3::AttributeValue & value) const [member function]

    cls.add_method('GetAttribute', 

                   'void', 

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

                   is_const=True)

    ## object-base.h (module 'core'): bool ns3::ObjectBase::GetAttributeFailSafe(std::string name, ns3::AttributeValue & attribute) const [member function]

    cls.add_method('GetAttributeFailSafe', 

                   'bool', 

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

                   is_const=True)

    ## object-base.h (module 'core'): ns3::TypeId ns3::ObjectBase::GetInstanceTypeId() const [member function]

    cls.add_method('GetInstanceTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_pure_virtual=True, is_const=True, is_virtual=True)

    ## object-base.h (module 'core'): static ns3::TypeId ns3::ObjectBase::GetTypeId() [member function]

    cls.add_method('GetTypeId', 

                   'ns3::TypeId', 

                   [], 

                   is_static=True)

    ## object-base.h (module 'core'): void ns3::ObjectBase::SetAttribute(std::string name, ns3::AttributeValue const & value) [member function]

    cls.add_method('SetAttribute', 

                   'void', 

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

    ## object-base.h (module 'core'): bool ns3::ObjectBase::SetAttributeFailSafe(std::string name, ns3::AttributeValue const & value) [member function]

    cls.add_method('SetAttributeFailSafe', 

                   'bool', 

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

    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]

    cls.add_method('TraceConnect', 

                   'bool', 

                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])

    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceConnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]

    cls.add_method('TraceConnectWithoutContext', 

                   'bool', 

                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnect(std::string name, std::string context, ns3::CallbackBase const & cb) [member function]

    cls.add_method('TraceDisconnect', 

                   'bool', 

                   [param('std::string', 'name'), param('std::string', 'context'), param('ns3::CallbackBase const &', 'cb')])

    ## object-base.h (module 'core'): bool ns3::ObjectBase::TraceDisconnectWithoutContext(std::string name, ns3::CallbackBase const & cb) [member function]

    cls.add_method('TraceDisconnectWithoutContext', 

                   'bool', 

                   [param('std::string', 'name'), param('ns3::CallbackBase const &', 'cb')])

    ## object-base.h (module 'core'): void ns3::ObjectBase::ConstructSelf(ns3::AttributeConstructionList const & attributes) [member function]

    cls.add_method('ConstructSelf', 

                   'void', 

                   [param('ns3::AttributeConstructionList const &', 'attributes')], 

                   visibility='protected')

    ## object-base.h (module 'core'): void ns3::ObjectBase::NotifyConstructionCompleted() [member function]

    cls.add_method('NotifyConstructionCompleted', 

                   'void', 

                   [], 

                   visibility='protected', is_virtual=True)

    return

def register_Ns3ObjectDeleter_methods(root_module, cls):

    ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter() [constructor]

    cls.add_constructor([])

    ## object.h (module 'core'): ns3::ObjectDeleter::ObjectDeleter(ns3::ObjectDeleter const & arg0) [copy constructor]

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

    ## object.h (module 'core'): static void ns3::ObjectDeleter::Delete(ns3::Object * object) [member function]

    cls.add_method('Delete', 

                   'void', 

                   [param('ns3::Object *', 'object')], 

                   is_static=True)

    return

def register_Ns3RandomVariable_methods(root_module, cls):

    cls.add_output_stream_operator()

    ## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable() [constructor]

    cls.add_constructor([])

    ## random-variable.h (module 'core'): ns3::RandomVariable::RandomVariable(ns3::RandomVariable const & o) [copy constructor]

    cls.add_constructor([param('ns3::RandomVariable const &', 'o')])

    ## random-variable.h (module 'core'): uint32_t ns3::RandomVariable::GetInteger() const [member function]

    cls.add_method('GetInteger', 

                   'uint32_t', 

                   [], 

                   is_const=True)

    ## random-variable.h (module 'core'): double ns3::RandomVariable::GetValue() const [member function]

    cls.add_method('GetValue', 

                   'double', 

                   [], 

                   is_const=True)

    return

def register_Ns3SeedManager_methods(root_module, cls):

    ## random-variable.h (module 'core'): ns3::SeedManager::SeedManager() [constructor]

    cls.add_constructor([])

    ## random-variable.h (module 'core'): ns3::SeedManager::SeedManager(ns3::SeedManager const & arg0) [copy constructor]

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

    ## random-variable.h (module 'core'): static bool ns3::SeedManager::CheckSeed(uint32_t seed) [member function]

    cls.add_method('CheckSeed', 

                   'bool', 

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

                   is_static=True)

    ## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetRun() [member function]

    cls.add_method('GetRun', 

                   'uint32_t', 

                   [], 

                   is_static=True)

    ## random-variable.h (module 'core'): static uint32_t ns3::SeedManager::GetSeed() [member function]

    cls.add_method('GetSeed', 

                   'uint32_t', 

                   [], 

                   is_static=True)

    ## random-variable.h (module 'core'): static void ns3::SeedManager::SetRun(uint32_t run) [member function]

    cls.add_method('SetRun', 

                   'void', 

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

                   is_static=True)

    ## random-variable.h (module 'core'): static void ns3::SeedManager::SetSeed(uint32_t seed) [member function]

    cls.add_method('SetSeed', 

                   'void', 

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

                   is_static=True)

    return

def register_Ns3SequentialVariable_methods(root_module, cls):

    ## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(ns3::SequentialVariable const & arg0) [copy constructor]

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

    ## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, double i=1, uint32_t c=1) [constructor]

    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('double', 'i', default_value='1'), param('uint32_t', 'c', default_value='1')])

    ## random-variable.h (module 'core'): ns3::SequentialVariable::SequentialVariable(double f, double l, ns3::RandomVariable const & i, uint32_t c=1) [constructor]

    cls.add_constructor([param('double', 'f'), param('double', 'l'), param('ns3::RandomVariable const &', 'i'), param('uint32_t', 'c', default_value='1')])

    return

def register_Ns3SimpleRefCount__Ns3Object_Ns3ObjectBase_Ns3ObjectDeleter_methods(root_module, cls):

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount() [constructor]

    cls.add_constructor([])

    ## simple-ref-count.h (module 'core'): ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::SimpleRefCount(ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter> const & o) [copy constructor]

    cls.add_constructor([param('ns3::SimpleRefCount< ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter > const &', 'o')])

    ## simple-ref-count.h (module 'core'): static void ns3::SimpleRefCount<ns3::Object, ns3::ObjectBase, ns3::ObjectDeleter>::Cleanup() [member function]

    cls.add_method('Cleanup', 

                   'void', 

                   [], 

                   is_static=True)

    return

def register_Ns3TriangularVariable_methods(root_module, cls):

    ## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(ns3::TriangularVariable const & arg0) [copy constructor]

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

    ## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable() [constructor]

    cls.add_constructor([])

    ## random-variable.h (module 'core'): ns3::TriangularVariable::TriangularVariable(double s, double l, double mean) [constructor]

    cls.add_constructor([param('double', 's'), param('double', 'l'), param('double', 'mean')])

    return

def register_Ns3TypeId_methods(root_module, cls):

    cls.add_binary_comparison_operator('<')

    cls.add_binary_comparison_operator('!=')

    cls.add_output_stream_operator()

    cls.add_binary_comparison_operator('==')

    ## type-id.h (module 'core'): ns3::TypeId::TypeId(char const * name) [constructor]

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

    ## type-id.h (module 'core'): ns3::TypeId::TypeId() [constructor]

    cls.add_constructor([])

    ## type-id.h (module 'core'): ns3::TypeId::TypeId(ns3::TypeId const & o) [copy constructor]

    cls.add_constructor([param('ns3::TypeId const &', 'o')])

    ## type-id.h (module 'core'): ns3::TypeId ns3::TypeId::AddAttribute(std::string name, std::string help, ns3::AttributeValue const & initialValue, ns3::Ptr<ns3::AttributeAccessor const> accessor, ns3::Ptr<ns3::AttributeChecker const> checker) [member function]

    cls.add_method('AddAttribute', 

                   'ns3::TypeId',