# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.38
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        try:
            fp, pathname, description = imp.find_module('_lilv', [dirname(__file__)])
            _mod = imp.load_module('_lilv', fp, pathname, description)
        finally:
            if fp is not None: fp.close()
        return _mod
    _lilv = swig_import_helper()
    del swig_import_helper
else:
    import _lilv
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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) or hasattr(self,name):
        self.__dict__[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(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


LILV_NS_DOAP = _lilv.LILV_NS_DOAP
LILV_NS_FOAF = _lilv.LILV_NS_FOAF
LILV_NS_LILV = _lilv.LILV_NS_LILV
LILV_NS_LV2 = _lilv.LILV_NS_LV2
LILV_NS_RDF = _lilv.LILV_NS_RDF
LILV_NS_RDFS = _lilv.LILV_NS_RDFS
LILV_NS_XSD = _lilv.LILV_NS_XSD
LILV_URI_AUDIO_PORT = _lilv.LILV_URI_AUDIO_PORT
LILV_URI_CONTROL_PORT = _lilv.LILV_URI_CONTROL_PORT
LILV_URI_EVENT_PORT = _lilv.LILV_URI_EVENT_PORT
LILV_URI_INPUT_PORT = _lilv.LILV_URI_INPUT_PORT
LILV_URI_MIDI_EVENT = _lilv.LILV_URI_MIDI_EVENT
LILV_URI_OUTPUT_PORT = _lilv.LILV_URI_OUTPUT_PORT
LILV_URI_PORT = _lilv.LILV_URI_PORT

def lilv_uri_to_path(*args):
  """lilv_uri_to_path(char uri) -> char"""
  return _lilv.lilv_uri_to_path(*args)

def lilv_new_uri(*args):
  """lilv_new_uri(LilvWorld world, char uri) -> LilvNode"""
  return _lilv.lilv_new_uri(*args)

def lilv_new_string(*args):
  """lilv_new_string(LilvWorld world, char str) -> LilvNode"""
  return _lilv.lilv_new_string(*args)

def lilv_new_int(*args):
  """lilv_new_int(LilvWorld world, int val) -> LilvNode"""
  return _lilv.lilv_new_int(*args)

def lilv_new_float(*args):
  """lilv_new_float(LilvWorld world, float val) -> LilvNode"""
  return _lilv.lilv_new_float(*args)

def lilv_new_bool(*args):
  """lilv_new_bool(LilvWorld world, bool val) -> LilvNode"""
  return _lilv.lilv_new_bool(*args)

def lilv_node_free(*args):
  """lilv_node_free(LilvNode val)"""
  return _lilv.lilv_node_free(*args)

def lilv_node_duplicate(*args):
  """lilv_node_duplicate(LilvNode val) -> LilvNode"""
  return _lilv.lilv_node_duplicate(*args)

def lilv_node_equals(*args):
  """lilv_node_equals(LilvNode value, LilvNode other) -> bool"""
  return _lilv.lilv_node_equals(*args)

def lilv_node_get_turtle_token(*args):
  """lilv_node_get_turtle_token(LilvNode value) -> char"""
  return _lilv.lilv_node_get_turtle_token(*args)

def lilv_node_is_uri(*args):
  """lilv_node_is_uri(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_uri(*args)

def lilv_node_as_uri(*args):
  """lilv_node_as_uri(LilvNode value) -> char"""
  return _lilv.lilv_node_as_uri(*args)

def lilv_node_is_blank(*args):
  """lilv_node_is_blank(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_blank(*args)

def lilv_node_as_blank(*args):
  """lilv_node_as_blank(LilvNode value) -> char"""
  return _lilv.lilv_node_as_blank(*args)

def lilv_node_is_literal(*args):
  """lilv_node_is_literal(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_literal(*args)

def lilv_node_is_string(*args):
  """lilv_node_is_string(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_string(*args)

def lilv_node_as_string(*args):
  """lilv_node_as_string(LilvNode value) -> char"""
  return _lilv.lilv_node_as_string(*args)

def lilv_node_is_float(*args):
  """lilv_node_is_float(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_float(*args)

def lilv_node_as_float(*args):
  """lilv_node_as_float(LilvNode value) -> float"""
  return _lilv.lilv_node_as_float(*args)

def lilv_node_is_int(*args):
  """lilv_node_is_int(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_int(*args)

def lilv_node_as_int(*args):
  """lilv_node_as_int(LilvNode value) -> int"""
  return _lilv.lilv_node_as_int(*args)

def lilv_node_is_bool(*args):
  """lilv_node_is_bool(LilvNode value) -> bool"""
  return _lilv.lilv_node_is_bool(*args)

def lilv_node_as_bool(*args):
  """lilv_node_as_bool(LilvNode value) -> bool"""
  return _lilv.lilv_node_as_bool(*args)

def lilv_plugin_classes_free(*args):
  """lilv_plugin_classes_free(LilvPluginClasses collection)"""
  return _lilv.lilv_plugin_classes_free(*args)

def lilv_plugin_classes_size(*args):
  """lilv_plugin_classes_size(LilvPluginClasses collection) -> unsigned int"""
  return _lilv.lilv_plugin_classes_size(*args)

def lilv_plugin_classes_begin(*args):
  """lilv_plugin_classes_begin(LilvPluginClasses collection) -> LilvIter"""
  return _lilv.lilv_plugin_classes_begin(*args)

def lilv_plugin_classes_get(*args):
  """lilv_plugin_classes_get(LilvPluginClasses collection, LilvIter i) -> LilvPluginClass"""
  return _lilv.lilv_plugin_classes_get(*args)

def lilv_plugin_classes_next(*args):
  """lilv_plugin_classes_next(LilvPluginClasses collection, LilvIter i) -> LilvIter"""
  return _lilv.lilv_plugin_classes_next(*args)

def lilv_plugin_classes_is_end(*args):
  """lilv_plugin_classes_is_end(LilvPluginClasses collection, LilvIter i) -> bool"""
  return _lilv.lilv_plugin_classes_is_end(*args)

def lilv_plugin_classes_get_by_uri(*args):
  """lilv_plugin_classes_get_by_uri(LilvPluginClasses classes, LilvNode uri) -> LilvPluginClass"""
  return _lilv.lilv_plugin_classes_get_by_uri(*args)

def lilv_scale_points_free(*args):
  """lilv_scale_points_free(LilvScalePoints collection)"""
  return _lilv.lilv_scale_points_free(*args)

def lilv_scale_points_size(*args):
  """lilv_scale_points_size(LilvScalePoints collection) -> unsigned int"""
  return _lilv.lilv_scale_points_size(*args)

def lilv_scale_points_begin(*args):
  """lilv_scale_points_begin(LilvScalePoints collection) -> LilvIter"""
  return _lilv.lilv_scale_points_begin(*args)

def lilv_scale_points_get(*args):
  """lilv_scale_points_get(LilvScalePoints collection, LilvIter i) -> LilvScalePoint"""
  return _lilv.lilv_scale_points_get(*args)

def lilv_scale_points_next(*args):
  """lilv_scale_points_next(LilvScalePoints collection, LilvIter i) -> LilvIter"""
  return _lilv.lilv_scale_points_next(*args)

def lilv_scale_points_is_end(*args):
  """lilv_scale_points_is_end(LilvScalePoints collection, LilvIter i) -> bool"""
  return _lilv.lilv_scale_points_is_end(*args)

def lilv_uis_free(*args):
  """lilv_uis_free(LilvUIs collection)"""
  return _lilv.lilv_uis_free(*args)

def lilv_uis_size(*args):
  """lilv_uis_size(LilvUIs collection) -> unsigned int"""
  return _lilv.lilv_uis_size(*args)

def lilv_uis_begin(*args):
  """lilv_uis_begin(LilvUIs collection) -> LilvIter"""
  return _lilv.lilv_uis_begin(*args)

def lilv_uis_get(*args):
  """lilv_uis_get(LilvUIs collection, LilvIter i) -> LilvUI"""
  return _lilv.lilv_uis_get(*args)

def lilv_uis_next(*args):
  """lilv_uis_next(LilvUIs collection, LilvIter i) -> LilvIter"""
  return _lilv.lilv_uis_next(*args)

def lilv_uis_is_end(*args):
  """lilv_uis_is_end(LilvUIs collection, LilvIter i) -> bool"""
  return _lilv.lilv_uis_is_end(*args)

def lilv_uis_get_by_uri(*args):
  """lilv_uis_get_by_uri(LilvUIs uis, LilvNode uri) -> LilvUI"""
  return _lilv.lilv_uis_get_by_uri(*args)

def lilv_nodes_free(*args):
  """lilv_nodes_free(LilvNodes collection)"""
  return _lilv.lilv_nodes_free(*args)

def lilv_nodes_size(*args):
  """lilv_nodes_size(LilvNodes collection) -> unsigned int"""
  return _lilv.lilv_nodes_size(*args)

def lilv_nodes_begin(*args):
  """lilv_nodes_begin(LilvNodes collection) -> LilvIter"""
  return _lilv.lilv_nodes_begin(*args)

def lilv_nodes_get(*args):
  """lilv_nodes_get(LilvNodes collection, LilvIter i) -> LilvNode"""
  return _lilv.lilv_nodes_get(*args)

def lilv_nodes_next(*args):
  """lilv_nodes_next(LilvNodes collection, LilvIter i) -> LilvIter"""
  return _lilv.lilv_nodes_next(*args)

def lilv_nodes_is_end(*args):
  """lilv_nodes_is_end(LilvNodes collection, LilvIter i) -> bool"""
  return _lilv.lilv_nodes_is_end(*args)

def lilv_nodes_get_first(*args):
  """lilv_nodes_get_first(LilvNodes collection) -> LilvNode"""
  return _lilv.lilv_nodes_get_first(*args)

def lilv_nodes_contains(*args):
  """lilv_nodes_contains(LilvNodes values, LilvNode value) -> bool"""
  return _lilv.lilv_nodes_contains(*args)

def lilv_plugins_size(*args):
  """lilv_plugins_size(LilvPlugins collection) -> unsigned int"""
  return _lilv.lilv_plugins_size(*args)

def lilv_plugins_begin(*args):
  """lilv_plugins_begin(LilvPlugins collection) -> LilvIter"""
  return _lilv.lilv_plugins_begin(*args)

def lilv_plugins_get(*args):
  """lilv_plugins_get(LilvPlugins collection, LilvIter i) -> LilvPlugin"""
  return _lilv.lilv_plugins_get(*args)

def lilv_plugins_next(*args):
  """lilv_plugins_next(LilvPlugins collection, LilvIter i) -> LilvIter"""
  return _lilv.lilv_plugins_next(*args)

def lilv_plugins_is_end(*args):
  """lilv_plugins_is_end(LilvPlugins collection, LilvIter i) -> bool"""
  return _lilv.lilv_plugins_is_end(*args)

def lilv_plugins_get_by_uri(*args):
  """lilv_plugins_get_by_uri(LilvPlugins plugins, LilvNode uri) -> LilvPlugin"""
  return _lilv.lilv_plugins_get_by_uri(*args)

def lilv_world_new():
  """lilv_world_new() -> LilvWorld"""
  return _lilv.lilv_world_new()
LILV_OPTION_FILTER_LANG = _lilv.LILV_OPTION_FILTER_LANG
LILV_OPTION_DYN_MANIFEST = _lilv.LILV_OPTION_DYN_MANIFEST

def lilv_world_set_option(*args):
  """lilv_world_set_option(LilvWorld world, char uri, LilvNode value)"""
  return _lilv.lilv_world_set_option(*args)

def lilv_world_free(*args):
  """lilv_world_free(LilvWorld world)"""
  return _lilv.lilv_world_free(*args)

def lilv_world_load_all(*args):
  """lilv_world_load_all(LilvWorld world)"""
  return _lilv.lilv_world_load_all(*args)

def lilv_world_load_bundle(*args):
  """lilv_world_load_bundle(LilvWorld world, LilvNode bundle_uri)"""
  return _lilv.lilv_world_load_bundle(*args)

def lilv_world_get_plugin_class(*args):
  """lilv_world_get_plugin_class(LilvWorld world) -> LilvPluginClass"""
  return _lilv.lilv_world_get_plugin_class(*args)

def lilv_world_get_plugin_classes(*args):
  """lilv_world_get_plugin_classes(LilvWorld world) -> LilvPluginClasses"""
  return _lilv.lilv_world_get_plugin_classes(*args)

def lilv_world_get_all_plugins(*args):
  """lilv_world_get_all_plugins(LilvWorld world) -> LilvPlugins"""
  return _lilv.lilv_world_get_all_plugins(*args)

def lilv_world_find_nodes(*args):
  """
    lilv_world_find_nodes(LilvWorld world, LilvNode subject, LilvNode predicate, 
        LilvNode object) -> LilvNodes
    """
  return _lilv.lilv_world_find_nodes(*args)

def lilv_plugin_verify(*args):
  """lilv_plugin_verify(LilvPlugin plugin) -> bool"""
  return _lilv.lilv_plugin_verify(*args)

def lilv_plugin_get_uri(*args):
  """lilv_plugin_get_uri(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_uri(*args)

def lilv_plugin_get_bundle_uri(*args):
  """lilv_plugin_get_bundle_uri(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_bundle_uri(*args)

def lilv_plugin_get_data_uris(*args):
  """lilv_plugin_get_data_uris(LilvPlugin plugin) -> LilvNodes"""
  return _lilv.lilv_plugin_get_data_uris(*args)

def lilv_plugin_get_library_uri(*args):
  """lilv_plugin_get_library_uri(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_library_uri(*args)

def lilv_plugin_get_name(*args):
  """lilv_plugin_get_name(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_name(*args)

def lilv_plugin_get_class(*args):
  """lilv_plugin_get_class(LilvPlugin plugin) -> LilvPluginClass"""
  return _lilv.lilv_plugin_get_class(*args)

def lilv_plugin_get_value(*args):
  """lilv_plugin_get_value(LilvPlugin p, LilvNode predicate) -> LilvNodes"""
  return _lilv.lilv_plugin_get_value(*args)

def lilv_plugin_has_feature(*args):
  """lilv_plugin_has_feature(LilvPlugin p, LilvNode feature_uri) -> bool"""
  return _lilv.lilv_plugin_has_feature(*args)

def lilv_plugin_get_supported_features(*args):
  """lilv_plugin_get_supported_features(LilvPlugin p) -> LilvNodes"""
  return _lilv.lilv_plugin_get_supported_features(*args)

def lilv_plugin_get_required_features(*args):
  """lilv_plugin_get_required_features(LilvPlugin p) -> LilvNodes"""
  return _lilv.lilv_plugin_get_required_features(*args)

def lilv_plugin_get_optional_features(*args):
  """lilv_plugin_get_optional_features(LilvPlugin p) -> LilvNodes"""
  return _lilv.lilv_plugin_get_optional_features(*args)

def lilv_plugin_get_num_ports(*args):
  """lilv_plugin_get_num_ports(LilvPlugin p) -> uint32_t"""
  return _lilv.lilv_plugin_get_num_ports(*args)

def lilv_plugin_get_port_ranges_float(*args):
  """lilv_plugin_get_port_ranges_float(LilvPlugin p, float min_values, float max_values, float def_values)"""
  return _lilv.lilv_plugin_get_port_ranges_float(*args)

def lilv_plugin_get_num_ports_of_class(*args):
  """lilv_plugin_get_num_ports_of_class(LilvPlugin p, LilvNode class_1, v(...) *args) -> uint32_t"""
  return _lilv.lilv_plugin_get_num_ports_of_class(*args)

def lilv_plugin_has_latency(*args):
  """lilv_plugin_has_latency(LilvPlugin p) -> bool"""
  return _lilv.lilv_plugin_has_latency(*args)

def lilv_plugin_get_latency_port_index(*args):
  """lilv_plugin_get_latency_port_index(LilvPlugin p) -> uint32_t"""
  return _lilv.lilv_plugin_get_latency_port_index(*args)

def lilv_plugin_get_port_by_index(*args):
  """lilv_plugin_get_port_by_index(LilvPlugin plugin, uint32_t index) -> LilvPort"""
  return _lilv.lilv_plugin_get_port_by_index(*args)

def lilv_plugin_get_port_by_symbol(*args):
  """lilv_plugin_get_port_by_symbol(LilvPlugin plugin, LilvNode symbol) -> LilvPort"""
  return _lilv.lilv_plugin_get_port_by_symbol(*args)

def lilv_plugin_get_author_name(*args):
  """lilv_plugin_get_author_name(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_author_name(*args)

def lilv_plugin_get_author_email(*args):
  """lilv_plugin_get_author_email(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_author_email(*args)

def lilv_plugin_get_author_homepage(*args):
  """lilv_plugin_get_author_homepage(LilvPlugin plugin) -> LilvNode"""
  return _lilv.lilv_plugin_get_author_homepage(*args)

def lilv_plugin_is_replaced(*args):
  """lilv_plugin_is_replaced(LilvPlugin plugin) -> bool"""
  return _lilv.lilv_plugin_is_replaced(*args)

def lilv_port_get_value(*args):
  """lilv_port_get_value(LilvPlugin plugin, LilvPort port, LilvNode predicate) -> LilvNodes"""
  return _lilv.lilv_port_get_value(*args)

def lilv_port_get_properties(*args):
  """lilv_port_get_properties(LilvPlugin plugin, LilvPort port) -> LilvNodes"""
  return _lilv.lilv_port_get_properties(*args)

def lilv_port_has_property(*args):
  """lilv_port_has_property(LilvPlugin p, LilvPort port, LilvNode property_uri) -> bool"""
  return _lilv.lilv_port_has_property(*args)

def lilv_port_supports_event(*args):
  """lilv_port_supports_event(LilvPlugin p, LilvPort port, LilvNode event_uri) -> bool"""
  return _lilv.lilv_port_supports_event(*args)

def lilv_port_get_symbol(*args):
  """lilv_port_get_symbol(LilvPlugin plugin, LilvPort port) -> LilvNode"""
  return _lilv.lilv_port_get_symbol(*args)

def lilv_port_get_name(*args):
  """lilv_port_get_name(LilvPlugin plugin, LilvPort port) -> LilvNode"""
  return _lilv.lilv_port_get_name(*args)

def lilv_port_get_classes(*args):
  """lilv_port_get_classes(LilvPlugin plugin, LilvPort port) -> LilvNodes"""
  return _lilv.lilv_port_get_classes(*args)

def lilv_port_is_a(*args):
  """lilv_port_is_a(LilvPlugin plugin, LilvPort port, LilvNode port_class) -> bool"""
  return _lilv.lilv_port_is_a(*args)

def lilv_port_get_range(*args):
  """
    lilv_port_get_range(LilvPlugin plugin, LilvPort port, LilvNode deflt, LilvNode min, 
        LilvNode max)
    """
  return _lilv.lilv_port_get_range(*args)

def lilv_port_get_scale_points(*args):
  """lilv_port_get_scale_points(LilvPlugin plugin, LilvPort port) -> LilvScalePoints"""
  return _lilv.lilv_port_get_scale_points(*args)

def lilv_scale_point_get_label(*args):
  """lilv_scale_point_get_label(LilvScalePoint point) -> LilvNode"""
  return _lilv.lilv_scale_point_get_label(*args)

def lilv_scale_point_get_value(*args):
  """lilv_scale_point_get_value(LilvScalePoint point) -> LilvNode"""
  return _lilv.lilv_scale_point_get_value(*args)

def lilv_plugin_class_get_parent_uri(*args):
  """lilv_plugin_class_get_parent_uri(LilvPluginClass plugin_class) -> LilvNode"""
  return _lilv.lilv_plugin_class_get_parent_uri(*args)

def lilv_plugin_class_get_uri(*args):
  """lilv_plugin_class_get_uri(LilvPluginClass plugin_class) -> LilvNode"""
  return _lilv.lilv_plugin_class_get_uri(*args)

def lilv_plugin_class_get_label(*args):
  """lilv_plugin_class_get_label(LilvPluginClass plugin_class) -> LilvNode"""
  return _lilv.lilv_plugin_class_get_label(*args)

def lilv_plugin_class_get_children(*args):
  """lilv_plugin_class_get_children(LilvPluginClass plugin_class) -> LilvPluginClasses"""
  return _lilv.lilv_plugin_class_get_children(*args)
class LilvInstanceImpl(_object):
    """Proxy of C++ LilvInstanceImpl class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LilvInstanceImpl, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LilvInstanceImpl, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lv2_descriptor"] = _lilv.LilvInstanceImpl_lv2_descriptor_set
    __swig_getmethods__["lv2_descriptor"] = _lilv.LilvInstanceImpl_lv2_descriptor_get
    if _newclass:lv2_descriptor = _swig_property(_lilv.LilvInstanceImpl_lv2_descriptor_get, _lilv.LilvInstanceImpl_lv2_descriptor_set)
    __swig_setmethods__["lv2_handle"] = _lilv.LilvInstanceImpl_lv2_handle_set
    __swig_getmethods__["lv2_handle"] = _lilv.LilvInstanceImpl_lv2_handle_get
    if _newclass:lv2_handle = _swig_property(_lilv.LilvInstanceImpl_lv2_handle_get, _lilv.LilvInstanceImpl_lv2_handle_set)
    __swig_setmethods__["pimpl"] = _lilv.LilvInstanceImpl_pimpl_set
    __swig_getmethods__["pimpl"] = _lilv.LilvInstanceImpl_pimpl_get
    if _newclass:pimpl = _swig_property(_lilv.LilvInstanceImpl_pimpl_get, _lilv.LilvInstanceImpl_pimpl_set)
    def __init__(self): 
        """__init__(self) -> LilvInstanceImpl"""
        this = _lilv.new_LilvInstanceImpl()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lilv.delete_LilvInstanceImpl
    __del__ = lambda self : None;
LilvInstanceImpl_swigregister = _lilv.LilvInstanceImpl_swigregister
LilvInstanceImpl_swigregister(LilvInstanceImpl)


def lilv_plugin_instantiate(*args):
  """lilv_plugin_instantiate(LilvPlugin plugin, double sample_rate, LV2_Feature features) -> LilvInstance"""
  return _lilv.lilv_plugin_instantiate(*args)

def lilv_instance_free(*args):
  """lilv_instance_free(LilvInstance instance)"""
  return _lilv.lilv_instance_free(*args)

def lilv_instance_get_uri(*args):
  """lilv_instance_get_uri(LilvInstance instance) -> char"""
  return _lilv.lilv_instance_get_uri(*args)

def lilv_instance_connect_port(*args):
  """lilv_instance_connect_port(LilvInstance instance, uint32_t port_index, void data_location)"""
  return _lilv.lilv_instance_connect_port(*args)

def lilv_instance_activate(*args):
  """lilv_instance_activate(LilvInstance instance)"""
  return _lilv.lilv_instance_activate(*args)

def lilv_instance_run(*args):
  """lilv_instance_run(LilvInstance instance, uint32_t sample_count)"""
  return _lilv.lilv_instance_run(*args)

def lilv_instance_deactivate(*args):
  """lilv_instance_deactivate(LilvInstance instance)"""
  return _lilv.lilv_instance_deactivate(*args)

def lilv_instance_get_extension_data(*args):
  """lilv_instance_get_extension_data(LilvInstance instance, char uri) -> void"""
  return _lilv.lilv_instance_get_extension_data(*args)

def lilv_instance_get_descriptor(*args):
  """lilv_instance_get_descriptor(LilvInstance instance) -> LV2_Descriptor"""
  return _lilv.lilv_instance_get_descriptor(*args)

def lilv_instance_get_handle(*args):
  """lilv_instance_get_handle(LilvInstance instance) -> LV2_Handle"""
  return _lilv.lilv_instance_get_handle(*args)

def lilv_plugin_get_uis(*args):
  """lilv_plugin_get_uis(LilvPlugin plugin) -> LilvUIs"""
  return _lilv.lilv_plugin_get_uis(*args)

def lilv_ui_get_uri(*args):
  """lilv_ui_get_uri(LilvUI ui) -> LilvNode"""
  return _lilv.lilv_ui_get_uri(*args)

def lilv_ui_get_classes(*args):
  """lilv_ui_get_classes(LilvUI ui) -> LilvNodes"""
  return _lilv.lilv_ui_get_classes(*args)

def lilv_ui_is_a(*args):
  """lilv_ui_is_a(LilvUI ui, LilvNode class_uri) -> bool"""
  return _lilv.lilv_ui_is_a(*args)

def lilv_ui_is_supported(*args):
  """
    lilv_ui_is_supported(LilvUI ui, LilvUISupportedFunc supported_func, LilvNode container_type, 
        LilvNode ui_type) -> unsigned int
    """
  return _lilv.lilv_ui_is_supported(*args)

def lilv_ui_get_bundle_uri(*args):
  """lilv_ui_get_bundle_uri(LilvUI ui) -> LilvNode"""
  return _lilv.lilv_ui_get_bundle_uri(*args)

def lilv_ui_get_binary_uri(*args):
  """lilv_ui_get_binary_uri(LilvUI ui) -> LilvNode"""
  return _lilv.lilv_ui_get_binary_uri(*args)

def uri_to_path(*args):
  """uri_to_path(char uri) -> char"""
  return _lilv.uri_to_path(*args)
class Node(_object):
    """Proxy of C++ Lilv::Node class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Node, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, LilvNode node) -> Node
        __init__(self, Node copy) -> Node
        """
        this = _lilv.new_Node(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lilv.delete_Node
    __del__ = lambda self : None;
    def equals(self, *args):
        """equals(self, Node other) -> bool"""
        return _lilv.Node_equals(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Node other) -> bool"""
        return _lilv.Node___eq__(self, *args)

    def get_turtle_token(self):
        """get_turtle_token(self) -> char"""
        return _lilv.Node_get_turtle_token(self)

    def is_uri(self):
        """is_uri(self) -> bool"""
        return _lilv.Node_is_uri(self)

    def as_uri(self):
        """as_uri(self) -> char"""
        return _lilv.Node_as_uri(self)

    def is_blank(self):
        """is_blank(self) -> bool"""
        return _lilv.Node_is_blank(self)

    def as_blank(self):
        """as_blank(self) -> char"""
        return _lilv.Node_as_blank(self)

    def is_literal(self):
        """is_literal(self) -> bool"""
        return _lilv.Node_is_literal(self)

    def is_string(self):
        """is_string(self) -> bool"""
        return _lilv.Node_is_string(self)

    def as_string(self):
        """as_string(self) -> char"""
        return _lilv.Node_as_string(self)

    def is_float(self):
        """is_float(self) -> bool"""
        return _lilv.Node_is_float(self)

    def as_float(self):
        """as_float(self) -> float"""
        return _lilv.Node_as_float(self)

    def is_int(self):
        """is_int(self) -> bool"""
        return _lilv.Node_is_int(self)

    def as_int(self):
        """as_int(self) -> int"""
        return _lilv.Node_as_int(self)

    def is_bool(self):
        """is_bool(self) -> bool"""
        return _lilv.Node_is_bool(self)

    def as_bool(self):
        """as_bool(self) -> bool"""
        return _lilv.Node_as_bool(self)

    __swig_setmethods__["me"] = _lilv.Node_me_set
    __swig_getmethods__["me"] = _lilv.Node_me_get
    if _newclass:me = _swig_property(_lilv.Node_me_get, _lilv.Node_me_set)
    def __str__(self):
    	return self.get_turtle_token()

Node_swigregister = _lilv.Node_swigregister
Node_swigregister(Node)

class ScalePoint(_object):
    """Proxy of C++ Lilv::ScalePoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScalePoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScalePoint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvScalePoint c_obj) -> ScalePoint"""
        this = _lilv.new_ScalePoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_label(self):
        """get_label(self) -> LilvNode"""
        return _lilv.ScalePoint_get_label(self)

    def get_value(self):
        """get_value(self) -> LilvNode"""
        return _lilv.ScalePoint_get_value(self)

    __swig_setmethods__["me"] = _lilv.ScalePoint_me_set
    __swig_getmethods__["me"] = _lilv.ScalePoint_me_get
    if _newclass:me = _swig_property(_lilv.ScalePoint_me_get, _lilv.ScalePoint_me_set)
    __swig_destroy__ = _lilv.delete_ScalePoint
    __del__ = lambda self : None;
ScalePoint_swigregister = _lilv.ScalePoint_swigregister
ScalePoint_swigregister(ScalePoint)

class PluginClass(_object):
    """Proxy of C++ Lilv::PluginClass class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PluginClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PluginClass, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvPluginClass c_obj) -> PluginClass"""
        this = _lilv.new_PluginClass(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_parent_uri(self):
        """get_parent_uri(self) -> Node"""
        return _lilv.PluginClass_get_parent_uri(self)

    def get_uri(self):
        """get_uri(self) -> Node"""
        return _lilv.PluginClass_get_uri(self)

    def get_label(self):
        """get_label(self) -> Node"""
        return _lilv.PluginClass_get_label(self)

    def get_children(self):
        """get_children(self) -> LilvPluginClasses"""
        return _lilv.PluginClass_get_children(self)

    __swig_setmethods__["me"] = _lilv.PluginClass_me_set
    __swig_getmethods__["me"] = _lilv.PluginClass_me_get
    if _newclass:me = _swig_property(_lilv.PluginClass_me_get, _lilv.PluginClass_me_set)
    __swig_destroy__ = _lilv.delete_PluginClass
    __del__ = lambda self : None;
PluginClass_swigregister = _lilv.PluginClass_swigregister
PluginClass_swigregister(PluginClass)

class PluginClasses(_object):
    """Proxy of C++ Lilv::PluginClasses class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PluginClasses, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PluginClasses, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvPluginClasses c_obj) -> PluginClasses"""
        this = _lilv.new_PluginClasses(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(self) -> unsigned int"""
        return _lilv.PluginClasses_size(self)

    def get(self, *args):
        """get(self, LilvIter i) -> PluginClass"""
        return _lilv.PluginClasses_get(self, *args)

    def begin(self):
        """begin(self) -> LilvIter"""
        return _lilv.PluginClasses_begin(self)

    def next(self, *args):
        """next(self, LilvIter i) -> LilvIter"""
        return _lilv.PluginClasses_next(self, *args)

    def is_end(self, *args):
        """is_end(self, LilvIter i) -> bool"""
        return _lilv.PluginClasses_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.PluginClasses_me_set
    __swig_getmethods__["me"] = _lilv.PluginClasses_me_get
    if _newclass:me = _swig_property(_lilv.PluginClasses_me_get, _lilv.PluginClasses_me_set)
    def get_by_uri(self, *args):
        """get_by_uri(self, LilvNode uri) -> PluginClass"""
        return _lilv.PluginClasses_get_by_uri(self, *args)

    __swig_destroy__ = _lilv.delete_PluginClasses
    __del__ = lambda self : None;
PluginClasses_swigregister = _lilv.PluginClasses_swigregister
PluginClasses_swigregister(PluginClasses)

class ScalePoints(_object):
    """Proxy of C++ Lilv::ScalePoints class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScalePoints, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScalePoints, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvScalePoints c_obj) -> ScalePoints"""
        this = _lilv.new_ScalePoints(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(self) -> unsigned int"""
        return _lilv.ScalePoints_size(self)

    def get(self, *args):
        """get(self, LilvIter i) -> ScalePoint"""
        return _lilv.ScalePoints_get(self, *args)

    def begin(self):
        """begin(self) -> LilvIter"""
        return _lilv.ScalePoints_begin(self)

    def next(self, *args):
        """next(self, LilvIter i) -> LilvIter"""
        return _lilv.ScalePoints_next(self, *args)

    def is_end(self, *args):
        """is_end(self, LilvIter i) -> bool"""
        return _lilv.ScalePoints_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.ScalePoints_me_set
    __swig_getmethods__["me"] = _lilv.ScalePoints_me_get
    if _newclass:me = _swig_property(_lilv.ScalePoints_me_get, _lilv.ScalePoints_me_set)
    __swig_destroy__ = _lilv.delete_ScalePoints
    __del__ = lambda self : None;
ScalePoints_swigregister = _lilv.ScalePoints_swigregister
ScalePoints_swigregister(ScalePoints)

class Nodes(_object):
    """Proxy of C++ Lilv::Nodes class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Nodes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Nodes, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvNodes c_obj) -> Nodes"""
        this = _lilv.new_Nodes(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(self) -> unsigned int"""
        return _lilv.Nodes_size(self)

    def get(self, *args):
        """get(self, LilvIter i) -> Node"""
        return _lilv.Nodes_get(self, *args)

    def begin(self):
        """begin(self) -> LilvIter"""
        return _lilv.Nodes_begin(self)

    def next(self, *args):
        """next(self, LilvIter i) -> LilvIter"""
        return _lilv.Nodes_next(self, *args)

    def is_end(self, *args):
        """is_end(self, LilvIter i) -> bool"""
        return _lilv.Nodes_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.Nodes_me_set
    __swig_getmethods__["me"] = _lilv.Nodes_me_get
    if _newclass:me = _swig_property(_lilv.Nodes_me_get, _lilv.Nodes_me_set)
    def contains(self, *args):
        """contains(self, Node node) -> bool"""
        return _lilv.Nodes_contains(self, *args)

    __swig_destroy__ = _lilv.delete_Nodes
    __del__ = lambda self : None;
Nodes_swigregister = _lilv.Nodes_swigregister
Nodes_swigregister(Nodes)

class Port(_object):
    """Proxy of C++ Lilv::Port class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Port, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Port, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvPlugin p, LilvPort c_obj) -> Port"""
        this = _lilv.new_Port(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """get_value(self, LilvNode predicate) -> LilvNodes"""
        return _lilv.Port_get_value(self, *args)

    def get_properties(self):
        """get_properties(self) -> LilvNodes"""
        return _lilv.Port_get_properties(self)

    def has_property(self, *args):
        """has_property(self, LilvNode property_uri) -> bool"""
        return _lilv.Port_has_property(self, *args)

    def supports_event(self, *args):
        """supports_event(self, LilvNode event_uri) -> bool"""
        return _lilv.Port_supports_event(self, *args)

    def get_symbol(self):
        """get_symbol(self) -> LilvNode"""
        return _lilv.Port_get_symbol(self)

    def get_name(self):
        """get_name(self) -> LilvNode"""
        return _lilv.Port_get_name(self)

    def get_classes(self):
        """get_classes(self) -> LilvNodes"""
        return _lilv.Port_get_classes(self)

    def is_a(self, *args):
        """is_a(self, LilvNode port_class) -> bool"""
        return _lilv.Port_is_a(self, *args)

    def get_scale_points(self):
        """get_scale_points(self) -> LilvScalePoints"""
        return _lilv.Port_get_scale_points(self)

    __swig_setmethods__["parent"] = _lilv.Port_parent_set
    __swig_getmethods__["parent"] = _lilv.Port_parent_get
    if _newclass:parent = _swig_property(_lilv.Port_parent_get, _lilv.Port_parent_set)
    __swig_setmethods__["me"] = _lilv.Port_me_set
    __swig_getmethods__["me"] = _lilv.Port_me_get
    if _newclass:me = _swig_property(_lilv.Port_me_get, _lilv.Port_me_set)
    __swig_destroy__ = _lilv.delete_Port
    __del__ = lambda self : None;
Port_swigregister = _lilv.Port_swigregister
Port_swigregister(Port)

class Plugin(_object):
    """Proxy of C++ Lilv::Plugin class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plugin, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvPlugin c_obj) -> Plugin"""
        this = _lilv.new_Plugin(*args)
        try: self.this.append(this)
        except: self.this = this
    def verify(self):
        """verify(self) -> bool"""
        return _lilv.Plugin_verify(self)

    def get_uri(self):
        """get_uri(self) -> Node"""
        return _lilv.Plugin_get_uri(self)

    def get_bundle_uri(self):
        """get_bundle_uri(self) -> Node"""
        return _lilv.Plugin_get_bundle_uri(self)

    def get_data_uris(self):
        """get_data_uris(self) -> Nodes"""
        return _lilv.Plugin_get_data_uris(self)

    def get_library_uri(self):
        """get_library_uri(self) -> Node"""
        return _lilv.Plugin_get_library_uri(self)

    def get_name(self):
        """get_name(self) -> Node"""
        return _lilv.Plugin_get_name(self)

    def get_class(self):
        """get_class(self) -> PluginClass"""
        return _lilv.Plugin_get_class(self)

    def get_value(self, *args):
        """get_value(self, Node pred) -> Nodes"""
        return _lilv.Plugin_get_value(self, *args)

    def has_feature(self, *args):
        """has_feature(self, Node feature_uri) -> bool"""
        return _lilv.Plugin_has_feature(self, *args)

    def get_supported_features(self):
        """get_supported_features(self) -> Nodes"""
        return _lilv.Plugin_get_supported_features(self)

    def get_required_features(self):
        """get_required_features(self) -> Nodes"""
        return _lilv.Plugin_get_required_features(self)

    def get_optional_features(self):
        """get_optional_features(self) -> Nodes"""
        return _lilv.Plugin_get_optional_features(self)

    def get_num_ports(self):
        """get_num_ports(self) -> unsigned int"""
        return _lilv.Plugin_get_num_ports(self)

    def has_latency(self):
        """has_latency(self) -> bool"""
        return _lilv.Plugin_has_latency(self)

    def get_latency_port_index(self):
        """get_latency_port_index(self) -> unsigned int"""
        return _lilv.Plugin_get_latency_port_index(self)

    def get_author_name(self):
        """get_author_name(self) -> Node"""
        return _lilv.Plugin_get_author_name(self)

    def get_author_email(self):
        """get_author_email(self) -> Node"""
        return _lilv.Plugin_get_author_email(self)

    def get_author_homepage(self):
        """get_author_homepage(self) -> Node"""
        return _lilv.Plugin_get_author_homepage(self)

    def is_replaced(self):
        """is_replaced(self) -> bool"""
        return _lilv.Plugin_is_replaced(self)

    def get_port_by_index(self, *args):
        """get_port_by_index(self, unsigned int index) -> Port"""
        return _lilv.Plugin_get_port_by_index(self, *args)

    def get_port_by_symbol(self, *args):
        """get_port_by_symbol(self, LilvNode symbol) -> Port"""
        return _lilv.Plugin_get_port_by_symbol(self, *args)

    def get_port_ranges_float(self, *args):
        """get_port_ranges_float(self, float min_values, float max_values, float def_values)"""
        return _lilv.Plugin_get_port_ranges_float(self, *args)

    def get_num_ports_of_class(self, *args):
        """get_num_ports_of_class(self, LilvNode class_1, LilvNode class_2) -> unsigned int"""
        return _lilv.Plugin_get_num_ports_of_class(self, *args)

    __swig_setmethods__["me"] = _lilv.Plugin_me_set
    __swig_getmethods__["me"] = _lilv.Plugin_me_get
    if _newclass:me = _swig_property(_lilv.Plugin_me_get, _lilv.Plugin_me_set)
    __swig_destroy__ = _lilv.delete_Plugin
    __del__ = lambda self : None;
Plugin_swigregister = _lilv.Plugin_swigregister
Plugin_swigregister(Plugin)

class Plugins(_object):
    """Proxy of C++ Lilv::Plugins class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plugins, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plugins, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, LilvPlugins c_obj) -> Plugins"""
        this = _lilv.new_Plugins(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(self) -> unsigned int"""
        return _lilv.Plugins_size(self)

    def get(self, *args):
        """get(self, LilvIter i) -> Plugin"""
        return _lilv.Plugins_get(self, *args)

    def begin(self):
        """begin(self) -> LilvIter"""
        return _lilv.Plugins_begin(self)

    def next(self, *args):
        """next(self, LilvIter i) -> LilvIter"""
        return _lilv.Plugins_next(self, *args)

    def is_end(self, *args):
        """is_end(self, LilvIter i) -> bool"""
        return _lilv.Plugins_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.Plugins_me_set
    __swig_getmethods__["me"] = _lilv.Plugins_me_get
    if _newclass:me = _swig_property(_lilv.Plugins_me_get, _lilv.Plugins_me_set)
    def get_by_uri(self, *args):
        """get_by_uri(self, LilvNode uri) -> Plugin"""
        return _lilv.Plugins_get_by_uri(self, *args)

    def __iter__(self):
    	class Iterator(object):
    		def __init__(self, plugins):
    			self.plugins = plugins
    			self.iter    = plugins.begin()
                    
    		def next(self):
    			self.iter = self.plugins.next(self.iter)
    			if not self.plugins.is_end(self.iter):
    				return self.plugins.get(self.iter)
    			else:
    				raise StopIteration

    	return Iterator(self)

    __swig_destroy__ = _lilv.delete_Plugins
    __del__ = lambda self : None;
Plugins_swigregister = _lilv.Plugins_swigregister
Plugins_swigregister(Plugins)

class Instance(_object):
    """Proxy of C++ Lilv::Instance class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Instance, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Instance, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Plugin plugin, double sample_rate) -> Instance"""
        this = _lilv.new_Instance(*args)
        try: self.this.append(this)
        except: self.this = this
    def connect_port(self, *args):
        """connect_port(self, unsigned int port_index, void data_location)"""
        return _lilv.Instance_connect_port(self, *args)

    def activate(self):
        """activate(self)"""
        return _lilv.Instance_activate(self)

    def run(self, *args):
        """run(self, unsigned int sample_count)"""
        return _lilv.Instance_run(self, *args)

    def deactivate(self):
        """deactivate(self)"""
        return _lilv.Instance_deactivate(self)

    def get_descriptor(self):
        """get_descriptor(self) -> LV2_Descriptor"""
        return _lilv.Instance_get_descriptor(self)

    __swig_setmethods__["me"] = _lilv.Instance_me_set
    __swig_getmethods__["me"] = _lilv.Instance_me_get
    if _newclass:me = _swig_property(_lilv.Instance_me_get, _lilv.Instance_me_set)
    __swig_destroy__ = _lilv.delete_Instance
    __del__ = lambda self : None;
Instance_swigregister = _lilv.Instance_swigregister
Instance_swigregister(Instance)

class World(_object):
    """Proxy of C++ Lilv::World class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, World, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, World, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> World"""
        this = _lilv.new_World()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lilv.delete_World
    __del__ = lambda self : None;
    def new_uri(self, *args):
        """new_uri(self, char uri) -> LilvNode"""
        return _lilv.World_new_uri(self, *args)

    def new_string(self, *args):
        """new_string(self, char str) -> LilvNode"""
        return _lilv.World_new_string(self, *args)

    def new_int(self, *args):
        """new_int(self, int val) -> LilvNode"""
        return _lilv.World_new_int(self, *args)

    def new_float(self, *args):
        """new_float(self, float val) -> LilvNode"""
        return _lilv.World_new_float(self, *args)

    def new_bool(self, *args):
        """new_bool(self, bool val) -> LilvNode"""
        return _lilv.World_new_bool(self, *args)

    def find_nodes(self, *args):
        """find_nodes(self, LilvNode subject, LilvNode predicate, LilvNode object) -> Nodes"""
        return _lilv.World_find_nodes(self, *args)

    def set_option(self, *args):
        """set_option(self, char uri, LilvNode value)"""
        return _lilv.World_set_option(self, *args)

    def load_all(self):
        """load_all(self)"""
        return _lilv.World_load_all(self)

    def load_bundle(self, *args):
        """load_bundle(self, LilvNode bundle_uri)"""
        return _lilv.World_load_bundle(self, *args)

    def get_plugin_class(self):
        """get_plugin_class(self) -> LilvPluginClass"""
        return _lilv.World_get_plugin_class(self)

    def get_plugin_classes(self):
        """get_plugin_classes(self) -> LilvPluginClasses"""
        return _lilv.World_get_plugin_classes(self)

    def get_all_plugins(self):
        """get_all_plugins(self) -> Plugins"""
        return _lilv.World_get_all_plugins(self)

    __swig_setmethods__["me"] = _lilv.World_me_set
    __swig_getmethods__["me"] = _lilv.World_me_get
    if _newclass:me = _swig_property(_lilv.World_me_get, _lilv.World_me_set)
World_swigregister = _lilv.World_swigregister
World_swigregister(World)



