text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 4.0.0
  #
  # Do not make changes to this file unless you know what you are doing--modify
  # the SWIG interface file instead.
  
  from sys import version_info as _swig_python_version_info
  if _swig_python_version_info < (2, 7, 0):
      raise RuntimeError('Python 2.7 or later required')
  
  # Import the low-level C/C++ module
  if __package__ or '.' in __name__:
      from . import _helics
  else:
      import _helics
  
  try:
      import builtins as __builtin__
  except ImportError:
      import __builtin__
  
  def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
      if name == "thisown":
          return self.this.own(value)
      if name == "this":
          if type(value).__name__ == 'SwigPyObject':
              self.__dict__[name] = value
              return
      method = class_type.__swig_setmethods__.get(name, None)
      if method:
          return method(self, value)
      if not static:
          object.__setattr__(self, name, value)
      else:
          raise AttributeError("You cannot add attributes to %s" % self)
  
  
  def _swig_setattr(self, class_type, name, value):
      return _swig_setattr_nondynamic(self, class_type, name, value, 0)
  
  
  def _swig_getattr(self, class_type, name):
      if name == "thisown":
          return self.this.own()
      method = class_type.__swig_getmethods__.get(name, None)
      if method:
          return method(self)
      raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
  
  
  def _swig_repr(self):
      try:
          strthis = "proxy of " + self.this.__repr__()
      except __builtin__.Exception:
          strthis = ""
      return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
  
  
  def _swig_setattr_nondynamic_instance_variable(set):
      def set_instance_attr(self, name, value):
          if name == "thisown":
              self.this.own(value)
          elif name == "this":
              set(self, name, value)
          elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
              set(self, name, value)
          else:
              raise AttributeError("You cannot add instance attributes to %s" % self)
      return set_instance_attr
  
  
  def _swig_setattr_nondynamic_class_variable(set):
      def set_class_attr(cls, name, value):
          if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
              set(cls, name, value)
          else:
              raise AttributeError("You cannot add class attributes to %s" % cls)
      return set_class_attr
  
  
  def _swig_add_metaclass(metaclass):
      """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
      def wrapper(cls):
          return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
      return wrapper
  
  
  class _SwigNonDynamicMeta(type):
      """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
      __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
  
  
  helics_core_type_default = _helics.helics_core_type_default
  helics_core_type_zmq = _helics.helics_core_type_zmq
  helics_core_type_mpi = _helics.helics_core_type_mpi
  helics_core_type_test = _helics.helics_core_type_test
  helics_core_type_interprocess = _helics.helics_core_type_interprocess
  helics_core_type_ipc = _helics.helics_core_type_ipc
  helics_core_type_tcp = _helics.helics_core_type_tcp
  helics_core_type_udp = _helics.helics_core_type_udp
  helics_core_type_zmq_test = _helics.helics_core_type_zmq_test
  helics_core_type_nng = _helics.helics_core_type_nng
  helics_core_type_tcp_ss = _helics.helics_core_type_tcp_ss
  helics_core_type_http = _helics.helics_core_type_http
  helics_data_type_string = _helics.helics_data_type_string
  helics_data_type_double = _helics.helics_data_type_double
  helics_data_type_int = _helics.helics_data_type_int
  helics_data_type_complex = _helics.helics_data_type_complex
  helics_data_type_vector = _helics.helics_data_type_vector
  helics_data_type_complex_vector = _helics.helics_data_type_complex_vector
  helics_data_type_named_point = _helics.helics_data_type_named_point
  helics_data_type_boolean = _helics.helics_data_type_boolean
  helics_data_type_time = _helics.helics_data_type_time
  helics_data_type_raw = _helics.helics_data_type_raw
  helics_data_type_any = _helics.helics_data_type_any
  helics_flag_observer = _helics.helics_flag_observer
  helics_flag_uninterruptible = _helics.helics_flag_uninterruptible
  helics_flag_interruptible = _helics.helics_flag_interruptible
  helics_flag_source_only = _helics.helics_flag_source_only
  helics_flag_only_transmit_on_change = _helics.helics_flag_only_transmit_on_change
  helics_flag_only_update_on_change = _helics.helics_flag_only_update_on_change
  helics_flag_wait_for_current_time_update = _helics.helics_flag_wait_for_current_time_update
  helics_flag_rollback = _helics.helics_flag_rollback
  helics_flag_forward_compute = _helics.helics_flag_forward_compute
  helics_flag_realtime = _helics.helics_flag_realtime
  helics_flag_single_thread_federate = _helics.helics_flag_single_thread_federate
  helics_flag_delay_init_entry = _helics.helics_flag_delay_init_entry
  helics_flag_enable_init_entry = _helics.helics_flag_enable_init_entry
  helics_flag_ignore_time_mismatch_warnings = _helics.helics_flag_ignore_time_mismatch_warnings
  helics_log_level_no_print = _helics.helics_log_level_no_print
  helics_log_level_error = _helics.helics_log_level_error
  helics_log_level_warning = _helics.helics_log_level_warning
  helics_log_level_summary = _helics.helics_log_level_summary
  helics_log_level_connections = _helics.helics_log_level_connections
  helics_log_level_interfaces = _helics.helics_log_level_interfaces
  helics_log_level_timing = _helics.helics_log_level_timing
  helics_log_level_data = _helics.helics_log_level_data
  helics_log_level_trace = _helics.helics_log_level_trace
  helics_ok = _helics.helics_ok
  helics_error_registration_failure = _helics.helics_error_registration_failure
  helics_error_connection_failure = _helics.helics_error_connection_failure
  helics_error_invalid_object = _helics.helics_error_invalid_object
  helics_error_invalid_argument = _helics.helics_error_invalid_argument
  helics_error_discard = _helics.helics_error_discard
  helics_error_system_failure = _helics.helics_error_system_failure
  helics_warning = _helics.helics_warning
  helics_error_invalid_state_transition = _helics.helics_error_invalid_state_transition
  helics_error_invalid_function_call = _helics.helics_error_invalid_function_call
  helics_error_execution_failure = _helics.helics_error_execution_failure
  helics_error_insufficient_space = _helics.helics_error_insufficient_space
  helics_error_other = _helics.helics_error_other
  helics_error_external_type = _helics.helics_error_external_type
  helics_property_time_delta = _helics.helics_property_time_delta
  helics_property_time_period = _helics.helics_property_time_period
  helics_property_time_offset = _helics.helics_property_time_offset
  helics_property_time_rt_lag = _helics.helics_property_time_rt_lag
  helics_property_time_rt_lead = _helics.helics_property_time_rt_lead
  helics_property_time_rt_tolerance = _helics.helics_property_time_rt_tolerance
  helics_property_time_input_delay = _helics.helics_property_time_input_delay
  helics_property_time_output_delay = _helics.helics_property_time_output_delay
  helics_property_int_max_iterations = _helics.helics_property_int_max_iterations
  helics_property_int_log_level = _helics.helics_property_int_log_level
  helics_property_int_file_log_level = _helics.helics_property_int_file_log_level
  helics_property_int_console_log_level = _helics.helics_property_int_console_log_level
  helics_handle_option_connection_required = _helics.helics_handle_option_connection_required
  helics_handle_option_connection_optional = _helics.helics_handle_option_connection_optional
  helics_handle_option_single_connection_only = _helics.helics_handle_option_single_connection_only
  helics_handle_option_multiple_connections_allowed = _helics.helics_handle_option_multiple_connections_allowed
  helics_handle_option_buffer_data = _helics.helics_handle_option_buffer_data
  helics_handle_option_strict_type_checking = _helics.helics_handle_option_strict_type_checking
  helics_handle_option_ignore_unit_mismatch = _helics.helics_handle_option_ignore_unit_mismatch
  helics_handle_option_only_transmit_on_change = _helics.helics_handle_option_only_transmit_on_change
  helics_handle_option_only_update_on_change = _helics.helics_handle_option_only_update_on_change
  helics_handle_option_ignore_interrupts = _helics.helics_handle_option_ignore_interrupts
  helics_filter_type_custom = _helics.helics_filter_type_custom
  helics_filter_type_delay = _helics.helics_filter_type_delay
  helics_filter_type_random_delay = _helics.helics_filter_type_random_delay
  helics_filter_type_random_drop = _helics.helics_filter_type_random_drop
  helics_filter_type_reroute = _helics.helics_filter_type_reroute
  helics_filter_type_clone = _helics.helics_filter_type_clone
  helics_filter_type_firewall = _helics.helics_filter_type_firewall
  helics_iteration_request_no_iteration = _helics.helics_iteration_request_no_iteration
  helics_iteration_request_force_iteration = _helics.helics_iteration_request_force_iteration
  helics_iteration_request_iterate_if_needed = _helics.helics_iteration_request_iterate_if_needed
  helics_iteration_result_next_step = _helics.helics_iteration_result_next_step
  helics_iteration_result_error = _helics.helics_iteration_result_error
  helics_iteration_result_halted = _helics.helics_iteration_result_halted
  helics_iteration_result_iterating = _helics.helics_iteration_result_iterating
  helics_state_startup = _helics.helics_state_startup
  helics_state_initialization = _helics.helics_state_initialization
  helics_state_execution = _helics.helics_state_execution
  helics_state_finalize = _helics.helics_state_finalize
  helics_state_error = _helics.helics_state_error
  helics_state_pending_init = _helics.helics_state_pending_init
  helics_state_pending_exec = _helics.helics_state_pending_exec
  helics_state_pending_time = _helics.helics_state_pending_time
  helics_state_pending_iterative_time = _helics.helics_state_pending_iterative_time
  helics_state_pending_finalize = _helics.helics_state_pending_finalize
  class helics_complex(object):
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      __repr__ = _swig_repr
      real = property(_helics.helics_complex_real_get, _helics.helics_complex_real_set)
      imag = property(_helics.helics_complex_imag_get, _helics.helics_complex_imag_set)
  
      def __init__(self):
          _helics.helics_complex_swiginit(self, _helics.new_helics_complex())
      __swig_destroy__ = _helics.delete_helics_complex
  
  # Register helics_complex in _helics:
  _helics.helics_complex_swigregister(helics_complex)
  cvar = _helics.cvar
  helics_time_zero = cvar.helics_time_zero
  helics_time_epsilon = cvar.helics_time_epsilon
  helics_time_invalid = cvar.helics_time_invalid
  helics_time_maxtime = cvar.helics_time_maxtime
  helics_true = cvar.helics_true
  helics_false = cvar.helics_false
  
  class helics_message(object):
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
      __repr__ = _swig_repr
      time = property(_helics.helics_message_time_get, _helics.helics_message_time_set)
      data = property(_helics.helics_message_data_get, _helics.helics_message_data_set)
      length = property(_helics.helics_message_length_get, _helics.helics_message_length_set)
      messageID = property(_helics.helics_message_messageID_get, _helics.helics_message_messageID_set)
      flags = property(_helics.helics_message_flags_get, _helics.helics_message_flags_set)
      original_source = property(_helics.helics_message_original_source_get, _helics.helics_message_original_source_set)
      source = property(_helics.helics_message_source_get, _helics.helics_message_source_set)
      dest = property(_helics.helics_message_dest_get, _helics.helics_message_dest_set)
      original_dest = property(_helics.helics_message_original_dest_get, _helics.helics_message_original_dest_set)
  
      def __init__(self):
          _helics.helics_message_swiginit(self, _helics.new_helics_message())
      __swig_destroy__ = _helics.delete_helics_message
  
  # Register helics_message in _helics:
  _helics.helics_message_swigregister(helics_message)
  
  
  def helicsGetVersion() -> "char const *":
      return _helics.helicsGetVersion()
  
  def helicsIsCoreTypeAvailable(type: 'char const *') -> "helics_bool":
      return _helics.helicsIsCoreTypeAvailable(type)
  
  def helicsCreateCore(type: 'char const *', name: 'char const *', initString: 'char const *') -> "helics_core":
      return _helics.helicsCreateCore(type, name, initString)
  
  def helicsCreateCoreFromArgs(type: 'char const *', name: 'char const *', argc: 'int') -> "helics_core":
      return _helics.helicsCreateCoreFromArgs(type, name, argc)
  
  def helicsCoreClone(core: 'helics_core') -> "helics_core":
      return _helics.helicsCoreClone(core)
  
  def helicsCoreIsValid(core: 'helics_core') -> "helics_bool":
      return _helics.helicsCoreIsValid(core)
  
  def helicsCreateBroker(type: 'char const *', name: 'char const *', initString: 'char const *') -> "helics_broker":
      return _helics.helicsCreateBroker(type, name, initString)
  
  def helicsCreateBrokerFromArgs(type: 'char const *', name: 'char const *', argc: 'int') -> "helics_broker":
      return _helics.helicsCreateBrokerFromArgs(type, name, argc)
  
  def helicsBrokerClone(broker: 'helics_broker') -> "helics_broker":
      return _helics.helicsBrokerClone(broker)
  
  def helicsBrokerIsValid(broker: 'helics_broker') -> "helics_bool":
      return _helics.helicsBrokerIsValid(broker)
  
  def helicsBrokerIsConnected(broker: 'helics_broker') -> "helics_bool":
      return _helics.helicsBrokerIsConnected(broker)
  
  def helicsBrokerDataLink(broker: 'helics_broker', source: 'char const *', target: 'char const *') -> "void":
      return _helics.helicsBrokerDataLink(broker, source, target)
  
  def helicsBrokerAddSourceFilterToEndpoint(broker: 'helics_broker', filter: 'char const *', endpoint: 'char const *') -> "void":
      return _helics.helicsBrokerAddSourceFilterToEndpoint(broker, filter, endpoint)
  
  def helicsBrokerAddDestinationFilterToEndpoint(broker: 'helics_broker', filter: 'char const *', endpoint: 'char const *') -> "void":
      return _helics.helicsBrokerAddDestinationFilterToEndpoint(broker, filter, endpoint)
  
  def helicsCoreWaitForDisconnect(core: 'helics_core', msToWait: 'int') -> "helics_bool":
      return _helics.helicsCoreWaitForDisconnect(core, msToWait)
  
  def helicsBrokerWaitForDisconnect(broker: 'helics_broker', msToWait: 'int') -> "helics_bool":
      return _helics.helicsBrokerWaitForDisconnect(broker, msToWait)
  
  def helicsCoreIsConnected(core: 'helics_core') -> "helics_bool":
      return _helics.helicsCoreIsConnected(core)
  
  def helicsCoreDataLink(core: 'helics_core', source: 'char const *', target: 'char const *') -> "void":
      return _helics.helicsCoreDataLink(core, source, target)
  
  def helicsCoreAddSourceFilterToEndpoint(core: 'helics_core', filter: 'char const *', endpoint: 'char const *') -> "void":
      return _helics.helicsCoreAddSourceFilterToEndpoint(core, filter, endpoint)
  
  def helicsCoreAddDestinationFilterToEndpoint(core: 'helics_core', filter: 'char const *', endpoint: 'char const *') -> "void":
      return _helics.helicsCoreAddDestinationFilterToEndpoint(core, filter, endpoint)
  
  def helicsBrokerGetIdentifier(broker: 'helics_broker') -> "char const *":
      return _helics.helicsBrokerGetIdentifier(broker)
  
  def helicsCoreGetIdentifier(core: 'helics_core') -> "char const *":
      return _helics.helicsCoreGetIdentifier(core)
  
  def helicsBrokerGetAddress(broker: 'helics_broker') -> "char const *":
      return _helics.helicsBrokerGetAddress(broker)
  
  def helicsCoreGetAddress(core: 'helics_core') -> "char const *":
      return _helics.helicsCoreGetAddress(core)
  
  def helicsCoreSetReadyToInit(core: 'helics_core') -> "void":
      return _helics.helicsCoreSetReadyToInit(core)
  
  def helicsCoreDisconnect(core: 'helics_core') -> "void":
      return _helics.helicsCoreDisconnect(core)
  
  def helicsGetFederateByName(fedName: 'char const *') -> "helics_federate":
      return _helics.helicsGetFederateByName(fedName)
  
  def helicsBrokerDisconnect(broker: 'helics_broker') -> "void":
      return _helics.helicsBrokerDisconnect(broker)
  
  def helicsFederateDestroy(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateDestroy(fed)
  
  def helicsBrokerDestroy(broker: 'helics_broker') -> "void":
      return _helics.helicsBrokerDestroy(broker)
  
  def helicsCoreDestroy(core: 'helics_core') -> "void":
      return _helics.helicsCoreDestroy(core)
  
  def helicsCoreFree(core: 'helics_core') -> "void":
      return _helics.helicsCoreFree(core)
  
  def helicsBrokerFree(broker: 'helics_broker') -> "void":
      return _helics.helicsBrokerFree(broker)
  
  def helicsCreateValueFederate(fedName: 'char const *', fi: 'helics_federate_info') -> "helics_federate":
      return _helics.helicsCreateValueFederate(fedName, fi)
  
  def helicsCreateValueFederateFromConfig(configFile: 'char const *') -> "helics_federate":
      return _helics.helicsCreateValueFederateFromConfig(configFile)
  
  def helicsCreateMessageFederate(fedName: 'char const *', fi: 'helics_federate_info') -> "helics_federate":
      return _helics.helicsCreateMessageFederate(fedName, fi)
  
  def helicsCreateMessageFederateFromConfig(configFile: 'char const *') -> "helics_federate":
      return _helics.helicsCreateMessageFederateFromConfig(configFile)
  
  def helicsCreateCombinationFederate(fedName: 'char const *', fi: 'helics_federate_info') -> "helics_federate":
      return _helics.helicsCreateCombinationFederate(fedName, fi)
  
  def helicsCreateCombinationFederateFromConfig(configFile: 'char const *') -> "helics_federate":
      return _helics.helicsCreateCombinationFederateFromConfig(configFile)
  
  def helicsFederateClone(fed: 'helics_federate') -> "helics_federate":
      return _helics.helicsFederateClone(fed)
  
  def helicsCreateFederateInfo() -> "helics_federate_info":
      return _helics.helicsCreateFederateInfo()
  
  def helicsFederateInfoClone(fi: 'helics_federate_info') -> "helics_federate_info":
      return _helics.helicsFederateInfoClone(fi)
  
  def helicsFederateInfoLoadFromArgs(fi: 'helics_federate_info', argc: 'int') -> "void":
      return _helics.helicsFederateInfoLoadFromArgs(fi, argc)
  
  def helicsFederateInfoFree(fi: 'helics_federate_info') -> "void":
      return _helics.helicsFederateInfoFree(fi)
  
  def helicsFederateIsValid(fed: 'helics_federate') -> "helics_bool":
      return _helics.helicsFederateIsValid(fed)
  
  def helicsFederateInfoSetCoreName(fi: 'helics_federate_info', corename: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetCoreName(fi, corename)
  
  def helicsFederateInfoSetCoreInitString(fi: 'helics_federate_info', coreInit: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetCoreInitString(fi, coreInit)
  
  def helicsFederateInfoSetBrokerInitString(fi: 'helics_federate_info', brokerInit: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetBrokerInitString(fi, brokerInit)
  
  def helicsFederateInfoSetCoreType(fi: 'helics_federate_info', coretype: 'int') -> "void":
      return _helics.helicsFederateInfoSetCoreType(fi, coretype)
  
  def helicsFederateInfoSetCoreTypeFromString(fi: 'helics_federate_info', coretype: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetCoreTypeFromString(fi, coretype)
  
  def helicsFederateInfoSetBroker(fi: 'helics_federate_info', broker: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetBroker(fi, broker)
  
  def helicsFederateInfoSetBrokerKey(fi: 'helics_federate_info', brokerkey: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetBrokerKey(fi, brokerkey)
  
  def helicsFederateInfoSetBrokerPort(fi: 'helics_federate_info', brokerPort: 'int') -> "void":
      return _helics.helicsFederateInfoSetBrokerPort(fi, brokerPort)
  
  def helicsFederateInfoSetLocalPort(fi: 'helics_federate_info', localPort: 'char const *') -> "void":
      return _helics.helicsFederateInfoSetLocalPort(fi, localPort)
  
  def helicsGetPropertyIndex(val: 'char const *') -> "int":
      return _helics.helicsGetPropertyIndex(val)
  
  def helicsGetOptionIndex(val: 'char const *') -> "int":
      return _helics.helicsGetOptionIndex(val)
  
  def helicsFederateInfoSetFlagOption(fi: 'helics_federate_info', flag: 'int', value: 'helics_bool') -> "void":
      return _helics.helicsFederateInfoSetFlagOption(fi, flag, value)
  
  def helicsFederateInfoSetSeparator(fi: 'helics_federate_info', separator: 'char') -> "void":
      return _helics.helicsFederateInfoSetSeparator(fi, separator)
  
  def helicsFederateInfoSetTimeProperty(fi: 'helics_federate_info', timeProperty: 'int', propertyValue: 'helics_time') -> "void":
      return _helics.helicsFederateInfoSetTimeProperty(fi, timeProperty, propertyValue)
  
  def helicsFederateInfoSetIntegerProperty(fi: 'helics_federate_info', intProperty: 'int', propertyValue: 'int') -> "void":
      return _helics.helicsFederateInfoSetIntegerProperty(fi, intProperty, propertyValue)
  
  def helicsFederateRegisterInterfaces(fed: 'helics_federate', file: 'char const *') -> "void":
      return _helics.helicsFederateRegisterInterfaces(fed, file)
  
  def helicsFederateFinalize(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateFinalize(fed)
  
  def helicsFederateFinalizeAsync(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateFinalizeAsync(fed)
  
  def helicsFederateFinalizeComplete(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateFinalizeComplete(fed)
  
  def helicsFederateFree(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateFree(fed)
  
  def helicsCloseLibrary() -> "void":
      return _helics.helicsCloseLibrary()
  
  def helicsFederateEnterInitializingMode(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateEnterInitializingMode(fed)
  
  def helicsFederateEnterInitializingModeAsync(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateEnterInitializingModeAsync(fed)
  
  def helicsFederateIsAsyncOperationCompleted(fed: 'helics_federate') -> "helics_bool":
      return _helics.helicsFederateIsAsyncOperationCompleted(fed)
  
  def helicsFederateEnterInitializingModeComplete(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateEnterInitializingModeComplete(fed)
  
  def helicsFederateEnterExecutingMode(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateEnterExecutingMode(fed)
  
  def helicsFederateEnterExecutingModeAsync(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateEnterExecutingModeAsync(fed)
  
  def helicsFederateEnterExecutingModeComplete(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateEnterExecutingModeComplete(fed)
  
  def helicsFederateEnterExecutingModeIterative(fed: 'helics_federate', iterate: 'helics_iteration_request') -> "helics_iteration_result":
      return _helics.helicsFederateEnterExecutingModeIterative(fed, iterate)
  
  def helicsFederateEnterExecutingModeIterativeAsync(fed: 'helics_federate', iterate: 'helics_iteration_request') -> "void":
      return _helics.helicsFederateEnterExecutingModeIterativeAsync(fed, iterate)
  
  def helicsFederateEnterExecutingModeIterativeComplete(fed: 'helics_federate') -> "helics_iteration_result":
      return _helics.helicsFederateEnterExecutingModeIterativeComplete(fed)
  
  def helicsFederateGetState(fed: 'helics_federate') -> "helics_federate_state":
      return _helics.helicsFederateGetState(fed)
  
  def helicsFederateGetCoreObject(fed: 'helics_federate') -> "helics_core":
      return _helics.helicsFederateGetCoreObject(fed)
  
  def helicsFederateRequestTime(fed: 'helics_federate', requestTime: 'helics_time') -> "helics_time":
      return _helics.helicsFederateRequestTime(fed, requestTime)
  
  def helicsFederateRequestTimeAdvance(fed: 'helics_federate', timeDelta: 'helics_time') -> "helics_time":
      return _helics.helicsFederateRequestTimeAdvance(fed, timeDelta)
  
  def helicsFederateRequestNextStep(fed: 'helics_federate') -> "helics_time":
      return _helics.helicsFederateRequestNextStep(fed)
  
  def helicsFederateRequestTimeIterative(fed: 'helics_federate', requestTime: 'helics_time', iterate: 'helics_iteration_request') -> "helics_iteration_result *":
      return _helics.helicsFederateRequestTimeIterative(fed, requestTime, iterate)
  
  def helicsFederateRequestTimeAsync(fed: 'helics_federate', requestTime: 'helics_time') -> "void":
      return _helics.helicsFederateRequestTimeAsync(fed, requestTime)
  
  def helicsFederateRequestTimeComplete(fed: 'helics_federate') -> "helics_time":
      return _helics.helicsFederateRequestTimeComplete(fed)
  
  def helicsFederateRequestTimeIterativeAsync(fed: 'helics_federate', requestTime: 'helics_time', iterate: 'helics_iteration_request') -> "void":
      return _helics.helicsFederateRequestTimeIterativeAsync(fed, requestTime, iterate)
  
  def helicsFederateRequestTimeIterativeComplete(fed: 'helics_federate') -> "helics_iteration_result *":
      return _helics.helicsFederateRequestTimeIterativeComplete(fed)
  
  def helicsFederateGetName(fed: 'helics_federate') -> "char const *":
      return _helics.helicsFederateGetName(fed)
  
  def helicsFederateSetTimeProperty(fed: 'helics_federate', timeProperty: 'int', time: 'helics_time') -> "void":
      return _helics.helicsFederateSetTimeProperty(fed, timeProperty, time)
  
  def helicsFederateSetFlagOption(fed: 'helics_federate', flag: 'int', flagValue: 'helics_bool') -> "void":
      return _helics.helicsFederateSetFlagOption(fed, flag, flagValue)
  
  def helicsFederateSetSeparator(fed: 'helics_federate', separator: 'char') -> "void":
      return _helics.helicsFederateSetSeparator(fed, separator)
  
  def helicsFederateSetIntegerProperty(fed: 'helics_federate', intProperty: 'int', propertyVal: 'int') -> "void":
      return _helics.helicsFederateSetIntegerProperty(fed, intProperty, propertyVal)
  
  def helicsFederateGetTimeProperty(fed: 'helics_federate', timeProperty: 'int') -> "helics_time":
      return _helics.helicsFederateGetTimeProperty(fed, timeProperty)
  
  def helicsFederateGetFlagOption(fed: 'helics_federate', flag: 'int') -> "helics_bool":
      return _helics.helicsFederateGetFlagOption(fed, flag)
  
  def helicsFederateGetIntegerProperty(fed: 'helics_federate', intProperty: 'int') -> "int":
      return _helics.helicsFederateGetIntegerProperty(fed, intProperty)
  
  def helicsFederateGetCurrentTime(fed: 'helics_federate') -> "helics_time":
      return _helics.helicsFederateGetCurrentTime(fed)
  
  def helicsFederateSetGlobal(fed: 'helics_federate', valueName: 'char const *', value: 'char const *') -> "void":
      return _helics.helicsFederateSetGlobal(fed, valueName, value)
  
  def helicsFederateSetLogFile(fed: 'helics_federate', logFile: 'char const *') -> "void":
      return _helics.helicsFederateSetLogFile(fed, logFile)
  
  def helicsFederateLogErrorMessage(fed: 'helics_federate', logmessage: 'char const *') -> "void":
      return _helics.helicsFederateLogErrorMessage(fed, logmessage)
  
  def helicsFederateLogWarningMessage(fed: 'helics_federate', logmessage: 'char const *') -> "void":
      return _helics.helicsFederateLogWarningMessage(fed, logmessage)
  
  def helicsFederateLogInfoMessage(fed: 'helics_federate', logmessage: 'char const *') -> "void":
      return _helics.helicsFederateLogInfoMessage(fed, logmessage)
  
  def helicsFederateLogDebugMessage(fed: 'helics_federate', logmessage: 'char const *') -> "void":
      return _helics.helicsFederateLogDebugMessage(fed, logmessage)
  
  def helicsFederateLogLevelMessage(fed: 'helics_federate', loglevel: 'int', logmessage: 'char const *') -> "void":
      return _helics.helicsFederateLogLevelMessage(fed, loglevel, logmessage)
  
  def helicsCoreSetGlobal(core: 'helics_core', valueName: 'char const *', value: 'char const *') -> "void":
      return _helics.helicsCoreSetGlobal(core, valueName, value)
  
  def helicsBrokerSetGlobal(broker: 'helics_broker', valueName: 'char const *', value: 'char const *') -> "void":
      return _helics.helicsBrokerSetGlobal(broker, valueName, value)
  
  def helicsCoreSetLogFile(core: 'helics_core', logFileName: 'char const *') -> "void":
      return _helics.helicsCoreSetLogFile(core, logFileName)
  
  def helicsBrokerSetLogFile(broker: 'helics_broker', logFileName: 'char const *') -> "void":
      return _helics.helicsBrokerSetLogFile(broker, logFileName)
  
  def helicsCreateQuery(target: 'char const *', query: 'char const *') -> "helics_query":
      return _helics.helicsCreateQuery(target, query)
  
  def helicsQueryExecute(query: 'helics_query', fed: 'helics_federate') -> "char const *":
      return _helics.helicsQueryExecute(query, fed)
  
  def helicsQueryCoreExecute(query: 'helics_query', core: 'helics_core') -> "char const *":
      return _helics.helicsQueryCoreExecute(query, core)
  
  def helicsQueryBrokerExecute(query: 'helics_query', broker: 'helics_broker') -> "char const *":
      return _helics.helicsQueryBrokerExecute(query, broker)
  
  def helicsQueryExecuteAsync(query: 'helics_query', fed: 'helics_federate') -> "void":
      return _helics.helicsQueryExecuteAsync(query, fed)
  
  def helicsQueryExecuteComplete(query: 'helics_query') -> "char const *":
      return _helics.helicsQueryExecuteComplete(query)
  
  def helicsQueryIsCompleted(query: 'helics_query') -> "helics_bool":
      return _helics.helicsQueryIsCompleted(query)
  
  def helicsQueryFree(query: 'helics_query') -> "void":
      return _helics.helicsQueryFree(query)
  
  def helicsCleanupLibrary() -> "void":
      return _helics.helicsCleanupLibrary()
  
  def helicsFederateRegisterSubscription(fed: 'helics_federate', key: 'char const *', units: 'char const *') -> "helics_input":
      return _helics.helicsFederateRegisterSubscription(fed, key, units)
  
  def helicsFederateRegisterPublication(fed: 'helics_federate', key: 'char const *', type: 'helics_data_type', units: 'char const *') -> "helics_publication":
      return _helics.helicsFederateRegisterPublication(fed, key, type, units)
  
  def helicsFederateRegisterTypePublication(fed: 'helics_federate', key: 'char const *', type: 'char const *', units: 'char const *') -> "helics_publication":
      return _helics.helicsFederateRegisterTypePublication(fed, key, type, units)
  
  def helicsFederateRegisterGlobalPublication(fed: 'helics_federate', key: 'char const *', type: 'helics_data_type', units: 'char const *') -> "helics_publication":
      return _helics.helicsFederateRegisterGlobalPublication(fed, key, type, units)
  
  def helicsFederateRegisterGlobalTypePublication(fed: 'helics_federate', key: 'char const *', type: 'char const *', units: 'char const *') -> "helics_publication":
      return _helics.helicsFederateRegisterGlobalTypePublication(fed, key, type, units)
  
  def helicsFederateRegisterInput(fed: 'helics_federate', key: 'char const *', type: 'helics_data_type', units: 'char const *') -> "helics_input":
      return _helics.helicsFederateRegisterInput(fed, key, type, units)
  
  def helicsFederateRegisterTypeInput(fed: 'helics_federate', key: 'char const *', type: 'char const *', units: 'char const *') -> "helics_input":
      return _helics.helicsFederateRegisterTypeInput(fed, key, type, units)
  
  def helicsFederateRegisterGlobalInput(fed: 'helics_federate', key: 'char const *', type: 'helics_data_type', units: 'char const *') -> "helics_publication":
      return _helics.helicsFederateRegisterGlobalInput(fed, key, type, units)
  
  def helicsFederateRegisterGlobalTypeInput(fed: 'helics_federate', key: 'char const *', type: 'char const *', units: 'char const *') -> "helics_publication":
      return _helics.helicsFederateRegisterGlobalTypeInput(fed, key, type, units)
  
  def helicsFederateGetPublication(fed: 'helics_federate', key: 'char const *') -> "helics_publication":
      return _helics.helicsFederateGetPublication(fed, key)
  
  def helicsFederateGetPublicationByIndex(fed: 'helics_federate', index: 'int') -> "helics_publication":
      return _helics.helicsFederateGetPublicationByIndex(fed, index)
  
  def helicsFederateGetInput(fed: 'helics_federate', key: 'char const *') -> "helics_input":
      return _helics.helicsFederateGetInput(fed, key)
  
  def helicsFederateGetInputByIndex(fed: 'helics_federate', index: 'int') -> "helics_input":
      return _helics.helicsFederateGetInputByIndex(fed, index)
  
  def helicsFederateGetSubscription(fed: 'helics_federate', key: 'char const *') -> "helics_input":
      return _helics.helicsFederateGetSubscription(fed, key)
  
  def helicsFederateClearUpdates(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateClearUpdates(fed)
  
  def helicsFederateRegisterFromPublicationJSON(fed: 'helics_federate', json: 'char const *') -> "void":
      return _helics.helicsFederateRegisterFromPublicationJSON(fed, json)
  
  def helicsFederatePublishJSON(fed: 'helics_federate', json: 'char const *') -> "void":
      return _helics.helicsFederatePublishJSON(fed, json)
  
  def helicsPublicationPublishRaw(pub: 'helics_publication', data: 'void const *') -> "int":
      return _helics.helicsPublicationPublishRaw(pub, data)
  
  def helicsPublicationPublishString(pub: 'helics_publication', str: 'char const *') -> "void":
      return _helics.helicsPublicationPublishString(pub, str)
  
  def helicsPublicationPublishInteger(pub: 'helics_publication', val: 'int64_t') -> "void":
      return _helics.helicsPublicationPublishInteger(pub, val)
  
  def helicsPublicationPublishBoolean(pub: 'helics_publication', val: 'helics_bool') -> "void":
      return _helics.helicsPublicationPublishBoolean(pub, val)
  
  def helicsPublicationPublishDouble(pub: 'helics_publication', val: 'double') -> "void":
      return _helics.helicsPublicationPublishDouble(pub, val)
  
  def helicsPublicationPublishTime(pub: 'helics_publication', val: 'helics_time') -> "void":
      return _helics.helicsPublicationPublishTime(pub, val)
  
  def helicsPublicationPublishChar(pub: 'helics_publication', val: 'char') -> "void":
      return _helics.helicsPublicationPublishChar(pub, val)
  
  def helicsPublicationPublishComplex(pub: 'helics_publication', real: 'double', imag: 'double') -> "void":
      return _helics.helicsPublicationPublishComplex(pub, real, imag)
  
  def helicsPublicationPublishVector(pub: 'helics_publication', vectorInput: 'double const *') -> "int":
      return _helics.helicsPublicationPublishVector(pub, vectorInput)
  
  def helicsPublicationPublishNamedPoint(pub: 'helics_publication', str: 'char const *', val: 'double') -> "void":
      return _helics.helicsPublicationPublishNamedPoint(pub, str, val)
  
  def helicsPublicationAddTarget(pub: 'helics_publication', target: 'char const *') -> "void":
      return _helics.helicsPublicationAddTarget(pub, target)
  
  def helicsInputAddTarget(ipt: 'helics_input', target: 'char const *') -> "void":
      return _helics.helicsInputAddTarget(ipt, target)
  
  def helicsInputGetRawValueSize(ipt: 'helics_input') -> "int":
      return _helics.helicsInputGetRawValueSize(ipt)
  
  def helicsInputGetRawValue(ipt: 'helics_input', data: 'void *', maxlen: 'int') -> "int *":
      return _helics.helicsInputGetRawValue(ipt, data, maxlen)
  
  def helicsInputGetStringSize(ipt: 'helics_input') -> "int":
      return _helics.helicsInputGetStringSize(ipt)
  
  def helicsInputGetString(ipt: 'helics_input') -> "int *":
      return _helics.helicsInputGetString(ipt)
  
  def helicsInputGetInteger(ipt: 'helics_input') -> "int64_t":
      return _helics.helicsInputGetInteger(ipt)
  
  def helicsInputGetBoolean(ipt: 'helics_input') -> "helics_bool":
      return _helics.helicsInputGetBoolean(ipt)
  
  def helicsInputGetDouble(ipt: 'helics_input') -> "double":
      return _helics.helicsInputGetDouble(ipt)
  
  def helicsInputGetTime(ipt: 'helics_input') -> "helics_time":
      return _helics.helicsInputGetTime(ipt)
  
  def helicsInputGetChar(ipt: 'helics_input') -> "char":
      return _helics.helicsInputGetChar(ipt)
  
  def helicsInputGetComplexObject(ipt: 'helics_input') -> "helics_complex":
      return _helics.helicsInputGetComplexObject(ipt)
  
  def helicsInputGetComplex(ipt: 'helics_input') -> "double *, double *":
      return _helics.helicsInputGetComplex(ipt)
  
  def helicsInputGetVectorSize(ipt: 'helics_input') -> "int":
      return _helics.helicsInputGetVectorSize(ipt)
  
  def helicsInputGetVector(ipt: 'helics_input') -> "int *":
      return _helics.helicsInputGetVector(ipt)
  
  def helicsInputGetNamedPoint(ipt: 'helics_input') -> "int *, double *":
      return _helics.helicsInputGetNamedPoint(ipt)
  
  def helicsInputSetDefaultRaw(ipt: 'helics_input', data: 'void const *') -> "int":
      return _helics.helicsInputSetDefaultRaw(ipt, data)
  
  def helicsInputSetDefaultString(ipt: 'helics_input', str: 'char const *') -> "void":
      return _helics.helicsInputSetDefaultString(ipt, str)
  
  def helicsInputSetDefaultInteger(ipt: 'helics_input', val: 'int64_t') -> "void":
      return _helics.helicsInputSetDefaultInteger(ipt, val)
  
  def helicsInputSetDefaultBoolean(ipt: 'helics_input', val: 'helics_bool') -> "void":
      return _helics.helicsInputSetDefaultBoolean(ipt, val)
  
  def helicsInputSetDefaultTime(ipt: 'helics_input', val: 'helics_time') -> "void":
      return _helics.helicsInputSetDefaultTime(ipt, val)
  
  def helicsInputSetDefaultChar(ipt: 'helics_input', val: 'char') -> "void":
      return _helics.helicsInputSetDefaultChar(ipt, val)
  
  def helicsInputSetDefaultDouble(ipt: 'helics_input', val: 'double') -> "void":
      return _helics.helicsInputSetDefaultDouble(ipt, val)
  
  def helicsInputSetDefaultComplex(ipt: 'helics_input', real: 'double', imag: 'double') -> "void":
      return _helics.helicsInputSetDefaultComplex(ipt, real, imag)
  
  def helicsInputSetDefaultVector(ipt: 'helics_input', vectorInput: 'double const *') -> "int":
      return _helics.helicsInputSetDefaultVector(ipt, vectorInput)
  
  def helicsInputSetDefaultNamedPoint(ipt: 'helics_input', str: 'char const *', val: 'double') -> "void":
      return _helics.helicsInputSetDefaultNamedPoint(ipt, str, val)
  
  def helicsInputGetType(ipt: 'helics_input') -> "char const *":
      return _helics.helicsInputGetType(ipt)
  
  def helicsInputGetPublicationType(ipt: 'helics_input') -> "char const *":
      return _helics.helicsInputGetPublicationType(ipt)
  
  def helicsPublicationGetType(pub: 'helics_publication') -> "char const *":
      return _helics.helicsPublicationGetType(pub)
  
  def helicsInputGetKey(ipt: 'helics_input') -> "char const *":
      return _helics.helicsInputGetKey(ipt)
  
  def helicsSubscriptionGetKey(ipt: 'helics_input') -> "char const *":
      return _helics.helicsSubscriptionGetKey(ipt)
  
  def helicsPublicationGetKey(pub: 'helics_publication') -> "char const *":
      return _helics.helicsPublicationGetKey(pub)
  
  def helicsInputGetUnits(ipt: 'helics_input') -> "char const *":
      return _helics.helicsInputGetUnits(ipt)
  
  def helicsInputGetInjectionUnits(ipt: 'helics_input') -> "char const *":
      return _helics.helicsInputGetInjectionUnits(ipt)
  
  def helicsInputGetExtractionUnits(ipt: 'helics_input') -> "char const *":
      return _helics.helicsInputGetExtractionUnits(ipt)
  
  def helicsPublicationGetUnits(pub: 'helics_publication') -> "char const *":
      return _helics.helicsPublicationGetUnits(pub)
  
  def helicsInputGetInfo(inp: 'helics_input') -> "char const *":
      return _helics.helicsInputGetInfo(inp)
  
  def helicsInputSetInfo(inp: 'helics_input', info: 'char const *') -> "void":
      return _helics.helicsInputSetInfo(inp, info)
  
  def helicsPublicationGetInfo(pub: 'helics_publication') -> "char const *":
      return _helics.helicsPublicationGetInfo(pub)
  
  def helicsPublicationSetInfo(pub: 'helics_publication', info: 'char const *') -> "void":
      return _helics.helicsPublicationSetInfo(pub, info)
  
  def helicsInputGetOption(inp: 'helics_input', option: 'int') -> "helics_bool":
      return _helics.helicsInputGetOption(inp, option)
  
  def helicsInputSetOption(inp: 'helics_input', option: 'int', value: 'helics_bool') -> "void":
      return _helics.helicsInputSetOption(inp, option, value)
  
  def helicsPublicationGetOption(pub: 'helics_publication', option: 'int') -> "helics_bool":
      return _helics.helicsPublicationGetOption(pub, option)
  
  def helicsPublicationSetOption(pub: 'helics_publication', option: 'int', val: 'helics_bool') -> "void":
      return _helics.helicsPublicationSetOption(pub, option, val)
  
  def helicsInputIsUpdated(ipt: 'helics_input') -> "helics_bool":
      return _helics.helicsInputIsUpdated(ipt)
  
  def helicsInputLastUpdateTime(ipt: 'helics_input') -> "helics_time":
      return _helics.helicsInputLastUpdateTime(ipt)
  
  def helicsInputClearUpdate(ipt: 'helics_input') -> "void":
      return _helics.helicsInputClearUpdate(ipt)
  
  def helicsFederateGetPublicationCount(fed: 'helics_federate') -> "int":
      return _helics.helicsFederateGetPublicationCount(fed)
  
  def helicsFederateGetInputCount(fed: 'helics_federate') -> "int":
      return _helics.helicsFederateGetInputCount(fed)
  
  def helicsFederateRegisterEndpoint(fed: 'helics_federate', name: 'char const *', type: 'char const *') -> "helics_endpoint":
      return _helics.helicsFederateRegisterEndpoint(fed, name, type)
  
  def helicsFederateRegisterGlobalEndpoint(fed: 'helics_federate', name: 'char const *', type: 'char const *') -> "helics_endpoint":
      return _helics.helicsFederateRegisterGlobalEndpoint(fed, name, type)
  
  def helicsFederateGetEndpoint(fed: 'helics_federate', name: 'char const *') -> "helics_endpoint":
      return _helics.helicsFederateGetEndpoint(fed, name)
  
  def helicsFederateGetEndpointByIndex(fed: 'helics_federate', index: 'int') -> "helics_endpoint":
      return _helics.helicsFederateGetEndpointByIndex(fed, index)
  
  def helicsEndpointSetDefaultDestination(endpoint: 'helics_endpoint', dest: 'char const *') -> "void":
      return _helics.helicsEndpointSetDefaultDestination(endpoint, dest)
  
  def helicsEndpointGetDefaultDestination(endpoint: 'helics_endpoint') -> "char const *":
      return _helics.helicsEndpointGetDefaultDestination(endpoint)
  
  def helicsEndpointSendMessageRaw(endpoint: 'helics_endpoint', dest: 'char const *', data: 'void const *') -> "int":
      return _helics.helicsEndpointSendMessageRaw(endpoint, dest, data)
  
  def helicsEndpointSendEventRaw(endpoint: 'helics_endpoint', dest: 'char const *', data: 'void const *', time: 'helics_time') -> "int":
      return _helics.helicsEndpointSendEventRaw(endpoint, dest, data, time)
  
  def helicsEndpointSendMessage(endpoint: 'helics_endpoint', message: 'helics_message') -> "void":
      return _helics.helicsEndpointSendMessage(endpoint, message)
  
  def helicsEndpointSendMessageObject(endpoint: 'helics_endpoint', message: 'helics_message_object') -> "void":
      return _helics.helicsEndpointSendMessageObject(endpoint, message)
  
  def helicsEndpointSubscribe(endpoint: 'helics_endpoint', key: 'char const *') -> "void":
      return _helics.helicsEndpointSubscribe(endpoint, key)
  
  def helicsFederateHasMessage(fed: 'helics_federate') -> "helics_bool":
      return _helics.helicsFederateHasMessage(fed)
  
  def helicsEndpointHasMessage(endpoint: 'helics_endpoint') -> "helics_bool":
      return _helics.helicsEndpointHasMessage(endpoint)
  
  def helicsFederatePendingMessages(fed: 'helics_federate') -> "int":
      return _helics.helicsFederatePendingMessages(fed)
  
  def helicsEndpointPendingMessages(endpoint: 'helics_endpoint') -> "int":
      return _helics.helicsEndpointPendingMessages(endpoint)
  
  def helicsEndpointGetMessage(endpoint: 'helics_endpoint') -> "helics_message":
      return _helics.helicsEndpointGetMessage(endpoint)
  
  def helicsEndpointGetMessageObject(endpoint: 'helics_endpoint') -> "helics_message_object":
      return _helics.helicsEndpointGetMessageObject(endpoint)
  
  def helicsFederateGetMessage(fed: 'helics_federate') -> "helics_message":
      return _helics.helicsFederateGetMessage(fed)
  
  def helicsFederateGetMessageObject(fed: 'helics_federate') -> "helics_message_object":
      return _helics.helicsFederateGetMessageObject(fed)
  
  def helicsFederateCreateMessageObject(fed: 'helics_federate') -> "helics_message_object":
      return _helics.helicsFederateCreateMessageObject(fed)
  
  def helicsFederateClearMessages(fed: 'helics_federate') -> "void":
      return _helics.helicsFederateClearMessages(fed)
  
  def helicsEndpointClearMessages(endpoint: 'helics_endpoint') -> "void":
      return _helics.helicsEndpointClearMessages(endpoint)
  
  def helicsEndpointGetType(endpoint: 'helics_endpoint') -> "char const *":
      return _helics.helicsEndpointGetType(endpoint)
  
  def helicsEndpointGetName(endpoint: 'helics_endpoint') -> "char const *":
      return _helics.helicsEndpointGetName(endpoint)
  
  def helicsFederateGetEndpointCount(fed: 'helics_federate') -> "int":
      return _helics.helicsFederateGetEndpointCount(fed)
  
  def helicsEndpointGetInfo(end: 'helics_endpoint') -> "char const *":
      return _helics.helicsEndpointGetInfo(end)
  
  def helicsEndpointSetInfo(end: 'helics_endpoint', info: 'char const *') -> "void":
      return _helics.helicsEndpointSetInfo(end, info)
  
  def helicsEndpointSetOption(end: 'helics_endpoint', option: 'int', value: 'helics_bool') -> "void":
      return _helics.helicsEndpointSetOption(end, option, value)
  
  def helicsEndpointGetOption(end: 'helics_endpoint', option: 'int') -> "helics_bool":
      return _helics.helicsEndpointGetOption(end, option)
  
  def helicsMessageGetSource(message: 'helics_message_object') -> "char const *":
      return _helics.helicsMessageGetSource(message)
  
  def helicsMessageGetDestination(message: 'helics_message_object') -> "char const *":
      return _helics.helicsMessageGetDestination(message)
  
  def helicsMessageGetOriginalSource(message: 'helics_message_object') -> "char const *":
      return _helics.helicsMessageGetOriginalSource(message)
  
  def helicsMessageGetOriginalDestination(message: 'helics_message_object') -> "char const *":
      return _helics.helicsMessageGetOriginalDestination(message)
  
  def helicsMessageGetTime(message: 'helics_message_object') -> "helics_time":
      return _helics.helicsMessageGetTime(message)
  
  def helicsMessageGetString(message: 'helics_message_object') -> "char const *":
      return _helics.helicsMessageGetString(message)
  
  def helicsMessageGetMessageID(message: 'helics_message_object') -> "int":
      return _helics.helicsMessageGetMessageID(message)
  
  def helicsMessageCheckFlag(message: 'helics_message_object', flag: 'int') -> "helics_bool":
      return _helics.helicsMessageCheckFlag(message, flag)
  
  def helicsMessageGetRawDataSize(message: 'helics_message_object') -> "int":
      return _helics.helicsMessageGetRawDataSize(message)
  
  def helicsMessageGetRawData(message: 'helics_message_object', data: 'void *', maxlen: 'int') -> "int *":
      return _helics.helicsMessageGetRawData(message, data, maxlen)
  
  def helicsMessageIsValid(message: 'helics_message_object') -> "helics_bool":
      return _helics.helicsMessageIsValid(message)
  
  def helicsMessageSetSource(message: 'helics_message_object', src: 'char const *') -> "void":
      return _helics.helicsMessageSetSource(message, src)
  
  def helicsMessageSetDestination(message: 'helics_message_object', dest: 'char const *') -> "void":
      return _helics.helicsMessageSetDestination(message, dest)
  
  def helicsMessageSetOriginalSource(message: 'helics_message_object', src: 'char const *') -> "void":
      return _helics.helicsMessageSetOriginalSource(message, src)
  
  def helicsMessageSetOriginalDestination(message: 'helics_message_object', dest: 'char const *') -> "void":
      return _helics.helicsMessageSetOriginalDestination(message, dest)
  
  def helicsMessageSetTime(message: 'helics_message_object', time: 'helics_time') -> "void":
      return _helics.helicsMessageSetTime(message, time)
  
  def helicsMessageReserve(message: 'helics_message_object', reserveSize: 'int') -> "void":
      return _helics.helicsMessageReserve(message, reserveSize)
  
  def helicsMessageSetMessageID(message: 'helics_message_object', messageID: 'int32_t') -> "void":
      return _helics.helicsMessageSetMessageID(message, messageID)
  
  def helicsMessageClearFlags(message: 'helics_message_object') -> "void":
      return _helics.helicsMessageClearFlags(message)
  
  def helicsMessageSetFlagOption(message: 'helics_message_object', flag: 'int', flagValue: 'helics_bool') -> "void":
      return _helics.helicsMessageSetFlagOption(message, flag, flagValue)
  
  def helicsMessageSetString(message: 'helics_message_object', str: 'char const *') -> "void":
      return _helics.helicsMessageSetString(message, str)
  
  def helicsMessageSetData(message: 'helics_message_object', data: 'void const *') -> "int":
      return _helics.helicsMessageSetData(message, data)
  
  def helicsMessageAppendData(message: 'helics_message_object', data: 'void const *') -> "int":
      return _helics.helicsMessageAppendData(message, data)
  
  def helicsFederateRegisterFilter(fed: 'helics_federate', type: 'helics_filter_type', name: 'char const *') -> "helics_filter":
      return _helics.helicsFederateRegisterFilter(fed, type, name)
  
  def helicsFederateRegisterGlobalFilter(fed: 'helics_federate', type: 'helics_filter_type', name: 'char const *') -> "helics_filter":
      return _helics.helicsFederateRegisterGlobalFilter(fed, type, name)
  
  def helicsFederateRegisterCloningFilter(fed: 'helics_federate', deliveryEndpoint: 'char const *') -> "helics_filter":
      return _helics.helicsFederateRegisterCloningFilter(fed, deliveryEndpoint)
  
  def helicsFederateRegisterGlobalCloningFilter(fed: 'helics_federate', deliveryEndpoint: 'char const *') -> "helics_filter":
      return _helics.helicsFederateRegisterGlobalCloningFilter(fed, deliveryEndpoint)
  
  def helicsCoreRegisterFilter(core: 'helics_core', type: 'helics_filter_type', name: 'char const *') -> "helics_filter":
      return _helics.helicsCoreRegisterFilter(core, type, name)
  
  def helicsCoreRegisterCloningFilter(core: 'helics_core', deliveryEndpoint: 'char const *') -> "helics_filter":
      return _helics.helicsCoreRegisterCloningFilter(core, deliveryEndpoint)
  
  def helicsFederateGetFilterCount(fed: 'helics_federate') -> "int":
      return _helics.helicsFederateGetFilterCount(fed)
  
  def helicsFederateGetFilter(fed: 'helics_federate', name: 'char const *') -> "helics_filter":
      return _helics.helicsFederateGetFilter(fed, name)
  
  def helicsFederateGetFilterByIndex(fed: 'helics_federate', index: 'int') -> "helics_filter":
      return _helics.helicsFederateGetFilterByIndex(fed, index)
  
  def helicsFilterGetName(filt: 'helics_filter') -> "char const *":
      return _helics.helicsFilterGetName(filt)
  
  def helicsFilterSet(filt: 'helics_filter', prop: 'char const *', val: 'double') -> "void":
      return _helics.helicsFilterSet(filt, prop, val)
  
  def helicsFilterSetString(filt: 'helics_filter', prop: 'char const *', val: 'char const *') -> "void":
      return _helics.helicsFilterSetString(filt, prop, val)
  
  def helicsFilterAddDestinationTarget(filt: 'helics_filter', dest: 'char const *') -> "void":
      return _helics.helicsFilterAddDestinationTarget(filt, dest)
  
  def helicsFilterAddSourceTarget(filt: 'helics_filter', source: 'char const *') -> "void":
      return _helics.helicsFilterAddSourceTarget(filt, source)
  
  def helicsFilterAddDeliveryEndpoint(filt: 'helics_filter', deliveryEndpoint: 'char const *') -> "void":
      return _helics.helicsFilterAddDeliveryEndpoint(filt, deliveryEndpoint)
  
  def helicsFilterRemoveTarget(filt: 'helics_filter', target: 'char const *') -> "void":
      return _helics.helicsFilterRemoveTarget(filt, target)
  
  def helicsFilterRemoveDeliveryEndpoint(filt: 'helics_filter', deliveryEndpoint: 'char const *') -> "void":
      return _helics.helicsFilterRemoveDeliveryEndpoint(filt, deliveryEndpoint)
  
  def helicsFilterGetInfo(filt: 'helics_filter') -> "char const *":
      return _helics.helicsFilterGetInfo(filt)
  
  def helicsFilterSetInfo(filt: 'helics_filter', info: 'char const *') -> "void":
      return _helics.helicsFilterSetInfo(filt, info)
  
  def helicsFilterSetOption(filt: 'helics_filter', option: 'int', value: 'helics_bool') -> "void":
      return _helics.helicsFilterSetOption(filt, option, value)
  
  def helicsFilterGetOption(filt: 'helics_filter', option: 'int') -> "helics_bool":
      return _helics.helicsFilterGetOption(filt, option)
  
  
  